@friehub/blueprint 0.1.0

package/dist/generators/render.js

@@ -0,0 +1,146 @@
+import Handlebars from "handlebars";
+Handlebars.registerHelper("pascalCase", (str) => {
+    return str
+        .split(/[_\-.\s]+/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+});
+Handlebars.registerHelper("camelCase", (str) => {
+    const pascal = str
+        .split(/[_\-.\s]+/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+});
+Handlebars.registerHelper("snakeCase", (str) => {
+    return str
+        .replace(/([A-Z])/g, "_$1")
+        .toLowerCase()
+        .replace(/^_/, "")
+        .replace(/[_\-.\s]+/g, "_");
+});
+Handlebars.registerHelper("kebabCase", (str) => {
+    return str
+        .replace(/([A-Z])/g, "-$1")
+        .toLowerCase()
+        .replace(/^-/, "")
+        .replace(/[_\-.\s]+/g, "-");
+});
+Handlebars.registerHelper("lowerCase", (str) => str.toLowerCase());
+Handlebars.registerHelper("upperCase", (str) => str.toUpperCase());
+Handlebars.registerHelper("mapType", (type, language) => {
+    const TYPE_MAPPINGS = {
+        string: { typescript: "string", rust: "String", python: "str", go: "string" },
+        number: { typescript: "number", rust: "f64", python: "float", go: "float64" },
+        boolean: { typescript: "boolean", rust: "bool", python: "bool", go: "bool" },
+        null: { typescript: "null", rust: "Option::None", python: "None", go: "nil" },
+    };
+    const mapping = TYPE_MAPPINGS[type]?.[language];
+    if (mapping)
+        return mapping;
+    if (type.endsWith("[]")) {
+        const inner = type.slice(0, -2);
+        const mappedInner = mapTypeHelper(inner, language);
+        switch (language) {
+            case "typescript":
+                return `${mappedInner}[]`;
+            case "rust":
+                return `Vec<${mappedInner}>`;
+            case "python":
+                return `list[${mappedInner}]`;
+            case "go":
+                return `[]${mappedInner}`;
+        }
+    }
+    if (type.endsWith("?")) {
+        const inner = type.slice(0, -1);
+        const mappedInner = mapTypeHelper(inner, language);
+        switch (language) {
+            case "typescript":
+                return `${mappedInner} | undefined`;
+            case "rust":
+                return `Option<${mappedInner}>`;
+            case "python":
+                return `Optional[${mappedInner}]`;
+            case "go":
+                return `*${mappedInner}`;
+        }
+    }
+    return type;
+});
+function mapTypeHelper(type, language) {
+    const TYPE_MAPPINGS = {
+        string: { typescript: "string", rust: "String", python: "str", go: "string" },
+        number: { typescript: "number", rust: "f64", python: "float", go: "float64" },
+        boolean: { typescript: "boolean", rust: "bool", python: "bool", go: "bool" },
+        null: { typescript: "null", rust: "Option::None", python: "None", go: "nil" },
+    };
+    const mapping = TYPE_MAPPINGS[type]?.[language];
+    if (mapping)
+        return mapping;
+    if (type.endsWith("[]")) {
+        const inner = type.slice(0, -2);
+        const mappedInner = mapTypeHelper(inner, language);
+        switch (language) {
+            case "typescript":
+                return `${mappedInner}[]`;
+            case "rust":
+                return `Vec<${mappedInner}>`;
+            case "python":
+                return `list[${mappedInner}]`;
+            case "go":
+                return `[]${mappedInner}`;
+        }
+    }
+    if (type.endsWith("?")) {
+        const inner = type.slice(0, -1);
+        const mappedInner = mapTypeHelper(inner, language);
+        switch (language) {
+            case "typescript":
+                return `${mappedInner} | undefined`;
+            case "rust":
+                return `Option<${mappedInner}>`;
+            case "python":
+                return `Optional[${mappedInner}]`;
+            case "go":
+                return `*${mappedInner}`;
+        }
+    }
+    return type;
+}
+Handlebars.registerHelper("inferType", (fieldName, language) => {
+    const TYPE_INFERENCE_RULES = [
+        { pattern: /^id$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+        { pattern: /_id$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+        { pattern: /_at$/i, typescript: "Timestamp", rust: "DateTime<Utc>", python: "str", go: "time.Time" },
+        { pattern: /_count$/i, typescript: "number", rust: "i64", python: "int", go: "int" },
+        { pattern: /_amount$/i, typescript: "number", rust: "f64", python: "float", go: "float64" },
+        { pattern: /_price$/i, typescript: "number", rust: "f64", python: "float", go: "float64" },
+        { pattern: /_total$/i, typescript: "number", rust: "f64", python: "float", go: "float64" },
+        { pattern: /is_/i, typescript: "boolean", rust: "bool", python: "bool", go: "bool" },
+        { pattern: /has_/i, typescript: "boolean", rust: "bool", python: "bool", go: "bool" },
+        { pattern: /_status$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+        { pattern: /_type$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+        { pattern: /_name$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+        { pattern: /_url$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+        { pattern: /_email$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+        { pattern: /_key$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+        { pattern: /_token$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+        { pattern: /_data$/i, typescript: "Record<string, unknown>", rust: "HashMap<String, Value>", python: "dict[str, Any]", go: "map[string]interface{}" },
+        { pattern: /_metadata$/i, typescript: "Record<string, unknown>", rust: "HashMap<String, Value>", python: "dict[str, Any]", go: "map[string]interface{}" },
+        { pattern: /_options$/i, typescript: "Record<string, unknown>", rust: "HashMap<String, Value>", python: "dict[str, Any]", go: "map[string]interface{}" },
+    ];
+    const rule = TYPE_INFERENCE_RULES.find((r) => r.pattern.test(fieldName));
+    if (rule) {
+        return rule[language] ?? "unknown";
+    }
+    return "unknown";
+});
+export function renderTemplate(template, context) {
+    const compiled = Handlebars.compile(template);
+    return compiled(context);
+}
+export function renderTemplateFile(templatePath, context) {
+    const template = Handlebars.compile(templatePath);
+    return template(context);
+}

package/dist/generators/types.js

@@ -0,0 +1,124 @@
+export const TYPE_MAPPINGS = [
+    { contractType: "string", typescript: "string", rust: "String", python: "str", go: "string" },
+    { contractType: "number", typescript: "number", rust: "f64", python: "float", go: "float64" },
+    { contractType: "boolean", typescript: "boolean", rust: "bool", python: "bool", go: "bool" },
+    { contractType: "null", typescript: "null", rust: "Option::None", python: "None", go: "nil" },
+];
+export const TYPE_INFERENCE_RULES = [
+    { pattern: /^id$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /_id$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /_at$/i, typescript: "Timestamp", rust: "DateTime<Utc>", python: "str", go: "time.Time" },
+    { pattern: /_count$/i, typescript: "number", rust: "i64", python: "int", go: "int" },
+    { pattern: /_amount$/i, typescript: "number", rust: "f64", python: "float", go: "float64" },
+    { pattern: /_price$/i, typescript: "number", rust: "f64", python: "float", go: "float64" },
+    { pattern: /_total$/i, typescript: "number", rust: "f64", python: "float", go: "float64" },
+    { pattern: /is_/i, typescript: "boolean", rust: "bool", python: "bool", go: "bool" },
+    { pattern: /has_/i, typescript: "boolean", rust: "bool", python: "bool", go: "bool" },
+    { pattern: /_status$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /_type$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /_name$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /_url$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /_email$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /_key$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /_token$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /_data$/i, typescript: "Record<string, unknown>", rust: "HashMap<String, Value>", python: "dict[str, Any]", go: "map[string]interface{}" },
+    { pattern: /_metadata$/i, typescript: "Record<string, unknown>", rust: "HashMap<String, Value>", python: "dict[str, Any]", go: "map[string]interface{}" },
+    { pattern: /_options$/i, typescript: "Record<string, unknown>", rust: "HashMap<String, Value>", python: "dict[str, Any]", go: "map[string]interface{}" },
+    { pattern: /^input$/i, typescript: "unknown", rust: "Value", python: "Any", go: "interface{}" },
+    { pattern: /^data$/i, typescript: "unknown", rust: "Value", python: "Any", go: "interface{}" },
+    { pattern: /^context$/i, typescript: "Record<string, unknown>", rust: "HashMap<String, Value>", python: "dict[str, Any]", go: "map[string]interface{}" },
+    { pattern: /^reason$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /^currency$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /^period$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /^filters$/i, typescript: "Record<string, unknown>", rust: "HashMap<String, Value>", python: "dict[str, Any]", go: "map[string]interface{}" },
+    { pattern: /^code$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /^message$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /^content$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /^status$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /^method$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /^reference$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /^amount$/i, typescript: "number", rust: "f64", python: "float", go: "float64" },
+    { pattern: /balance/i, typescript: "number", rust: "f64", python: "float", go: "float64" },
+    { pattern: /[Rr]eference$/i, typescript: "string", rust: "String", python: "str", go: "string" },
+    { pattern: /^options$/i, typescript: "Record<string, unknown>", rust: "HashMap<String, Value>", python: "dict[str, Any]", go: "map[string]interface{}" },
+];
+export function inferType(fieldName, language) {
+    const rule = TYPE_INFERENCE_RULES.find((r) => r.pattern.test(fieldName));
+    if (rule) {
+        return rule[language];
+    }
+    return "unknown";
+}
+export function mapType(type, language) {
+    const mapping = TYPE_MAPPINGS.find((m) => m.contractType === type);
+    if (mapping) {
+        return mapping[language];
+    }
+    if (type.endsWith("[]")) {
+        const inner = type.slice(0, -2);
+        const mappedInner = mapType(inner, language);
+        switch (language) {
+            case "typescript":
+                return `${mappedInner}[]`;
+            case "rust":
+                return `Vec<${mappedInner}>`;
+            case "python":
+                return `list[${mappedInner}]`;
+            case "go":
+                return `[]${mappedInner}`;
+        }
+    }
+    if (type.endsWith("?")) {
+        const inner = type.slice(0, -1);
+        const mappedInner = mapType(inner, language);
+        switch (language) {
+            case "typescript":
+                return `${mappedInner} | undefined`;
+            case "rust":
+                return `Option<${mappedInner}>`;
+            case "python":
+                return `Optional[${mappedInner}]`;
+            case "go":
+                return `*${mappedInner}`;
+        }
+    }
+    return type;
+}
+export function pascalCase(str) {
+    return str
+        .split(/[_\-.\s]+/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+}
+export function camelCase(str) {
+    if (str.includes("_") || str.includes("-") || str.includes(" ")) {
+        const pascal = pascalCase(str);
+        return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+    }
+    return str;
+}
+export function snakeCase(str) {
+    return str
+        .replace(/([A-Z])/g, "_$1")
+        .toLowerCase()
+        .replace(/^_/, "")
+        .replace(/[_\-.\s]+/g, "_");
+}
+export function kebabCase(str) {
+    return str
+        .replace(/([A-Z])/g, "-$1")
+        .toLowerCase()
+        .replace(/^-/, "")
+        .replace(/[_\-.\s]+/g, "-");
+}
+export function createTemplateData(module) {
+    return {
+        module,
+        pascalCase,
+        camelCase,
+        snakeCase,
+        kebabCase,
+        lowerCase: (str) => str.toLowerCase(),
+        upperCase: (str) => str.toUpperCase(),
+    };
+}

package/dist/generators/typescript/helpers.js

@@ -0,0 +1,125 @@
+import { pascalCase, camelCase, mapType, inferType } from "../types.js";
+export function generateTypeDefinition(type) {
+    const name = pascalCase(type.name);
+    const raw = type.raw;
+    if (raw.startsWith("type ")) {
+        return `export ${raw}`;
+    }
+    if (raw.includes("{")) {
+        const fields = parseTypeFields(raw);
+        const fieldsStr = fields.map((f) => {
+            const type = f.type ? `: ${mapType(f.type, "typescript")}` : `: ${inferType(f.name, "typescript")}`;
+            return `  ${camelCase(f.name)}${f.optional ? "?" : ""}${type};`;
+        }).join("\n");
+        return `export interface ${name} {\n${fieldsStr}\n}`;
+    }
+    const fieldsMatch = raw.match(/^\w+\s*\{\s*(.+)\s*\}$/);
+    if (fieldsMatch) {
+        const fields = fieldsMatch[1].split(",").map((f) => f.trim());
+        const fieldsStr = fields.map((f) => {
+            const optional = f.endsWith("?");
+            const fieldName = f.replace(/\?$/, "");
+            return `  ${camelCase(fieldName)}${optional ? "?" : ""}: ${inferType(fieldName, "typescript")};`;
+        }).join("\n");
+        return `export interface ${name} {\n${fieldsStr}\n}`;
+    }
+    return `export type ${name} = ${raw};`;
+}
+function parseTypeFields(raw) {
+    const fields = [];
+    const match = raw.match(/\{([^}]+)\}/s);
+    if (!match)
+        return fields;
+    const content = match[1] ?? "";
+    for (const line of content.split(/[,\n]/).filter((l) => l.trim())) {
+        const trimmed = line.trim().replace(/,\s*$/, "").replace(/\/\/.*$/, "").trim();
+        if (!trimmed)
+            continue;
+        const typeMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.+)$/);
+        if (typeMatch) {
+            fields.push({ name: typeMatch[1] ?? "", type: typeMatch[2]?.trim() ?? null, optional: false });
+            continue;
+        }
+        const optionalMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\?\s*:\s*(.+)$/);
+        if (optionalMatch) {
+            fields.push({ name: optionalMatch[1] ?? "", type: optionalMatch[2]?.trim() ?? null, optional: true });
+            continue;
+        }
+        const simpleMatch = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)$/);
+        if (simpleMatch) {
+            fields.push({ name: simpleMatch[1] ?? "", type: null, optional: trimmed.endsWith("?") });
+        }
+    }
+    return fields;
+}
+export function generateFunctionSignature(fn) {
+    const params = fn.params.map((p) => {
+        const type = p.type ? `: ${mapType(p.type, "typescript")}` : `: ${inferType(p.name, "typescript")}`;
+        return `${camelCase(p.name)}${p.optional ? "?" : ""}${type}`;
+    }).join(", ");
+    return `  ${camelCase(fn.name)}(${params}): Promise<${mapType(fn.returns, "typescript")}>;`;
+}
+export function generateParamsList(fn) {
+    return fn.params.map((p) => {
+        const type = p.type ? `: ${mapType(p.type, "typescript")}` : `: ${inferType(p.name, "typescript")}`;
+        return `${camelCase(p.name)}${p.optional ? "?" : ""}${type}`;
+    }).join(", ");
+}
+const SHARED_TYPES = `// Shared types used across all contracts
+export type Timestamp = string;
+export type UserId = string;
+export type EntityId = string;
+
+export interface PaginatedResult<T> {
+  data: T[];
+  cursor: string | null;
+  hasMore: boolean;
+  total?: number;
+}
+`;
+export function generateSharedTypes() {
+    return SHARED_TYPES;
+}
+export function generateIndex(moduleNames) {
+    const lines = [
+        "// Auto-generated module index",
+        "",
+        "export * from './shared.js';",
+        "",
+    ];
+    for (const name of moduleNames.sort()) {
+        lines.push(`export * from './${name}.js';`);
+    }
+    return lines.join("\n");
+}
+export function getSdkHint(adapterName, functionName) {
+    const hints = {
+        stripe: {
+            initiatePayment: "const paymentIntent = await this.stripe.paymentIntents.create({\n  amount: Math.round(amount * 100),\n  currency: currency.toLowerCase(),\n  payment_method: method,\n  metadata: { orderId },\n});\nreturn this.toPayment(paymentIntent);",
+            verifyPayment: "const paymentIntent = await this.stripe.paymentIntents.retrieve(paymentId);\nreturn this.toPayment(paymentIntent);",
+            getPaymentByOrder: "const paymentIntents = await this.stripe.paymentIntents.list({\n  limit: 1,\n  query: `metadata['orderId']:'${orderId}'`,\n});\nif (paymentIntents.data.length === 0) return undefined;\nreturn this.toPayment(paymentIntents.data[0]);",
+            initiateRefund: "const refund = await this.stripe.refunds.create({\n  payment_intent: paymentId,\n  amount: amount ? Math.round(amount * 100) : undefined,\n  reason: reason as any,\n});\nreturn { id: refund.id, paymentId, amount: refund.amount / 100, status: refund.status, reason: reason || '', createdAt: new Date(refund.created * 1000).toISOString() };",
+            getRefundByOrder: "const payment = await this.getPaymentByOrder(orderId);\nif (!payment) return undefined;\nreturn this.getRefund(payment.id);",
+            getRefund: "const refund = await this.stripe.refunds.retrieve(refundId);\nreturn { id: refund.id, paymentId: refund.payment_intent as string, amount: refund.amount / 100, status: refund.status, reason: refund.reason || '', createdAt: new Date(refund.created * 1000).toISOString() };",
+        },
+        redis: {
+            get: "const result = await this.redis.get(key);\nif (!result) return null;\nreturn JSON.parse(result);",
+            set: "const serialized = JSON.stringify(value);\nif (ttl) {\n  await this.redis.set(key, serialized, 'EX', ttl);\n} else {\n  await this.redis.set(key, serialized);\n}",
+            delete: "await this.redis.del(key);",
+            exists: "const result = await this.redis.exists(key);\nreturn result === 1;",
+            expire: "await this.redis.expire(key, seconds);",
+            ttl: "return await this.redis.ttl(key);",
+        },
+        bullmq: {
+            enqueue: "return await this.queue.add(name, data, { attempts: 3, backoff: { type: 'exponential', delay: 1000 } });",
+            dequeue: "const job = await this.queue.getNext();\nif (!job) return null;\nreturn job.data;",
+            peek: "const job = await this.queue.getJob(jobId);\nif (!job) return null;\nreturn job.data;",
+            size: "return await this.queue.getWaitingCount();",
+            remove: "await this.queue.remove(jobId);",
+        },
+        sendgrid: { sendEmail: "await this.sg.send({ to, from, subject, html: body, text: body });" },
+        resend: { sendEmail: "const result = await this.resend.emails.send({ from, to, subject, html: body });\nreturn { messageId: result.id, status: 'sent' };" },
+        twilio: { sendSMS: "const message = await this.twilio.messages.create({ to, from, body });\nreturn { messageId: message.sid, status: message.status };" },
+    };
+    return hints[adapterName]?.[functionName] ?? null;
+}

package/dist/generators/typescript/index.js

@@ -0,0 +1,206 @@
+import { pascalCase, camelCase, mapType } from "../types.js";
+import { generateTypeDefinition, generateFunctionSignature, generateParamsList, generateIndex, getSdkHint, generateSharedTypes } from "./helpers.js";
+const SDK_IMPORTS = {
+    stripe: `import Stripe from 'stripe';`,
+    redis: `import { createClient } from 'redis';`,
+    bullmq: `import { Queue, Worker, Job } from 'bullmq';`,
+    sendgrid: `import sgMail from '@sendgrid/mail';`,
+    resend: `import { Resend } from 'resend';`,
+    twilio: `import twilio from 'twilio';`,
+    memcached: `import Memcached from 'memcached';`,
+    sqs: `import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs';`,
+    sentry: `import * as Sentry from '@sentry/node';`,
+    clerk: `import { createClerkClient } from '@clerk/clerk-sdk-node';`,
+    sift: `import { SiftClient } from 'sift';`,
+    cloudinary: `import { v2 as cloudinary } from 'cloudinary';`,
+    algolia: `import { algoliasearch } from 'algoliasearch';`,
+};
+function getSdkImport(adapterName) {
+    return SDK_IMPORTS[adapterName] || `// TODO: import ${adapterName} SDK`;
+}
+export class TypeScriptGenerator {
+    language = "typescript";
+    name = "TypeScript Generator";
+    generateInterfaces(context) {
+        const files = [];
+        const errors = [];
+        let modules = this.resolveModules(context);
+        files.push({ path: "interfaces/shared.ts", content: generateSharedTypes() });
+        for (const mod of modules) {
+            try {
+                files.push({ path: `interfaces/${mod.name}.ts`, content: this.generateModuleInterface(mod) });
+            }
+            catch (error) {
+                errors.push(`Failed to generate interface for ${mod.name}: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+        files.push({ path: "interfaces/index.ts", content: generateIndex(modules.map((m) => m.name)) });
+        return { files, errors };
+    }
+    generateAdapter(context) {
+        const files = [];
+        const errors = [];
+        const adapters = context.adapters.filter((a) => {
+            if (context.module && a.module !== context.module)
+                return false;
+            if (context.provider && a.name !== context.provider)
+                return false;
+            return true;
+        });
+        for (const adapter of adapters) {
+            try {
+                const mod = context.catalog.modules.find((m) => m.name === adapter.module);
+                if (!mod) {
+                    errors.push(`Module ${adapter.module} not found for adapter ${adapter.name}`);
+                    continue;
+                }
+                files.push({ path: `adapters/${adapter.module}/${adapter.name}.ts`, content: this.generateAdapterClass(adapter, mod) });
+            }
+            catch (error) {
+                errors.push(`Failed to generate adapter ${adapter.name}: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+        return { files, errors };
+    }
+    generateTests(context) {
+        const files = [];
+        const errors = [];
+        const adapters = context.adapters.filter((a) => {
+            if (context.module && a.module !== context.module)
+                return false;
+            if (context.provider && a.name !== context.provider)
+                return false;
+            return true;
+        });
+        for (const adapter of adapters) {
+            try {
+                const mod = context.catalog.modules.find((m) => m.name === adapter.module);
+                if (!mod) {
+                    errors.push(`Module ${adapter.module} not found for adapter ${adapter.name}`);
+                    continue;
+                }
+                files.push({ path: `__tests__/${adapter.module}/${adapter.name}.test.ts`, content: this.generateConformanceTest(adapter, mod) });
+            }
+            catch (error) {
+                errors.push(`Failed to generate test for ${adapter.name}: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+        return { files, errors };
+    }
+    resolveModules(context) {
+        let modules = context.module
+            ? context.catalog.modules.filter((m) => m.name === context.module)
+            : context.catalog.modules;
+        if (context.module) {
+            const targetMod = context.catalog.modules.find((m) => m.name === context.module);
+            if (targetMod) {
+                for (const dep of targetMod.hardDeps) {
+                    const depMod = context.catalog.modules.find((m) => m.name === dep);
+                    if (depMod && !modules.some((m) => m.name === dep))
+                        modules = [...modules, depMod];
+                }
+            }
+        }
+        return modules;
+    }
+    generateModuleInterface(mod) {
+        const versionNote = mod.version ? `v${mod.version}` : "version not specified";
+        const lines = [
+            `// ${mod.name}.ts — ${versionNote} — contracts/${mod.name}.md`,
+            `// Auto-generated from contracts/${mod.name}.md`,
+            `// Types are inferred from naming conventions. Review before production use.`,
+            "",
+        ];
+        for (const type of mod.types) {
+            lines.push(generateTypeDefinition(type));
+            lines.push("");
+        }
+        const interfaceName = `${pascalCase(mod.name)}Contract`;
+        lines.push(`export interface ${interfaceName} {`);
+        for (const fn of mod.functions)
+            lines.push(generateFunctionSignature(fn));
+        lines.push("}");
+        return lines.join("\n");
+    }
+    generateAdapterClass(adapter, mod) {
+        const lines = [
+            `// ${adapter.name}.ts`,
+            `// Auto-generated adapter for ${adapter.name} → ${mod.name}`,
+            `// Types are inferred from naming conventions. Review before production use.`,
+            "",
+            getSdkImport(adapter.name),
+            `import type { ${pascalCase(mod.name)}Contract } from '../interfaces/${mod.name}';`,
+            "",
+        ];
+        const className = `${pascalCase(adapter.name)}Adapter`;
+        const configFields = adapter.config.required.map((f) => `  ${f.name}: ${mapType(f.type, "typescript")};`).join("\n");
+        lines.push(`export class ${className} implements ${pascalCase(mod.name)}Contract {`);
+        lines.push(`  constructor(private config: {`);
+        lines.push(configFields);
+        lines.push(`  }) {}`);
+        lines.push("");
+        for (const fn of mod.functions) {
+            if (adapter.implements.includes(fn.name)) {
+                lines.push(this.generateAdapterMethod(fn, adapter.name));
+            }
+            else {
+                const notSupportedMessage = adapter.does_not_implement?.includes(fn.name)
+                    ? `Not supported by ${adapter.name}: ${fn.name}`
+                    : `Not yet implemented: ${fn.name}`;
+                lines.push(this.generateUnimplementedMethod(fn, notSupportedMessage));
+            }
+        }
+        lines.push("}");
+        return lines.join("\n");
+    }
+    generateAdapterMethod(fn, adapterName) {
+        const lines = [];
+        lines.push(`  async ${camelCase(fn.name)}(${generateParamsList(fn)}): Promise<${mapType(fn.returns, "typescript")}> {`);
+        const hint = getSdkHint(adapterName, fn.name);
+        if (hint) {
+            const hintLines = hint.split("\n");
+            for (const hintLine of hintLines) {
+                lines.push(`    ${hintLine}`);
+            }
+        }
+        else {
+            lines.push(`    // TODO: Implement ${fn.name}`);
+            if (fn.returns !== "void") {
+                lines.push(`    throw new Error('Not implemented: ${fn.name}');`);
+            }
+        }
+        lines.push(`  }`);
+        return lines.join("\n");
+    }
+    generateUnimplementedMethod(fn, message) {
+        return `  async ${camelCase(fn.name)}(${generateParamsList(fn)}): Promise<${mapType(fn.returns, "typescript")}> {\n    throw new Error('${message}');\n  }`;
+    }
+    generateConformanceTest(adapter, mod) {
+        const className = `${pascalCase(adapter.name)}Adapter`;
+        const interfaceName = `${pascalCase(mod.name)}Contract`;
+        const lines = [
+            `// ${adapter.name}.test.ts`,
+            `// Auto-generated conformance test for ${adapter.name} → ${mod.name}`,
+            "",
+            `import { ${className} } from '../adapters/${mod.name}/${adapter.name}';`,
+            `import type { ${interfaceName} } from '../interfaces/${mod.name}';`,
+            "",
+            `describe('${className} implements ${interfaceName}', () => {`,
+            `  const adapter: ${interfaceName} = new ${className}({`,
+        ];
+        const testConfigs = adapter.config.required.map((f) => {
+            const val = f.type === "number" ? 0 : "false";
+            return `    ${f.name}: 'test'`;
+        }).join(",\n");
+        lines.push(testConfigs);
+        lines.push(`  });`);
+        lines.push("");
+        for (const fn of mod.functions) {
+            lines.push(`  it('has ${fn.name} method', () => {`);
+            lines.push(`    expect(typeof adapter.${camelCase(fn.name)}).toBe('function');`);
+            lines.push(`  });`);
+        }
+        lines.push(`});`);
+        return lines.join("\n");
+    }
+}

package/dist/index.js

@@ -0,0 +1,8 @@
+// Engineering Blueprinter - Public API
+// Import this library as: import { loadCatalog } from '@friehub/blueprint'
+export { loadCatalogFromRoot } from "./core/load-catalog.js";
+export { loadAdapters, loadAdapter } from "./core/adapters/load.js";
+export { resolve as resolveDeps, detectCycles } from "./core/resolve.js";
+export { searchModules } from "./core/search.js";
+export { buildGraph } from "./core/graph.js";
+export { implicitCores } from "./core/catalog.js";