@shahmarasy/prodo 0.1.0

package/dist/output-index.d.ts

@@ -0,0 +1,13 @@
+import type { ArtifactType } from "./types";
+type ArtifactMap = Partial<Record<ArtifactType, string>>;
+type ArtifactHistoryMap = Partial<Record<ArtifactType, string[]>>;
+export type OutputIndex = {
+    active: ArtifactMap;
+    history: ArtifactHistoryMap;
+    updated_at: string;
+};
+export declare function loadOutputIndex(cwd: string): Promise<OutputIndex>;
+export declare function saveOutputIndex(cwd: string, index: OutputIndex): Promise<void>;
+export declare function setActiveArtifact(cwd: string, type: ArtifactType, filePath: string): Promise<void>;
+export declare function getActiveArtifactPath(cwd: string, type: ArtifactType): Promise<string | undefined>;
+export {};

package/dist/output-index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOutputIndex = loadOutputIndex;
+exports.saveOutputIndex = saveOutputIndex;
+exports.setActiveArtifact = setActiveArtifact;
+exports.getActiveArtifactPath = getActiveArtifactPath;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("./paths");
+const utils_1 = require("./utils");
+function defaultIndex() {
+    return {
+        active: {},
+        history: {},
+        updated_at: new Date(0).toISOString()
+    };
+}
+async function loadOutputIndex(cwd) {
+    const indexPath = (0, paths_1.outputIndexPath)(cwd);
+    if (!(await (0, utils_1.fileExists)(indexPath)))
+        return defaultIndex();
+    const raw = await promises_1.default.readFile(indexPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+        active: parsed.active ?? {},
+        history: parsed.history ?? {},
+        updated_at: parsed.updated_at ?? new Date(0).toISOString()
+    };
+}
+async function saveOutputIndex(cwd, index) {
+    const indexPath = (0, paths_1.outputIndexPath)(cwd);
+    await (0, utils_1.ensureDir)(node_path_1.default.dirname(indexPath));
+    await promises_1.default.writeFile(indexPath, `${JSON.stringify(index, null, 2)}\n`, "utf8");
+}
+async function setActiveArtifact(cwd, type, filePath) {
+    const index = await loadOutputIndex(cwd);
+    const normalizedPath = node_path_1.default.resolve(filePath);
+    const existing = index.history[type] ?? [];
+    index.active[type] = normalizedPath;
+    index.history[type] = [normalizedPath, ...existing.filter((item) => item !== normalizedPath)].slice(0, 100);
+    index.updated_at = new Date().toISOString();
+    await saveOutputIndex(cwd, index);
+}
+async function getActiveArtifactPath(cwd, type) {
+    const index = await loadOutputIndex(cwd);
+    const candidate = index.active[type];
+    if (!candidate)
+        return undefined;
+    if (await (0, utils_1.fileExists)(candidate))
+        return candidate;
+    return undefined;
+}

package/dist/paths.d.ts

@@ -0,0 +1,16 @@
+import type { ArtifactType } from "./types";
+export declare function prodoPath(cwd: string): string;
+export declare function briefPath(cwd: string): string;
+export declare function normalizedBriefPath(cwd: string): string;
+export declare function settingsPath(cwd: string): string;
+export declare function registryPath(cwd: string): string;
+export declare function promptPath(cwd: string, artifactType: ArtifactType): string;
+export declare function templatePath(cwd: string, artifactType: ArtifactType): string;
+export declare function overrideTemplatePath(cwd: string, artifactType: ArtifactType): string;
+export declare function templateCandidatePaths(cwd: string, artifactType: ArtifactType): string[];
+export declare function overrideTemplateCandidatePaths(cwd: string, artifactType: ArtifactType): string[];
+export declare function schemaPath(cwd: string, artifactType: ArtifactType): string;
+export declare function outputDirPath(cwd: string, artifactType: ArtifactType, outputDirOverride?: string): string;
+export declare function reportPath(cwd: string): string;
+export declare function outputIndexPath(cwd: string): string;
+export declare function outputContextDirPath(cwd: string): string;

