@friehub/blueprint 0.1.0

package/dist/core/scanner.js

@@ -0,0 +1,163 @@
+import { SECTION_DEFINITIONS, normalizeSectionHeader } from "./sections.js";
+const H1_RE = /^#\s+(.+)$/;
+const H3_RE = /^###\s+(.+)$/;
+const H2_RE = /^##\s+(.+)$/;
+const SEPARATOR_RE = /^---\s*$/;
+export function scanDocument(file, text) {
+    const lines = text.split(/\r?\n/);
+    const source = { file, startLine: 1, endLine: Math.max(1, lines.length) };
+    const envelope = parseEnvelope(file, lines);
+    const sections = [];
+    let preambleStart = -1;
+    let preambleEnd = -1;
+    let currentSection = null;
+    let seenFirstKnownSection = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const lineNumber = index + 1;
+        const trimmed = line.trim();
+        if (lineNumber === envelope.titleLine || SEPARATOR_RE.test(trimmed)) {
+            continue;
+        }
+        const sectionHeader = detectSectionHeader(trimmed, envelope.kind);
+        if (sectionHeader) {
+            if (!seenFirstKnownSection) {
+                seenFirstKnownSection = true;
+            }
+            if (currentSection) {
+                currentSection.endLine = lineNumber - 1;
+                sections.push(currentSection);
+            }
+            currentSection = {
+                file,
+                name: sectionHeader.name,
+                aliases: sectionHeader.aliases,
+                kind: sectionHeader.kind,
+                content: sectionHeader.inlineContent ? `${sectionHeader.inlineContent}\n` : "",
+                startLine: lineNumber,
+                endLine: lineNumber,
+            };
+            continue;
+        }
+        if (!seenFirstKnownSection) {
+            if (trimmed) {
+                if (preambleStart === -1)
+                    preambleStart = lineNumber;
+                preambleEnd = lineNumber;
+            }
+            continue;
+        }
+        if (currentSection) {
+            currentSection.content += line + "\n";
+            currentSection.endLine = lineNumber;
+        }
+    }
+    if (currentSection) {
+        sections.push(currentSection);
+    }
+    const preamble = preambleStart === -1
+        ? null
+        : {
+            content: lines.slice(preambleStart - 1, preambleEnd).join("\n").trim(),
+            startLine: preambleStart,
+            endLine: preambleEnd,
+        };
+    return {
+        envelope,
+        preamble,
+        sections,
+        source,
+    };
+}
+function parseEnvelope(file, lines) {
+    const kind = /(^|[\\/])core([\\/]|$)/.test(file) ? "core" : "module";
+    const headingLine = lines.findIndex((line) => /^#{1,3}\s+/.test(line.trim()));
+    const titleLine = headingLine === -1 ? 1 : headingLine + 1;
+    const titleText = headingLine === -1 ? basenameWithoutExtension(file) : lines[headingLine].trim().replace(/^#{1,3}\s+/, "");
+    if (headingLine === -1) {
+        return {
+            kind,
+            name: basenameWithoutExtension(file),
+            title: basenameWithoutExtension(file),
+            titleLine,
+            source: { file, startLine: 1, endLine: 1 },
+        };
+    }
+    if (kind === "module") {
+        const nameMatch = titleText.match(/`([^`]+)`/) ?? titleText.match(/Module Contract:\s*(.+)$/i);
+        return {
+            kind,
+            name: (nameMatch?.[1] ?? basenameWithoutExtension(file)).trim(),
+            title: titleText,
+            titleLine,
+            source: { file, startLine: 1, endLine: 1 },
+        };
+    }
+    return {
+        kind,
+        name: basenameWithoutExtension(file),
+        title: titleText,
+        titleLine,
+        source: { file, startLine: 1, endLine: 1 },
+    };
+}
+function detectSectionHeader(trimmedLine, kind) {
+    const inlineMatch = matchKnownHeaderWithInlineContent(trimmedLine);
+    if (inlineMatch)
+        return inlineMatch;
+    const headingText = trimmedLine.replace(/^#{2,3}\s+/, "").trim();
+    const normalized = normalizeSectionHeader(headingText);
+    if (normalized) {
+        return {
+            name: normalized,
+            aliases: [],
+            kind: "known",
+        };
+    }
+    if (H2_RE.test(trimmedLine)) {
+        return {
+            name: headingText,
+            aliases: [],
+            kind: "unknown",
+        };
+    }
+    if (H3_RE.test(trimmedLine)) {
+        if (kind === "core") {
+            return {
+                name: headingText,
+                aliases: [],
+                kind: "unknown",
+            };
+        }
+        return null;
+    }
+    return null;
+}
+function matchKnownHeaderWithInlineContent(line) {
+    for (const definition of SECTION_DEFINITIONS) {
+        const candidates = [definition.header, ...definition.aliases];
+        for (const candidate of candidates) {
+            const lowerCandidate = candidate.toLowerCase();
+            const lowerLine = line.toLowerCase();
+            if (!lowerLine.startsWith(lowerCandidate))
+                continue;
+            const remainder = line.slice(candidate.length).trim();
+            if (remainder && !/^\s/.test(line.slice(candidate.length, candidate.length + 1))) {
+                // If the next character is not whitespace, it's likely a different token.
+                continue;
+            }
+            return {
+                name: definition.name,
+                aliases: [candidate],
+                kind: "known",
+                inlineContent: remainder,
+            };
+        }
+    }
+    return null;
+}
+function basenameWithoutExtension(file) {
+    const parts = file.split(/[\\/]/);
+    const filename = parts[parts.length - 1] ?? file;
+    return filename.replace(/\.md$/i, "");
+}

package/dist/core/search.js

@@ -0,0 +1,34 @@
+export function searchModules(catalog, query) {
+    const results = [];
+    const q = query.toLowerCase();
+    for (const mod of catalog.modules) {
+        let score = 0;
+        let matchType = "summary";
+        if (mod.name.toLowerCase() === q) {
+            score = 100;
+            matchType = "name";
+        }
+        else if (mod.name.toLowerCase().includes(q)) {
+            score = 80;
+            matchType = "name";
+        }
+        else if (mod.summary?.toLowerCase().includes(q)) {
+            score = 60;
+            matchType = "summary";
+        }
+        else {
+            for (const fn of mod.functions) {
+                if (fn.name.toLowerCase().includes(q)) {
+                    score = 40;
+                    matchType = "function";
+                    break;
+                }
+            }
+        }
+        if (score > 0) {
+            results.push({ module: mod, score, matchType });
+        }
+    }
+    results.sort((a, b) => b.score - a.score || a.module.name.localeCompare(b.module.name));
+    return results;
+}

package/dist/core/search.test.js

@@ -0,0 +1,43 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { loadCatalogFromRoot } from "./index.js";
+import { searchModules } from "./search.js";
+import { fileURLToPath } from "node:url";
+const ROOT = fileURLToPath(new URL("../../", import.meta.url));
+describe("search", () => {
+    it("finds modules by exact name", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const results = searchModules(result.value, "billing");
+        assert.ok(results.length > 0);
+        assert.equal(results[0].module.name, "billing");
+        assert.equal(results[0].score, 100);
+    });
+    it("finds modules by partial name", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const results = searchModules(result.value, "bill");
+        assert.ok(results.length > 0);
+        assert.ok(results.some((r) => r.module.name === "billing"));
+    });
+    it("finds modules by summary", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const results = searchModules(result.value, "subscription");
+        assert.ok(results.length > 0);
+        assert.ok(results.some((r) => r.module.name === "billing"));
+    });
+    it("returns empty for no matches", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const results = searchModules(result.value, "zzzznonexistent");
+        assert.equal(results.length, 0);
+    });
+    it("sorts by score", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        assert.notEqual(result.value, null);
+        const results = searchModules(result.value, "payment");
+        assert.ok(results.length > 1);
+        assert.equal(results[0].module.name, "payments");
+    });
+});

package/dist/core/section-body.js

@@ -0,0 +1,258 @@
+const FENCED_BLOCK_RE = /^```(?:[a-zA-Z0-9_-]+)?\s*$/;
+const FUNCTION_SIGNATURE_RE = /^([A-Za-z_][A-Za-z0-9_]*)(?:<[^>]+>)?\s*\((.*)\)\s*→\s*(.+)$/;
+const TYPE_ALIAS_RE = /^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+)$/;
+const TYPE_RECORD_RE = /^([A-Za-z_][A-Za-z0-9_]*)\s*\{\s*(.+)\s*\}$/;
+export function classifySectionBody(text, startLine, endLine) {
+    const lines = text.split(/\r?\n/);
+    const nonEmpty = lines.filter((line) => line.trim().length > 0);
+    const hasFence = nonEmpty.some((line) => FENCED_BLOCK_RE.test(line.trim()));
+    const hasBullets = nonEmpty.some((line) => /^[-*+]\s+/.test(line.trim()));
+    if (hasFence && hasBullets) {
+        return { kind: "mixed", raw: text, lines, startLine, endLine };
+    }
+    if (hasFence) {
+        return { kind: "fenced", raw: text, lines, startLine, endLine };
+    }
+    if (hasBullets) {
+        return { kind: "bullets", raw: text, lines, startLine, endLine };
+    }
+    if (nonEmpty.length > 1) {
+        return { kind: "paragraphs", raw: text, lines, startLine, endLine };
+    }
+    return { kind: "raw", raw: text, lines, startLine, endLine };
+}
+export function parseFunctionSignatureLine(line, source) {
+    const trimmed = line.trim().replace(/^#{2,3}\s+/, "").replace(/^`(.+)`$/, "$1");
+    if (!trimmed)
+        return null;
+    const match = trimmed.match(FUNCTION_SIGNATURE_RE);
+    if (!match)
+        return null;
+    const [, name = "", paramsRaw = "", returns = ""] = match;
+    const params = paramsRaw.trim() ? parseParameters(paramsRaw) : [];
+    return {
+        name,
+        params,
+        returns: returns.trim(),
+        signature: trimmed,
+        raw: line,
+        source,
+    };
+}
+export function parseTypeLine(line, source) {
+    const trimmed = line.trim().replace(/^#{2,3}\s+/, "");
+    if (!trimmed)
+        return null;
+    const typeKeyword = trimmed.match(/^type\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+)$/);
+    if (typeKeyword) {
+        return {
+            name: typeKeyword[1] ?? "",
+            raw: trimmed,
+            source,
+        };
+    }
+    const interfaceKeyword = trimmed.match(/^interface\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{/);
+    if (interfaceKeyword) {
+        return {
+            name: interfaceKeyword[1] ?? "",
+            raw: trimmed,
+            source,
+        };
+    }
+    const alias = trimmed.match(TYPE_ALIAS_RE);
+    if (alias) {
+        return {
+            name: alias[1] ?? "",
+            raw: trimmed,
+            source,
+        };
+    }
+    const record = trimmed.match(TYPE_RECORD_RE);
+    if (record) {
+        return {
+            name: record[1] ?? "",
+            raw: trimmed,
+            source,
+        };
+    }
+    return null;
+}
+export function collectMultiLineTypes(body, source) {
+    const items = [];
+    const lines = body.lines;
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i].trim();
+        if (!line || line.startsWith("```") || /^[-*+]\s+/.test(line)) {
+            i++;
+            continue;
+        }
+        const typeMatch = line.match(/^type\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\{/);
+        if (typeMatch) {
+            const name = typeMatch[1] ?? "";
+            const startLine = i;
+            let raw = line;
+            let braceDepth = 1;
+            i++;
+            while (i < lines.length && braceDepth > 0) {
+                const nextLine = lines[i].trim();
+                raw += "\n" + nextLine;
+                for (const ch of nextLine) {
+                    if (ch === "{")
+                        braceDepth++;
+                    if (ch === "}")
+                        braceDepth--;
+                }
+                if (braceDepth === 0)
+                    break;
+                i++;
+            }
+            items.push({
+                name,
+                raw,
+                source: {
+                    file: source.file,
+                    startLine: source.startLine + startLine,
+                    endLine: source.startLine + i,
+                },
+            });
+            i++;
+            continue;
+        }
+        const parsed = parseTypeLine(line, {
+            file: source.file,
+            startLine: source.startLine + i,
+            endLine: source.startLine + i,
+        });
+        if (parsed)
+            items.push(parsed);
+        i++;
+    }
+    return items;
+}
+export function parseParameters(paramsRaw) {
+    return splitTopLevel(paramsRaw, ",")
+        .map((chunk) => chunk.trim())
+        .filter(Boolean)
+        .map((chunk) => {
+        const [left, defaultValue] = splitOnce(chunk, "=");
+        const [namePart, typePart] = splitOnce(left.trim(), ":");
+        const optional = namePart.trim().endsWith("?");
+        const name = namePart.trim().replace(/\?$/, "");
+        const parameter = {
+            name,
+            type: typePart ? typePart.trim() : inferParamType(name),
+            optional,
+        };
+        if (defaultValue !== undefined) {
+            parameter.defaultValue = defaultValue.trim();
+        }
+        return parameter;
+    });
+}
+export function splitOnce(input, delimiter) {
+    const index = input.indexOf(delimiter);
+    if (index === -1)
+        return [input, undefined];
+    return [input.slice(0, index), input.slice(index + delimiter.length)];
+}
+export function splitTopLevel(input, delimiter) {
+    const parts = [];
+    let current = "";
+    let depth = 0;
+    const delimiterChar = delimiter[0] ?? ",";
+    for (const ch of input) {
+        if (ch === "<" || ch === "(" || ch === "[")
+            depth += 1;
+        if (ch === ">" || ch === ")" || ch === "]")
+            depth = Math.max(0, depth - 1);
+        if (ch === delimiterChar && depth === 0) {
+            parts.push(current);
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    if (current.length > 0)
+        parts.push(current);
+    return parts;
+}
+export function parseSectionBody(section, body, source) {
+    if (section === "functions") {
+        const items = parseBodyLines(body, source, parseFunctionSignatureLine);
+        return { kind: "functions", items, raw: body.raw, source };
+    }
+    if (section === "types") {
+        const items = collectMultiLineTypes(body, source);
+        return { kind: "types", items, raw: body.raw, source };
+    }
+    return {
+        kind: "text",
+        items: body.lines.map((line) => line.trim()).filter(Boolean),
+        raw: body.raw,
+        source,
+    };
+}
+function parseBodyLines(body, source, parser) {
+    const items = [];
+    const lines = body.lines;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index].trim();
+        if (!line)
+            continue;
+        if (line.startsWith("```") || /^[-*+]\s+/.test(line))
+            continue;
+        const parsed = parser(line, {
+            file: source.file,
+            startLine: body.startLine + index,
+            endLine: body.startLine + index,
+        });
+        if (parsed)
+            items.push(parsed);
+    }
+    return items;
+}
+function inferParamType(paramName) {
+    const rules = [
+        { pattern: /^id$/i, type: "string" },
+        { pattern: /_id$/i, type: "string" },
+        { pattern: /_at$/i, type: "Timestamp" },
+        { pattern: /_count$/i, type: "number" },
+        { pattern: /_amount$/i, type: "number" },
+        { pattern: /_price$/i, type: "number" },
+        { pattern: /_total$/i, type: "number" },
+        { pattern: /is_/i, type: "boolean" },
+        { pattern: /has_/i, type: "boolean" },
+        { pattern: /_status$/i, type: "string" },
+        { pattern: /_type$/i, type: "string" },
+        { pattern: /_name$/i, type: "string" },
+        { pattern: /_url$/i, type: "string" },
+        { pattern: /_email$/i, type: "string" },
+        { pattern: /_key$/i, type: "string" },
+        { pattern: /_token$/i, type: "string" },
+        { pattern: /_data$/i, type: "Record<string, unknown>" },
+        { pattern: /_metadata$/i, type: "Record<string, unknown>" },
+        { pattern: /_options$/i, type: "Record<string, unknown>" },
+        { pattern: /^input$/i, type: "unknown" },
+        { pattern: /^context$/i, type: "Record<string, unknown>" },
+        { pattern: /^reason$/i, type: "string" },
+        { pattern: /^currency$/i, type: "string" },
+        { pattern: /^period$/i, type: "string" },
+        { pattern: /^filters$/i, type: "Record<string, unknown>" },
+        { pattern: /^code$/i, type: "string" },
+        { pattern: /^message$/i, type: "string" },
+        { pattern: /^content$/i, type: "string" },
+        { pattern: /^status$/i, type: "string" },
+        { pattern: /^method$/i, type: "string" },
+        { pattern: /_method$/i, type: "string" },
+        { pattern: /^reference$/i, type: "string" },
+        { pattern: /^amount$/i, type: "number" },
+        { pattern: /balance/i, type: "number" },
+        { pattern: /[Rr]eference$/i, type: "string" },
+    ];
+    for (const rule of rules) {
+        if (rule.pattern.test(paramName))
+            return rule.type;
+    }
+    return "unknown";
+}

package/dist/core/sections.js

@@ -0,0 +1,53 @@
+export const SECTION_DEFINITIONS = [
+    {
+        name: "functions",
+        header: "Functions",
+        aliases: ["**Functions**"],
+        requiredForModule: true,
+    },
+    {
+        name: "types",
+        header: "Types",
+        aliases: ["**Types**"],
+        requiredForModule: true,
+    },
+    {
+        name: "invariants",
+        header: "Invariants",
+        aliases: ["**Invariants**"],
+        requiredForModule: false,
+    },
+    {
+        name: "providers",
+        header: "Providers",
+        aliases: ["**Providers:**"],
+        requiredForModule: false,
+    },
+    {
+        name: "system-integrations",
+        header: "System-Level Integrations",
+        aliases: ["System-Level Integrations & Constraints"],
+        requiredForModule: false,
+    },
+];
+export const SECTION_BY_HEADER = new Map(SECTION_DEFINITIONS.flatMap((definition) => [
+    [definition.header.toLowerCase(), definition],
+    ...definition.aliases.map((alias) => [alias.toLowerCase(), definition]),
+]));
+export function normalizeSectionHeader(header) {
+    const variants = [
+        header,
+        header.trim(),
+        header.trim().replace(/^\*\*(.+)\*\*$/, "$1"),
+        header.trim().replace(/^\*\*(.+)\*\*$/, "$1").replace(/:$/, ""),
+    ];
+    for (const variant of variants) {
+        const definition = SECTION_BY_HEADER.get(variant.toLowerCase());
+        if (definition)
+            return definition.name;
+    }
+    return null;
+}
+export function isRequiredModuleSection(name) {
+    return SECTION_DEFINITIONS.some((definition) => definition.name === name && definition.requiredForModule);
+}

package/dist/core/verify-implement.test.js

@@ -0,0 +1,123 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { verifyImplementation } from "./verify.js";
+import { generateImplementPrompts } from "./implement.js";
+import { loadCatalogFromRoot } from "./load-catalog.js";
+import { loadAdapters } from "./adapters/load.js";
+import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+const ROOT = fileURLToPath(new URL("../../", import.meta.url));
+describe("verify edge cases", () => {
+    it("handles file not found", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        const verify = await verifyImplementation("/tmp/nonexistent-file.ts", "payments", result.value);
+        assert.equal(verify.valid, false);
+        assert.ok(verify.issues.some((i) => i.kind === "file-not-found"));
+    });
+    it("handles unknown module", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        const verify = await verifyImplementation("/tmp/any-file.ts", "nonexistent-module", result.value);
+        assert.equal(verify.valid, false);
+        assert.equal(verify.issues[0].kind, "file-not-found");
+    });
+    it("detects missing functions", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        const verify = await verifyImplementation("/tmp/any-file.ts", "billing", result.value);
+        assert.equal(verify.valid, false);
+        assert.ok(verify.issues.length > 0, "should report all 10 missing functions");
+        assert.equal(verify.contractFunctions.length, 10, "billing has 10 functions");
+    });
+    it("parses class methods correctly", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        const goodImpl = `
+export class StripeAdapter implements PaymentsContract {
+  async initiatePayment(orderId: string, amount: number, currency: string, method: string): Promise<Payment> {
+    // implementation
+    return {} as Payment;
+  }
+  async verifyPayment(paymentId: string): Promise<Payment> {
+    return {} as Payment;
+  }
+  async getPaymentByOrder(orderId: string): Promise<Payment | undefined> {
+    return undefined;
+  }
+  async getWallet(userId: string): Promise<Wallet> { throw new Error('Not supported'); }
+  async creditWallet(userId: string, amount: number, currency: string): Promise<WalletTransaction> { throw new Error('Not supported'); }
+  async debitWallet(userId: string, amount: number, currency: string): Promise<WalletTransaction> { throw new Error('Not supported'); }
+  async getWalletTransactions(userId: string, options?: Record<string, unknown>): Promise<PaginatedResult<WalletTransaction>> { throw new Error('Not supported'); }
+  async initiateRefund(paymentId: string, amount: number, reason: string): Promise<Refund> {
+    return {} as Refund;
+  }
+  async getRefundByOrder(orderId: string): Promise<Refund | undefined> {
+    return undefined;
+  }
+  async getRefund(refundId: string): Promise<Refund> {
+    return {} as Refund;
+  }
+}`;
+        const fs = await import("node:fs/promises");
+        await fs.writeFile("/tmp/test-stripe.ts", goodImpl);
+        const verify = await verifyImplementation("/tmp/test-stripe.ts", "payments", result.value);
+        await fs.unlink("/tmp/test-stripe.ts");
+        assert.ok(verify.valid, `expected valid, got ${verify.issues.length} issues: ${verify.issues.map((i) => i.message).join("; ")}`);
+        assert.ok(verify.implFunctions.length >= 10, `expected >= 10 functions, got ${verify.implFunctions.length}`);
+    });
+    it("detects mismatched return types", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        const badImpl = `
+class Bad implements PaymentsContract {
+  async initiatePayment(...args: any[]): Promise<any> { return {}; }
+}`;
+        const fs = await import("node:fs/promises");
+        await fs.writeFile("/tmp/bad-stripe.ts", badImpl);
+        const verify = await verifyImplementation("/tmp/bad-stripe.ts", "payments", result.value);
+        await fs.unlink("/tmp/bad-stripe.ts");
+        assert.equal(verify.valid, false);
+        assert.ok(verify.issues.filter((i) => i.kind === "missing").length > 8, "should report many missing functions");
+    });
+    it("ignores commented-out code", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        const commentedImpl = `
+class Commented implements PaymentsContract {
+  // async initiatePayment(orderId: string): Promise<Payment> { return {}; }
+  async verifyPayment(paymentId: string): Promise<Payment> { return {} as Payment; }
+}`;
+        const fs = await import("node:fs/promises");
+        await fs.writeFile("/tmp/commented.ts", commentedImpl);
+        const verify = await verifyImplementation("/tmp/commented.ts", "payments", result.value);
+        await fs.unlink("/tmp/commented.ts");
+        assert.equal(verify.valid, false);
+        assert.ok(verify.implFunctions.filter((f) => f === "initiatePayment").length === 0, "should not count commented-out function");
+    });
+});
+describe("implement edge cases", () => {
+    it("generates prompts for all implemented functions", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        const { adapters } = await loadAdapters(join(ROOT, "adapters"));
+        const prompts = generateImplementPrompts(result.value, adapters, "payments", "stripe");
+        assert.ok(prompts.length > 0, "should generate prompts");
+        assert.equal(prompts.length, 6, "stripe implements 6 of 10 payments functions");
+    });
+    it("returns empty for unknown module", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        const { adapters } = await loadAdapters(join(ROOT, "adapters"));
+        const prompts = generateImplementPrompts(result.value, adapters, "nonexistent", "stripe");
+        assert.equal(prompts.length, 0);
+    });
+    it("returns empty for missing adapter", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        const { adapters } = await loadAdapters(join(ROOT, "adapters"));
+        const prompts = generateImplementPrompts(result.value, adapters, "payments", "nonexistent");
+        assert.equal(prompts.length, 0);
+    });
+    it("each prompt contains essential fields", async () => {
+        const result = await loadCatalogFromRoot(ROOT, "loose");
+        const { adapters } = await loadAdapters(join(ROOT, "adapters"));
+        const prompts = generateImplementPrompts(result.value, adapters, "payments", "stripe");
+        for (const p of prompts) {
+            assert.ok(p.function.length > 0);
+            assert.ok(p.prompt.includes(p.function));
+            assert.ok(p.prompt.includes("stripe"));
+        }
+    });
+});