@x12i/docify-export 1.0.0 → 1.1.0

package/dist/emit-knowledge.js

@@ -0,0 +1,755 @@
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+function ensureDir(p) {
+    mkdirSync(p, { recursive: true });
+}
+function write(path, body) {
+    ensureDir(dirname(path));
+    writeFileSync(path, body);
+}
+function fm(fields) {
+    const lines = ["---"];
+    for (const [k, v] of Object.entries(fields)) {
+        if (v === undefined || v === null)
+            continue;
+        if (Array.isArray(v)) {
+            if (!v.length)
+                continue;
+            lines.push(`${k}: [${v.map((x) => JSON.stringify(x)).join(", ")}]`);
+        }
+        else if (typeof v === "boolean" || typeof v === "number") {
+            lines.push(`${k}: ${v}`);
+        }
+        else {
+            const s = String(v);
+            lines.push(s.includes("\n") ? `${k}: |\n  ${s.replace(/\n/g, "\n  ")}` : `${k}: ${JSON.stringify(s)}`);
+        }
+    }
+    lines.push("---", "");
+    return lines.join("\n");
+}
+function conceptMd(c, body) {
+    return (fm({
+        id: c.id,
+        type: "concept",
+        title: c.title,
+        summary: c.summary,
+        problem: c.problem,
+        why: c.why,
+        mentalModel: c.mentalModel,
+        audiences: c.audiences,
+        prerequisites: c.prerequisites,
+        related: c.related,
+        next: c.next,
+        version: c.version,
+    }) +
+        `# ${c.title}\n\n` +
+        (body?.trim() ||
+            [
+                c.summary,
+                c.problem ? `## Problem\n\n${c.problem}` : "",
+                c.why ? `## Why\n\n${c.why}` : "",
+                c.mentalModel ? `## Mental model\n\n${c.mentalModel}` : "",
+                c.howItWorks ? `## How it works\n\n${c.howItWorks}` : "",
+            ]
+                .filter(Boolean)
+                .join("\n\n") + "\n"));
+}
+function guideMd(g, body) {
+    const steps = g.steps?.map((s, i) => `${i + 1}. **${s.title}**${s.expectedResult ? ` — ${s.expectedResult}` : ""}`).join("\n") ||
+        "";
+    return (fm({
+        id: g.id,
+        type: "guide",
+        title: g.title,
+        summary: g.summary,
+        why: g.why,
+        audiences: g.audiences,
+        prerequisites: g.prerequisites,
+        related: g.related,
+        invariants: g.invariants,
+        confirmationRequired: g.confirmationRequired,
+        version: g.version,
+    }) +
+        `# ${g.title}\n\n` +
+        (body?.trim() ||
+            [
+                g.summary,
+                g.why ? `## Why this path\n\n${g.why}` : "",
+                g.useWhen?.length ? `## Use this when\n\n${g.useWhen.map((x) => `- ${x}`).join("\n")}` : "",
+                g.doNotUseWhen?.length
+                    ? `## Do not use this when\n\n${g.doNotUseWhen.map((x) => `- ${x}`).join("\n")}`
+                    : "",
+                g.invariants?.length
+                    ? `## Invariants\n\n${g.invariants.map((x) => `- ${x}`).join("\n")}`
+                    : "",
+                steps ? `## Steps\n\n${steps}` : "",
+                g.verification?.length
+                    ? `## Verification\n\n${g.verification.map((x) => `- ${x}`).join("\n")}`
+                    : "",
+            ]
+                .filter(Boolean)
+                .join("\n\n") + "\n"));
+}
+function scenarioMd(s, body) {
+    const paths = s.paths
+        .map((p) => `### ${p.label}\n\n**When:** ${p.when}\n\n${p.rationale ? `${p.rationale}\n\n` : ""}Guides: ${(p.guideIds || []).map((g) => `\`${g}\``).join(", ") || "_none_"}`)
+        .join("\n\n");
+    return (fm({
+        id: s.id,
+        type: "scenario",
+        title: s.title,
+        summary: s.summary,
+        audiences: s.audiences,
+        invariants: s.invariants,
+        version: s.version,
+    }) +
+        `# ${s.title}\n\n` +
+        (body?.trim() ||
+            [
+                `## Situation\n\n${s.situation}`,
+                `## Decision\n\n${s.decisionQuestion}`,
+                s.signals?.length
+                    ? `## Signals\n\n${s.signals.map((x) => `- ${x}`).join("\n")}`
+                    : "",
+                `## Paths\n\n${paths}`,
+                s.escalation ? `## Escalation\n\n${s.escalation}` : "",
+            ]
+                .filter(Boolean)
+                .join("\n\n") + "\n"));
+}
+function diagramMd(d) {
+    const nodes = d.nodes
+        .map((n) => `- **${n.label}** (\`${n.id}\`)${n.description ? `: ${n.description}` : ""}`)
+        .join("\n");
+    const edges = d.edges
+        .map((e) => `- ${e.from} → ${e.to}${e.label ? ` (${e.label})` : ""}`)
+        .join("\n");
+    return (fm({
+        id: d.id,
+        type: "diagram",
+        title: d.title,
+        summary: d.summary,
+        why: d.why,
+        diagramType: d.type,
+        audiences: d.audiences,
+        related: d.related,
+    }) +
+        `# ${d.title}\n\n` +
+        [
+            d.summary,
+            `## Why\n\n${d.why}`,
+            `## How to read\n\n${d.howToRead}`,
+            `## Text alternative\n\n${d.textAlternative}`,
+            nodes ? `## Nodes\n\n${nodes}` : "",
+            edges ? `## Edges\n\n${edges}` : "",
+            d.keyTakeaways?.length
+                ? `## Key takeaways\n\n${d.keyTakeaways.map((x) => `- ${x}`).join("\n")}`
+                : "",
+            d.mermaid ? `## Mermaid source\n\n\`\`\`mermaid\n${d.mermaid}\n\`\`\`` : "",
+        ]
+            .filter(Boolean)
+            .join("\n\n") + "\n");
+}
+function packFiles(type, id, title, summary, markdownPath, related = []) {
+    const packJson = {
+        id: `${type}/${id}`,
+        type,
+        title,
+        summary,
+        markdownPath,
+        files: [markdownPath],
+        related,
+    };
+    const packMd = fm({
+        id: packJson.id,
+        type: "pack",
+        title,
+        summary,
+    }) +
+        `# Pack: ${title}\n\n` +
+        `${summary}\n\n` +
+        `Primary markdown: \`${markdownPath}\`\n`;
+    return { packMd, packJson };
+}
+/**
+ * Emit open Markdown trees, INDEX.md, SEARCH.json, per-type indexes, and packs.
+ * Same explicit source drives human site downloads and agent packages.
+ */
+export function emitOpenKnowledge(opts) {
+    const agentRoot = opts.agentDir ?? join(opts.outDir, "agent");
+    ensureDir(agentRoot);
+    const records = [];
+    const packs = [];
+    const manifestExtras = {
+        concepts: [],
+        guides: [],
+        scenarios: [],
+        decisions: [],
+        glossary: [],
+        visuals: [],
+        diagrams: [],
+        relationships: opts.knowledge.relationships.map((r) => ({
+            id: r.id,
+            type: String(r.type),
+            from: r.from,
+            to: r.to,
+        })),
+        tutorials: [],
+        examples: [],
+        sampleData: [],
+        uiClients: [],
+        apis: [],
+        packs: [],
+        indexes: {
+            indexMd: "INDEX.md",
+            searchJson: "SEARCH.json",
+        },
+    };
+    const k = opts.knowledge;
+    for (const c of k.concepts) {
+        const rel = `concepts/${c.id}.md`;
+        const md = conceptMd(c, k.markdownBodies[`concept:${c.id}`]);
+        write(join(agentRoot, rel), md);
+        const { packMd, packJson } = packFiles("concept", c.id, c.title, c.summary, rel, c.related);
+        write(join(agentRoot, `packs/concept/${c.id}/PACK.md`), packMd);
+        write(join(agentRoot, `packs/concept/${c.id}/pack.json`), JSON.stringify(packJson, null, 2));
+        packs.push(packJson);
+        manifestExtras.concepts.push({ id: c.id, title: c.title, md: rel });
+        manifestExtras.packs.push({
+            id: packJson.id,
+            type: "concept",
+            path: `packs/concept/${c.id}`,
+        });
+        records.push({
+            id: c.id,
+            type: "concept",
+            title: c.title,
+            summary: c.summary,
+            aliases: c.technicalName ? [c.technicalName] : [],
+            audiences: c.audiences,
+            tags: c.tags,
+            goals: [],
+            path: rel,
+            webPath: `/concepts/${c.id}`,
+            prerequisites: c.prerequisites,
+            related: c.related,
+            packIds: [packJson.id],
+        });
+    }
+    for (const g of k.guides) {
+        const rel = `guides/${g.id}.md`;
+        write(join(agentRoot, rel), guideMd(g, k.markdownBodies[`guide:${g.id}`]));
+        const { packMd, packJson } = packFiles("guide", g.id, g.title, g.summary, rel, g.related);
+        write(join(agentRoot, `packs/guide/${g.id}/PACK.md`), packMd);
+        write(join(agentRoot, `packs/guide/${g.id}/pack.json`), JSON.stringify(packJson, null, 2));
+        packs.push(packJson);
+        manifestExtras.guides.push({ id: g.id, title: g.title, md: rel });
+        manifestExtras.packs.push({
+            id: packJson.id,
+            type: "guide",
+            path: `packs/guide/${g.id}`,
+        });
+        records.push({
+            id: g.id,
+            type: "guide",
+            title: g.title,
+            summary: g.summary,
+            aliases: [],
+            audiences: g.audiences,
+            tags: g.tags,
+            goals: g.outcome ? [g.outcome] : [],
+            path: rel,
+            webPath: `/guides/${g.id}`,
+            prerequisites: g.prerequisites,
+            related: g.related,
+            packIds: [packJson.id],
+        });
+    }
+    for (const s of k.scenarios) {
+        const rel = `scenarios/${s.id}.md`;
+        write(join(agentRoot, rel), scenarioMd(s, k.markdownBodies[`scenario:${s.id}`]));
+        const { packMd, packJson } = packFiles("scenario", s.id, s.title, s.summary, rel, s.related);
+        write(join(agentRoot, `packs/scenario/${s.id}/PACK.md`), packMd);
+        write(join(agentRoot, `packs/scenario/${s.id}/pack.json`), JSON.stringify(packJson, null, 2));
+        packs.push(packJson);
+        manifestExtras.scenarios.push({ id: s.id, title: s.title, md: rel });
+        manifestExtras.packs.push({
+            id: packJson.id,
+            type: "scenario",
+            path: `packs/scenario/${s.id}`,
+        });
+        records.push({
+            id: s.id,
+            type: "scenario",
+            title: s.title,
+            summary: s.summary,
+            aliases: [],
+            audiences: s.audiences,
+            tags: s.tags,
+            goals: [s.decisionQuestion],
+            path: rel,
+            webPath: `/scenarios/${s.id}`,
+            prerequisites: s.prerequisites,
+            related: s.related,
+            packIds: [packJson.id],
+        });
+    }
+    for (const d of k.decisions) {
+        const rel = `decisions/${d.id}.md`;
+        const md = fm({
+            id: d.id,
+            type: "decision",
+            title: d.title,
+            summary: d.summary,
+            audiences: d.audiences,
+        }) +
+            `# ${d.title}\n\n${d.summary}\n\n` +
+            (d.recommendedDefault
+                ? `## Recommended default\n\n${d.recommendedDefault}\n\n`
+                : "") +
+            d.options
+                .map((o) => `### ${o.label}${o.recommended ? " (recommended)" : ""}\n\n${o.summary}`)
+                .join("\n\n") +
+            "\n";
+        write(join(agentRoot, rel), md);
+        manifestExtras.decisions.push({ id: d.id, title: d.title, md: rel });
+        records.push({
+            id: d.id,
+            type: "decision",
+            title: d.title,
+            summary: d.summary,
+            aliases: [],
+            audiences: d.audiences,
+            tags: d.tags,
+            goals: [],
+            path: rel,
+            prerequisites: d.prerequisites,
+            related: d.related,
+            packIds: [],
+        });
+    }
+    for (const t of k.glossary) {
+        const rel = `glossary/${t.id}.md`;
+        const md = fm({
+            id: t.id,
+            type: "glossary-term",
+            title: t.term,
+            summary: t.meaning,
+            aliases: t.aliases,
+        }) + `# ${t.term}\n\n${t.meaning}\n`;
+        write(join(agentRoot, rel), md);
+        manifestExtras.glossary.push({ id: t.id, term: t.term, md: rel });
+        records.push({
+            id: t.id,
+            type: "glossary",
+            title: t.term,
+            summary: t.meaning,
+            aliases: t.aliases,
+            audiences: [],
+            tags: [],
+            goals: [],
+            path: rel,
+            prerequisites: [],
+            related: t.relatedConceptIds,
+            packIds: [],
+        });
+    }
+    for (const v of k.visuals) {
+        const rel = `visuals/${v.id}.md`;
+        const md = fm({
+            id: v.id,
+            type: "visual",
+            title: v.caption,
+            summary: v.whyItMatters,
+        }) +
+            `# ${v.caption}\n\n` +
+            `Alt: ${v.alt}\n\n` +
+            `## What to notice\n\n${v.whatToNotice.map((x) => `- ${x}`).join("\n")}\n\n` +
+            `## Why it matters\n\n${v.whyItMatters}\n`;
+        write(join(agentRoot, rel), md);
+        manifestExtras.visuals.push({ id: v.id, title: v.caption, md: rel });
+        records.push({
+            id: v.id,
+            type: "visual",
+            title: v.caption,
+            summary: v.whyItMatters,
+            aliases: [],
+            audiences: [],
+            tags: [],
+            goals: [],
+            path: rel,
+            prerequisites: [],
+            related: v.conceptIds,
+            packIds: [],
+        });
+    }
+    for (const d of k.diagrams) {
+        const rel = `diagrams/${d.id}.md`;
+        write(join(agentRoot, rel), diagramMd(d));
+        if (d.mermaid) {
+            write(join(agentRoot, `diagrams/sources/${d.id}.mmd`), d.mermaid);
+        }
+        else if (d.mermaidPath && existsSync(d.mermaidPath)) {
+            write(join(agentRoot, `diagrams/sources/${d.id}.mmd`), readFileSync(d.mermaidPath, "utf8"));
+        }
+        const source = d.mermaid || d.mermaidPath ? `diagrams/sources/${d.id}.mmd` : undefined;
+        manifestExtras.diagrams.push({
+            id: d.id,
+            title: d.title,
+            md: rel,
+            source,
+        });
+        records.push({
+            id: d.id,
+            type: "diagram",
+            title: d.title,
+            summary: d.summary,
+            aliases: [],
+            audiences: d.audiences,
+            tags: d.tags,
+            goals: [],
+            path: rel,
+            webPath: `/diagrams/${d.id}`,
+            prerequisites: [],
+            related: d.related,
+            packIds: [],
+        });
+    }
+    for (const t of k.tutorials) {
+        const rel = `tutorials/${t.id}.md`;
+        const md = fm({
+            id: t.id,
+            type: "tutorial",
+            title: t.title,
+            summary: t.summary,
+            audiences: t.audiences,
+        }) +
+            `# ${t.title}\n\n${t.summary}\n\n` +
+            t.steps
+                .map((s, i) => `## ${i + 1}. ${s.title}\n\n${s.body ?? s.command ?? ""}`)
+                .join("\n\n") +
+            "\n";
+        write(join(agentRoot, rel), md);
+        const { packMd, packJson } = packFiles("tutorial", t.id, t.title, t.summary, rel, t.related);
+        write(join(agentRoot, `packs/tutorial/${t.id}/PACK.md`), packMd);
+        write(join(agentRoot, `packs/tutorial/${t.id}/pack.json`), JSON.stringify(packJson, null, 2));
+        packs.push(packJson);
+        manifestExtras.tutorials.push({ id: t.id, title: t.title, md: rel });
+        manifestExtras.packs.push({
+            id: packJson.id,
+            type: "tutorial",
+            path: `packs/tutorial/${t.id}`,
+        });
+        records.push({
+            id: t.id,
+            type: "tutorial",
+            title: t.title,
+            summary: t.summary,
+            aliases: [],
+            audiences: t.audiences,
+            tags: t.tags,
+            goals: t.outcome ? [t.outcome] : [],
+            path: rel,
+            prerequisites: t.prerequisites,
+            related: t.related,
+            packIds: [packJson.id],
+        });
+    }
+    for (const e of k.examples) {
+        const rel = `examples/${e.id}.md`;
+        const md = fm({
+            id: e.id,
+            type: "example",
+            title: e.title,
+            summary: e.purpose,
+        }) + `# ${e.title}\n\n${e.purpose}\n\n${e.explanation ?? ""}\n`;
+        write(join(agentRoot, rel), md);
+        manifestExtras.examples.push({ id: e.id, title: e.title, md: rel });
+        records.push({
+            id: e.id,
+            type: "example",
+            title: e.title,
+            summary: e.purpose,
+            aliases: [],
+            audiences: e.audiences,
+            tags: [],
+            goals: [],
+            path: rel,
+            prerequisites: [],
+            related: e.conceptIds,
+            packIds: [],
+        });
+    }
+    for (const ds of k.sampleData) {
+        const rel = `sample-data/${ds.id}.md`;
+        const md = fm({
+            id: ds.id,
+            type: "sample-data",
+            title: ds.id,
+            summary: ds.purpose,
+            version: ds.version,
+            origin: ds.origin,
+        }) + `# Sample data: ${ds.id}\n\n${ds.purpose}\n\nOrigin: ${ds.origin}\n`;
+        write(join(agentRoot, rel), md);
+        manifestExtras.sampleData.push({
+            id: ds.id,
+            title: ds.id,
+            md: rel,
+        });
+        records.push({
+            id: ds.id,
+            type: "sample-data",
+            title: ds.id,
+            summary: ds.purpose,
+            aliases: [],
+            audiences: [],
+            tags: [],
+            goals: [],
+            path: rel,
+            prerequisites: [],
+            related: [],
+            packIds: [],
+        });
+    }
+    for (const client of k.uiClients) {
+        const rel = `ui/clients/${client.id}.md`;
+        const md = fm({
+            id: client.id,
+            type: "ui-client",
+            title: client.title,
+            summary: client.summary,
+        }) + `# ${client.title}\n\n${client.summary}\n`;
+        write(join(agentRoot, rel), md);
+        manifestExtras.uiClients.push({
+            id: client.id,
+            title: client.title,
+            md: rel,
+        });
+        records.push({
+            id: client.id,
+            type: "ui-client",
+            title: client.title,
+            summary: client.summary,
+            aliases: [],
+            audiences: client.audiences,
+            tags: [],
+            goals: [],
+            path: rel,
+            prerequisites: [],
+            related: [],
+            packIds: [],
+        });
+    }
+    for (const api of k.apis) {
+        const rel = `apis/${api.id}/overview.md`;
+        const md = fm({
+            id: api.id,
+            type: "api",
+            title: api.title,
+            summary: api.summary,
+            why: api.why,
+        }) +
+            `# ${api.title}\n\n${api.summary}\n\n` +
+            (api.why ? `## Why\n\n${api.why}\n\n` : "") +
+            api.operations
+                .map((op) => `## ${op.method} ${op.path}\n\n${op.summary}`)
+                .join("\n\n") +
+            "\n";
+        write(join(agentRoot, rel), md);
+        manifestExtras.apis.push({ id: api.id, title: api.title, md: rel });
+        records.push({
+            id: api.id,
+            type: "api",
+            title: api.title,
+            summary: api.summary,
+            aliases: [],
+            audiences: api.audiences,
+            tags: [],
+            goals: [],
+            path: rel,
+            prerequisites: [],
+            related: api.related,
+            packIds: [],
+        });
+    }
+    // Use cases into open tree
+    for (const uc of opts.useCases.useCases) {
+        records.push({
+            id: uc.id,
+            type: "use-case",
+            title: uc.title,
+            summary: uc.expectedOutcome ?? uc.goal,
+            aliases: [],
+            audiences: uc.audiences,
+            tags: uc.tags,
+            goals: [uc.goal],
+            path: `use-cases/${uc.id}.md`,
+            webPath: `/use-cases#${uc.id}`,
+            prerequisites: uc.prerequisites ?? [],
+            related: uc.alsoSee ?? [],
+            packIds: [`use-case/${uc.id}`],
+        });
+    }
+    for (const book of opts.catalog.books) {
+        records.push({
+            id: book.id,
+            type: "book",
+            title: book.title,
+            summary: book.blurb,
+            aliases: [book.kicker],
+            audiences: book.audiences,
+            tags: book.tags,
+            goals: [],
+            path: `books/${book.id}/`,
+            webPath: `/books/${book.id}`,
+            prerequisites: [],
+            related: [],
+            packIds: [],
+        });
+    }
+    const search = {
+        version: 1,
+        product: opts.site.product,
+        generatedAt: new Date().toISOString(),
+        records,
+    };
+    write(join(agentRoot, "SEARCH.json"), JSON.stringify(search, null, 2));
+    const indexLines = [
+        `# ${opts.site.product} — knowledge index`,
+        "",
+        `Package: \`${opts.site.knowledgePackage}\``,
+        "",
+        "## How to choose",
+        "",
+        "- **Concept** — what it is and why it exists",
+        "- **Guide** — bounded task procedure",
+        "- **Scenario** — state + evidence → which path",
+        "- **Use case** — end-to-end outcome",
+        "- **Tutorial** — learn by doing",
+        "- **Decision** — options and recommended default",
+        "- **Reference / API** — exact technical detail",
+        "",
+        "## Manifest and search",
+        "",
+        "- `agent-manifest.json`",
+        "- `SEARCH.json`",
+        "",
+    ];
+    const sections = [
+        [
+            "Concepts",
+            k.concepts.map((c) => ({
+                id: c.id,
+                title: c.title,
+                summary: c.summary,
+                path: `concepts/${c.id}.md`,
+            })),
+        ],
+        [
+            "Guides",
+            k.guides.map((g) => ({
+                id: g.id,
+                title: g.title,
+                summary: g.summary,
+                path: `guides/${g.id}.md`,
+            })),
+        ],
+        [
+            "Scenarios",
+            k.scenarios.map((s) => ({
+                id: s.id,
+                title: s.title,
+                summary: s.summary,
+                path: `scenarios/${s.id}.md`,
+            })),
+        ],
+        [
+            "Diagrams",
+            k.diagrams.map((d) => ({
+                id: d.id,
+                title: d.title,
+                summary: d.summary,
+                path: `diagrams/${d.id}.md`,
+            })),
+        ],
+        [
+            "Tutorials",
+            k.tutorials.map((t) => ({
+                id: t.id,
+                title: t.title,
+                summary: t.summary,
+                path: `tutorials/${t.id}.md`,
+            })),
+        ],
+    ];
+    for (const [heading, items] of sections) {
+        indexLines.push(`## ${heading}`, "");
+        if (!items.length) {
+            indexLines.push("_None authored yet._", "");
+            continue;
+        }
+        for (const item of items) {
+            indexLines.push(`- \`${item.id}\` — **${item.title}** — ${item.summary} — [${item.path}](${item.path})`);
+        }
+        indexLines.push("");
+    }
+    const indexMd = indexLines.join("\n");
+    write(join(agentRoot, "INDEX.md"), indexMd);
+    // Per-type indexes
+    const writeTypeIndex = (name, items) => {
+        write(join(agentRoot, "indexes", `${name}.json`), JSON.stringify({ version: 1, items }, null, 2));
+        write(join(agentRoot, "indexes", `${name}.md`), `# ${name}\n\n` +
+            items.map((i) => `- \`${i.id}\` — ${i.title} — ${i.summary}`).join("\n") +
+            "\n");
+    };
+    writeTypeIndex("concepts", k.concepts.map((c) => ({
+        id: c.id,
+        title: c.title,
+        summary: c.summary,
+        path: `concepts/${c.id}.md`,
+    })));
+    writeTypeIndex("guides", k.guides.map((g) => ({
+        id: g.id,
+        title: g.title,
+        summary: g.summary,
+        path: `guides/${g.id}.md`,
+    })));
+    writeTypeIndex("scenarios", k.scenarios.map((s) => ({
+        id: s.id,
+        title: s.title,
+        summary: s.summary,
+        path: `scenarios/${s.id}.md`,
+    })));
+    writeTypeIndex("diagrams", k.diagrams.map((d) => ({
+        id: d.id,
+        title: d.title,
+        summary: d.summary,
+        path: `diagrams/${d.id}.md`,
+    })));
+    writeTypeIndex("use-cases", opts.useCases.useCases.map((u) => ({
+        id: u.id,
+        title: u.title,
+        summary: u.goal,
+        path: `use-cases/${u.id}.md`,
+    })));
+    writeTypeIndex("tutorials", k.tutorials.map((t) => ({
+        id: t.id,
+        title: t.title,
+        summary: t.summary,
+        path: `tutorials/${t.id}.md`,
+    })));
+    writeTypeIndex("books", opts.catalog.books.map((b) => ({
+        id: b.id,
+        title: b.title,
+        summary: b.blurb,
+        path: `books/${b.id}/`,
+    })));
+    // Also expose INDEX/SEARCH at bundle root for web downloads
+    write(join(opts.outDir, "INDEX.md"), indexMd);
+    write(join(opts.outDir, "SEARCH.json"), JSON.stringify(search, null, 2));
+    write(join(opts.outDir, "agent", "INDEX.md"), indexMd);
+    // agent tree already under agentRoot; if agentRoot is outDir/agent we're good
+    return { search, indexMd, packs, manifestExtras };
+}
+//# sourceMappingURL=emit-knowledge.js.map