package/dist/paths.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prodoPath = prodoPath;
+exports.briefPath = briefPath;
+exports.normalizedBriefPath = normalizedBriefPath;
+exports.settingsPath = settingsPath;
+exports.registryPath = registryPath;
+exports.promptPath = promptPath;
+exports.templatePath = templatePath;
+exports.overrideTemplatePath = overrideTemplatePath;
+exports.templateCandidatePaths = templateCandidatePaths;
+exports.overrideTemplateCandidatePaths = overrideTemplateCandidatePaths;
+exports.schemaPath = schemaPath;
+exports.outputDirPath = outputDirPath;
+exports.reportPath = reportPath;
+exports.outputIndexPath = outputIndexPath;
+exports.outputContextDirPath = outputContextDirPath;
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("./constants");
+function prodoPath(cwd) {
+    return node_path_1.default.join(cwd, constants_1.PRODO_DIR);
+}
+function briefPath(cwd) {
+    return node_path_1.default.join(cwd, "brief.md");
+}
+function normalizedBriefPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "briefs", "normalized-brief.json");
+}
+function settingsPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "settings.json");
+}
+function registryPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "registry.json");
+}
+function promptPath(cwd, artifactType) {
+    return node_path_1.default.join(prodoPath(cwd), "prompts", `${artifactType}.md`);
+}
+function templatePath(cwd, artifactType) {
+    return node_path_1.default.join(prodoPath(cwd), "templates", `${artifactType}.md`);
+}
+function overrideTemplatePath(cwd, artifactType) {
+    return node_path_1.default.join(prodoPath(cwd), "templates", "overrides", `${artifactType}.md`);
+}
+function templateExtensionsForArtifact(artifactType) {
+    if (artifactType === "workflow")
+        return ["md", "mmd"];
+    if (artifactType === "wireframe")
+        return ["md", "html"];
+    return ["md"];
+}
+function templateCandidatePaths(cwd, artifactType) {
+    const root = node_path_1.default.join(prodoPath(cwd), "templates");
+    return templateExtensionsForArtifact(artifactType).map((ext) => node_path_1.default.join(root, `${artifactType}.${ext}`));
+}
+function overrideTemplateCandidatePaths(cwd, artifactType) {
+    const root = node_path_1.default.join(prodoPath(cwd), "templates", "overrides");
+    return templateExtensionsForArtifact(artifactType).map((ext) => node_path_1.default.join(root, `${artifactType}.${ext}`));
+}
+function schemaPath(cwd, artifactType) {
+    return node_path_1.default.join(prodoPath(cwd), "schemas", `${artifactType}.yaml`);
+}
+function outputDirPath(cwd, artifactType, outputDirOverride) {
+    return node_path_1.default.join(cwd, "product-docs", outputDirOverride ?? (0, constants_1.defaultOutputDir)(artifactType));
+}
+function reportPath(cwd) {
+    return node_path_1.default.join(cwd, "product-docs", "reports", "latest-validation.md");
+}
+function outputIndexPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "state", "index.json");
+}
+function outputContextDirPath(cwd) {
+    return node_path_1.default.join(prodoPath(cwd), "state", "context");
+}

package/dist/preset-loader.d.ts

@@ -0,0 +1,4 @@
+export declare function applyConfiguredPresets(projectRoot: string, prodoRoot: string, prodoVersion: string, presetOverride?: string): Promise<{
+    installedPresets: string[];
+    appliedFiles: string[];
+}>;

package/dist/preset-loader.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyConfiguredPresets = applyConfiguredPresets;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const errors_1 = require("./errors");
+const project_config_1 = require("./project-config");
+const utils_1 = require("./utils");
+function parseVersion(version) {
+    return version.split(".").map((part) => Number(part.replace(/[^0-9]/g, "")) || 0).slice(0, 3);
+}
+function cmpVersion(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    for (let i = 0; i < 3; i++) {
+        if ((left[i] ?? 0) > (right[i] ?? 0))
+            return 1;
+        if ((left[i] ?? 0) < (right[i] ?? 0))
+            return -1;
+    }
+    return 0;
+}
+async function readPresetManifest(presetDir) {
+    const candidates = ["preset.yaml", "preset.yml", "preset.json"];
+    for (const name of candidates) {
+        const file = node_path_1.default.join(presetDir, name);
+        if (!(await (0, utils_1.fileExists)(file)))
+            continue;
+        if (name.endsWith(".json")) {
+            const parsed = JSON.parse(await promises_1.default.readFile(file, "utf8"));
+            const presetName = typeof parsed.name === "string" ? parsed.name.trim() : node_path_1.default.basename(presetDir);
+            return {
+                name: presetName,
+                version: typeof parsed.version === "string" ? parsed.version : undefined,
+                priority: typeof parsed.priority === "number" ? parsed.priority : 0,
+                min_prodo_version: typeof parsed.min_prodo_version === "string" ? parsed.min_prodo_version : undefined,
+                max_prodo_version: typeof parsed.max_prodo_version === "string" ? parsed.max_prodo_version : undefined,
+                command_packs: Array.isArray(parsed.command_packs)
+                    ? parsed.command_packs.filter((item) => typeof item === "string")
+                    : []
+            };
+        }
+        const parsed = js_yaml_1.default.load(await promises_1.default.readFile(file, "utf8")) ?? {};
+        const presetName = typeof parsed.name === "string" ? parsed.name.trim() : node_path_1.default.basename(presetDir);
+        return {
+            name: presetName,
+            version: typeof parsed.version === "string" ? parsed.version : undefined,
+            priority: typeof parsed.priority === "number" ? parsed.priority : 0,
+            min_prodo_version: typeof parsed.min_prodo_version === "string" ? parsed.min_prodo_version : undefined,
+            max_prodo_version: typeof parsed.max_prodo_version === "string" ? parsed.max_prodo_version : undefined,
+            command_packs: Array.isArray(parsed.command_packs)
+                ? parsed.command_packs.filter((item) => typeof item === "string")
+                : []
+        };
+    }
+    throw new errors_1.UserError(`Preset manifest is missing in ${presetDir} (expected preset.yaml or preset.json).`);
+}
+async function collectFilesRecursive(rootDir) {
+    if (!(await (0, utils_1.fileExists)(rootDir)))
+        return [];
+    const out = [];
+    const walk = async (current) => {
+        const entries = await promises_1.default.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full);
+            }
+            else {
+                out.push(full);
+            }
+        }
+    };
+    await walk(rootDir);
+    return out;
+}
+async function collectPresetOps(presetDir, prodoRoot, priority, order) {
+    const lanes = ["prompts", "schemas", "templates", "commands"];
+    const ops = [];
+    for (const lane of lanes) {
+        const sourceBase = node_path_1.default.join(presetDir, lane);
+        const files = await collectFilesRecursive(sourceBase);
+        for (const source of files) {
+            const relative = node_path_1.default.relative(sourceBase, source);
+            ops.push({
+                source,
+                target: node_path_1.default.join(prodoRoot, lane, relative),
+                priority,
+                order
+            });
+        }
+    }
+    return ops;
+}
+async function resolvePresetDir(projectRoot, presetName) {
+    const candidates = [
+        node_path_1.default.join(projectRoot, "presets", presetName),
+        node_path_1.default.resolve(__dirname, "..", "presets", presetName)
+    ];
+    for (const candidate of candidates) {
+        if (await (0, utils_1.fileExists)(candidate))
+            return candidate;
+    }
+    throw new errors_1.UserError(`Preset not found: ${presetName}. Create presets/${presetName} with a preset manifest.`);
+}
+async function writeInstalledPresets(prodoRoot, names) {
+    const file = node_path_1.default.join(prodoRoot, "presets", "installed.json");
+    await (0, utils_1.ensureDir)(node_path_1.default.dirname(file));
+    await promises_1.default.writeFile(file, `${JSON.stringify(Array.from(new Set(names)).sort(), null, 2)}\n`, "utf8");
+}
+async function readInstalledPresets(prodoRoot) {
+    const file = node_path_1.default.join(prodoRoot, "presets", "installed.json");
+    if (!(await (0, utils_1.fileExists)(file)))
+        return [];
+    try {
+        const parsed = JSON.parse(await promises_1.default.readFile(file, "utf8"));
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .filter((item) => typeof item === "string")
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+async function applyCopyOps(ops) {
+    const selected = new Map();
+    for (const op of ops) {
+        const current = selected.get(op.target);
+        if (!current) {
+            selected.set(op.target, op);
+            continue;
+        }
+        if (op.priority > current.priority || (op.priority === current.priority && op.order > current.order)) {
+            selected.set(op.target, op);
+        }
+    }
+    for (const op of selected.values()) {
+        await (0, utils_1.ensureDir)(node_path_1.default.dirname(op.target));
+        await promises_1.default.copyFile(op.source, op.target);
+    }
+}
+async function collectCommandPackOps(projectRoot, prodoRoot, names) {
+    const ops = [];
+    for (const [index, name] of names.entries()) {
+        const base = node_path_1.default.join(projectRoot, "command-packs", name);
+        if (!(await (0, utils_1.fileExists)(base))) {
+            throw new errors_1.UserError(`Command pack not found: command-packs/${name}`);
+        }
+        const laneMap = {
+            commands: "commands"
+        };
+        for (const [sourceLane, targetLane] of Object.entries(laneMap)) {
+            const sourceBase = node_path_1.default.join(base, sourceLane);
+            const files = await collectFilesRecursive(sourceBase);
+            for (const source of files) {
+                const relative = node_path_1.default.relative(sourceBase, source);
+                ops.push({
+                    source,
+                    target: node_path_1.default.join(prodoRoot, targetLane, relative),
+                    priority: 100,
+                    order: index
+                });
+            }
+        }
+    }
+    return ops;
+}
+async function applyConfiguredPresets(projectRoot, prodoRoot, prodoVersion, presetOverride) {
+    const config = await (0, project_config_1.readProjectConfig)(projectRoot);
+    const presets = Array.from(new Set([...(config.presets ?? []), ...(presetOverride ? [presetOverride] : [])]));
+    const existingInstalled = await readInstalledPresets(prodoRoot);
+    const allOps = [];
+    const installedNames = [...existingInstalled];
+    const commandPacks = new Set(config.command_packs ?? []);
+    for (const [order, presetName] of presets.entries()) {
+        const presetDir = await resolvePresetDir(projectRoot, presetName);
+        const manifest = await readPresetManifest(presetDir);
+        if (manifest.min_prodo_version && cmpVersion(prodoVersion, manifest.min_prodo_version) < 0) {
+            throw new errors_1.UserError(`Preset ${presetName} requires prodo >= ${manifest.min_prodo_version}, current is ${prodoVersion}.`);
+        }
+        if (manifest.max_prodo_version && cmpVersion(prodoVersion, manifest.max_prodo_version) > 0) {
+            throw new errors_1.UserError(`Preset ${presetName} supports prodo <= ${manifest.max_prodo_version}, current is ${prodoVersion}.`);
+        }
+        for (const pack of manifest.command_packs ?? []) {
+            if (pack.trim())
+                commandPacks.add(pack.trim());
+        }
+        installedNames.push(manifest.name || presetName);
+        allOps.push(...(await collectPresetOps(presetDir, prodoRoot, manifest.priority ?? 0, order)));
+    }
+    const commandPackList = Array.from(commandPacks);
+    if (commandPackList.length > 0) {
+        const commandPackOps = await collectCommandPackOps(projectRoot, prodoRoot, commandPackList);
+        allOps.push(...commandPackOps);
+    }
+    if (allOps.length > 0)
+        await applyCopyOps(allOps);
+    await writeInstalledPresets(prodoRoot, installedNames);
+    return {
+        installedPresets: Array.from(new Set(installedNames)),
+        appliedFiles: Array.from(new Set(allOps.map((item) => item.target)))
+    };
+}

package/dist/project-config.d.ts

@@ -0,0 +1,14 @@
+import type { ContractCoverage } from "./types";
+export type ArtifactConfig = {
+    name: string;
+    output_dir?: string;
+    required_headings?: string[];
+    upstream?: string[];
+    required_contracts?: Array<keyof ContractCoverage>;
+};
+export type ProdoProjectConfig = {
+    presets?: string[];
+    artifacts?: ArtifactConfig[];
+    command_packs?: string[];
+};
+export declare function readProjectConfig(cwd: string): Promise<ProdoProjectConfig>;

package/dist/project-config.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readProjectConfig = readProjectConfig;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+function sanitizeStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+function sanitizeArtifact(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const rec = raw;
+    const name = typeof rec.name === "string" ? rec.name.trim() : "";
+    if (!name)
+        return null;
+    const outputDir = typeof rec.output_dir === "string" ? rec.output_dir.trim() : undefined;
+    const requiredHeadings = sanitizeStringArray(rec.required_headings);
+    const upstream = sanitizeStringArray(rec.upstream);
+    const requiredContracts = sanitizeStringArray(rec.required_contracts)
+        .filter((value) => value === "goals" || value === "core_features" || value === "constraints");
+    return {
+        name,
+        ...(outputDir ? { output_dir: outputDir } : {}),
+        ...(requiredHeadings.length > 0 ? { required_headings: requiredHeadings } : {}),
+        ...(upstream.length > 0 ? { upstream } : {}),
+        ...(requiredContracts.length > 0 ? { required_contracts: requiredContracts } : {})
+    };
+}
+function sanitizeConfig(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const rec = raw;
+    const artifacts = Array.isArray(rec.artifacts)
+        ? rec.artifacts.map(sanitizeArtifact).filter((item) => item !== null)
+        : [];
+    return {
+        presets: sanitizeStringArray(rec.presets),
+        command_packs: sanitizeStringArray(rec.command_packs),
+        ...(artifacts.length > 0 ? { artifacts } : {})
+    };
+}
+async function readProjectConfig(cwd) {
+    const candidates = [
+        node_path_1.default.join(cwd, ".prodo", "config.json"),
+        node_path_1.default.join(cwd, "prodo.config.json")
+    ];
+    for (const candidate of candidates) {
+        if (!(await (0, utils_1.fileExists)(candidate)))
+            continue;
+        try {
+            const parsed = JSON.parse(await promises_1.default.readFile(candidate, "utf8"));
+            return sanitizeConfig(parsed);
+        }
+        catch {
+            throw new errors_1.UserError(`Invalid project config JSON: ${candidate}`);
+        }
+    }
+    return {};
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,2 @@
+import type { LLMProvider } from "../types";
+export declare function createProvider(): LLMProvider;

package/dist/providers/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProvider = createProvider;
+const mock_provider_1 = require("./mock-provider");
+const openai_provider_1 = require("./openai-provider");
+function createProvider() {
+    const provider = (process.env.PRODO_LLM_PROVIDER ?? "mock").toLowerCase();
+    if (provider === "openai") {
+        return new openai_provider_1.OpenAIProvider();
+    }
+    return new mock_provider_1.MockProvider();
+}

package/dist/providers/mock-provider.d.ts

@@ -0,0 +1,7 @@
+import type { LLMProvider, ProviderSchemaHint } from "../types";
+export declare class MockProvider implements LLMProvider {
+    generate(_prompt: string, inputContext: Record<string, unknown>, schemaHint: ProviderSchemaHint): Promise<{
+        body: string;
+        frontmatter?: Record<string, unknown>;
+    }>;
+}

package/dist/providers/mock-provider.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockProvider = void 0;
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+function asContracts(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        if (!item || typeof item !== "object")
+            return null;
+        const record = item;
+        if (typeof record.id !== "string" || typeof record.text !== "string")
+            return null;
+        return { id: record.id, text: record.text };
+    })
+        .filter((item) => item !== null);
+}
+function extractValue(markdown, heading) {
+    const aliases = heading.split("|").map((item) => item.trim().toLowerCase());
+    const lines = markdown.split(/\r?\n/);
+    let collect = false;
+    const out = [];
+    for (const raw of lines) {
+        const headingMatch = raw.match(/^#{1,6}\s+(.+?)\s*$/);
+        if (headingMatch) {
+            const current = headingMatch[1].trim().toLowerCase();
+            if (collect && !aliases.includes(current))
+                break;
+            collect = aliases.includes(current);
+            continue;
+        }
+        if (!collect)
+            continue;
+        const cleaned = raw.replace(/^\s*[-*]\s*/, "").trim();
+        if (cleaned.length > 0)
+            out.push(cleaned);
+    }
+    return out;
+}
+function normalizeWithMock(inputContext) {
+    const brief = typeof inputContext.briefMarkdown === "string" ? inputContext.briefMarkdown : "";
+    const product = extractValue(brief, "Product Name|Name")[0] ?? "";
+    const problem = extractValue(brief, "Problem|Problem Statement").join(" ");
+    const audience = extractValue(brief, "Audience|Users|Persona");
+    const goals = extractValue(brief, "Goals|Objectives");
+    const features = extractValue(brief, "Core Features|Features|Capabilities");
+    const constraints = extractValue(brief, "Constraints|Limitations|Restrictions");
+    const assumptions = extractValue(brief, "Assumptions|Open Questions");
+    const contracts = {
+        goals: goals.map((text, index) => ({ id: `G${index + 1}`, text })),
+        core_features: features.map((text, index) => ({ id: `F${index + 1}`, text })),
+        constraints: constraints.map((text, index) => ({ id: `C${index + 1}`, text }))
+    };
+    const confidence = {
+        product_name: product ? 0.95 : 0.25,
+        problem: problem ? 0.95 : 0.25,
+        audience: audience.length > 0 ? 0.95 : 0.25,
+        goals: goals.length > 0 ? 0.95 : 0.25,
+        core_features: features.length > 0 ? 0.95 : 0.25
+    };
+    return JSON.stringify({
+        schema_version: "1.0",
+        product_name: product,
+        problem,
+        audience,
+        goals,
+        core_features: features,
+        constraints,
+        assumptions,
+        contracts,
+        confidence
+    }, null, 2);
+}
+function normalizeSectionItems(inputContext) {
+    const normalizedBrief = (inputContext.normalizedBrief ?? {});
+    const goals = asStringArray(normalizedBrief.goals);
+    const features = asStringArray(normalizedBrief.core_features);
+    const constraints = asStringArray(normalizedBrief.constraints);
+    return [...goals, ...features, ...constraints];
+}
+function coverageItems(schemaHint, inputContext) {
+    const catalog = (inputContext.contractCatalog ?? {});
+    const values = [];
+    if (schemaHint.requiredContracts.includes("goals"))
+        values.push(...asContracts(catalog.goals));
+    if (schemaHint.requiredContracts.includes("core_features"))
+        values.push(...asContracts(catalog.core_features));
+    if (schemaHint.requiredContracts.includes("constraints"))
+        values.push(...asContracts(catalog.constraints));
+    return values;
+}
+function headingBlock(heading, items, fallbackText, coverage) {
+    const selected = items.slice(0, 2);
+    const contractBullets = coverage.map((item) => `- [${item.id}] ${item.text}`);
+    const bullets = [...contractBullets, ...selected.map((item) => `- ${item}`)];
+    const finalBullets = bullets.length > 0 ? bullets.join("\n") : `- ${fallbackText}`;
+    return `${heading}\n${finalBullets}\n`;
+}
+function buildArtifactBody(schemaHint, inputContext) {
+    const normalizedBrief = (inputContext.normalizedBrief ?? {});
+    const productName = typeof normalizedBrief.product_name === "string" ? normalizedBrief.product_name : "Product";
+    const lang = typeof inputContext.outputLanguage === "string" ? inputContext.outputLanguage.toLowerCase() : "en";
+    const items = normalizeSectionItems(inputContext);
+    const coverage = coverageItems(schemaHint, inputContext);
+    const fallback = lang === "tr" ? "Detay daha sonra netlestirilecek." : "To be refined.";
+    const sections = schemaHint.requiredHeadings.map((heading) => headingBlock(heading, items, fallback, coverage));
+    const title = lang === "tr"
+        ? `# ${productName} icin ${schemaHint.artifactType.toUpperCase()}`
+        : `# ${schemaHint.artifactType.toUpperCase()} for ${productName}`;
+    if (schemaHint.artifactType === "workflow") {
+        return `${title}\n\n${sections.join("\n")}\n\n\`\`\`mermaid
+flowchart TD
+  A[Start] --> B[[F1] User Action]
+  B --> C[System Step]
+  C --> D[Done]
+\`\`\``.trim();
+    }
+    return `${title}\n\n${sections.join("\n")}\n\n${lang === "tr" ? "Not" : "Note"}: ${fallback}`.trim();
+}
+function semanticIssuesWithMock(inputContext) {
+    const pair = inputContext.pair;
+    const leftBody = typeof pair?.left_body === "string" ? pair.left_body : "";
+    const rightBody = typeof pair?.right_body === "string" ? pair.right_body : "";
+    const leftFile = typeof pair?.left_file === "string" ? pair.left_file : "";
+    const rightFile = typeof pair?.right_file === "string" ? pair.right_file : "";
+    const issues = [];
+    const contradiction = /guest checkout/i.test(leftBody) && /(auth required|requires auth|must login)/i.test(rightBody);
+    if (contradiction) {
+        issues.push({
+            level: "error",
+            code: "semantic_contradiction",
+            check: "semantic_consistency",
+            contract_id: "F1",
+            file: rightFile || leftFile,
+            message: "Workflow allows guest checkout but paired artifact requires authentication.",
+            suggestion: "Align auth behavior across both artifacts."
+        });
+    }
+    return JSON.stringify({ issues }, null, 2);
+}
+function contractRelevanceWithMock(inputContext) {
+    const contractText = typeof inputContext.contract_text === "string" ? inputContext.contract_text.toLowerCase() : "";
+    const contextText = typeof inputContext.context_text === "string" ? inputContext.context_text.toLowerCase() : "";
+    const terms = contractText
+        .split(/\W+/)
+        .map((term) => term.trim())
+        .filter((term) => term.length > 3);
+    const overlap = terms.filter((term) => contextText.includes(term)).length;
+    const relevant = terms.length === 0 ? true : overlap / terms.length >= 0.25;
+    return JSON.stringify({ relevant, score: terms.length === 0 ? 1 : overlap / terms.length }, null, 2);
+}
+class MockProvider {
+    async generate(_prompt, inputContext, schemaHint) {
+        if (schemaHint.artifactType === "normalize")
+            return { body: normalizeWithMock(inputContext) };
+        if (schemaHint.artifactType === "semantic_consistency")
+            return { body: semanticIssuesWithMock(inputContext) };
+        if (schemaHint.artifactType === "contract_relevance")
+            return { body: contractRelevanceWithMock(inputContext) };
+        return { body: buildArtifactBody(schemaHint, inputContext) };
+    }
+}
+exports.MockProvider = MockProvider;

package/dist/providers/openai-provider.d.ts

@@ -0,0 +1,11 @@
+import type { LLMProvider, ProviderSchemaHint } from "../types";
+export declare class OpenAIProvider implements LLMProvider {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    constructor();
+    generate(prompt: string, inputContext: Record<string, unknown>, schemaHint: ProviderSchemaHint): Promise<{
+        body: string;
+        frontmatter?: Record<string, unknown>;
+    }>;
+}