@shahmarasy/prodo 0.1.0

package/dist/init.js

@@ -0,0 +1,307 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const agent_command_installer_1 = require("./agent-command-installer");
+const artifact_registry_1 = require("./artifact-registry");
+const utils_1 = require("./utils");
+const paths_1 = require("./paths");
+const preset_loader_1 = require("./preset-loader");
+const registry_1 = require("./registry");
+const settings_1 = require("./settings");
+const workflow_commands_1 = require("./workflow-commands");
+const templates_1 = require("./templates");
+function templateFileName(artifactType) {
+    if (artifactType === "workflow")
+        return `${artifactType}.mmd`;
+    if (artifactType === "wireframe")
+        return `${artifactType}.html`;
+    return `${artifactType}.md`;
+}
+async function writeFileIfMissing(filePath, content) {
+    if (await (0, utils_1.fileExists)(filePath))
+        return;
+    await promises_1.default.writeFile(filePath, content, "utf8");
+}
+async function readProdoVersion(cwd) {
+    const candidates = [
+        node_path_1.default.join(cwd, "package.json"),
+        node_path_1.default.resolve(__dirname, "..", "package.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"));
+            if (typeof parsed.version === "string" && parsed.version.trim().length > 0)
+                return parsed.version;
+        }
+        catch {
+            // ignore and continue
+        }
+    }
+    return "0.0.0-dev";
+}
+async function fileSha256(filePath) {
+    const content = await promises_1.default.readFile(filePath);
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+async function listFilesRecursive(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 loadPreviousManifest(root) {
+    const manifestPath = node_path_1.default.join(root, "scaffold-manifest.json");
+    if (!(await (0, utils_1.fileExists)(manifestPath)))
+        return null;
+    try {
+        const parsed = JSON.parse(await promises_1.default.readFile(manifestPath, "utf8"));
+        if (!Array.isArray(parsed.assets))
+            return null;
+        return {
+            schema_version: "1.0",
+            generated_at: parsed.generated_at ?? "",
+            prodo_version: parsed.prodo_version ?? "0.0.0-dev",
+            copied_asset_count: Number(parsed.copied_asset_count ?? 0),
+            copied_assets: Array.isArray(parsed.copied_assets) ? parsed.copied_assets : [],
+            asset_count: Number(parsed.asset_count ?? 0),
+            parity_summary: {
+                match_count: Number(parsed.parity_summary?.match_count ?? 0),
+                drift_count: Number(parsed.parity_summary?.drift_count ?? 0),
+                missing_count: Number(parsed.parity_summary?.missing_count ?? 0),
+                protected_count: Number(parsed.parity_summary?.protected_count ?? 0),
+                updated_count: Number(parsed.parity_summary?.updated_count ?? 0),
+                unmanaged_count: Number(parsed.parity_summary?.unmanaged_count ?? 0)
+            },
+            assets: parsed.assets
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function copyDirIfMissing(sourceDir, targetDir, copiedAssets) {
+    if (!(await (0, utils_1.fileExists)(sourceDir)))
+        return;
+    await (0, utils_1.ensureDir)(targetDir);
+    const entries = await promises_1.default.readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const src = node_path_1.default.join(sourceDir, entry.name);
+        const dst = node_path_1.default.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirIfMissing(src, dst, copiedAssets);
+            continue;
+        }
+        if (await (0, utils_1.fileExists)(dst))
+            continue;
+        await promises_1.default.copyFile(src, dst);
+        copiedAssets.push({
+            source: src,
+            target: dst,
+            sha256: await fileSha256(dst)
+        });
+    }
+}
+async function buildAssetManifest(pairs, previous, backup) {
+    const previousByTarget = new Map();
+    for (const item of previous?.assets ?? []) {
+        previousByTarget.set(node_path_1.default.resolve(item.target), item);
+    }
+    const items = [];
+    for (const pair of pairs) {
+        const sourceFiles = await listFilesRecursive(pair.sourceDir);
+        for (const sourceFile of sourceFiles) {
+            const relative = node_path_1.default.relative(pair.sourceDir, sourceFile);
+            const targetFile = node_path_1.default.join(pair.targetDir, relative);
+            const resolvedTarget = node_path_1.default.resolve(targetFile);
+            const sourceHash = await fileSha256(sourceFile);
+            const targetExists = await (0, utils_1.fileExists)(targetFile);
+            if (!targetExists) {
+                await (0, utils_1.ensureDir)(node_path_1.default.dirname(targetFile));
+                backup.set(resolvedTarget, null);
+                await promises_1.default.copyFile(sourceFile, targetFile);
+                items.push({
+                    source: sourceFile,
+                    target: targetFile,
+                    source_sha256: sourceHash,
+                    target_sha256: await fileSha256(targetFile),
+                    status: "missing"
+                });
+                continue;
+            }
+            const currentTargetHash = await fileSha256(targetFile);
+            const prev = previousByTarget.get(resolvedTarget);
+            const prevTargetHash = prev?.target_sha256 ?? null;
+            const prevSourceHash = prev?.source_sha256 ?? null;
+            if (currentTargetHash === sourceHash) {
+                items.push({
+                    source: sourceFile,
+                    target: targetFile,
+                    source_sha256: sourceHash,
+                    target_sha256: currentTargetHash,
+                    status: "match"
+                });
+                continue;
+            }
+            if (prev && prevTargetHash && prevSourceHash && currentTargetHash === prevTargetHash && prevSourceHash !== sourceHash) {
+                if (!backup.has(resolvedTarget)) {
+                    backup.set(resolvedTarget, await promises_1.default.readFile(targetFile));
+                }
+                await promises_1.default.copyFile(sourceFile, targetFile);
+                items.push({
+                    source: sourceFile,
+                    target: targetFile,
+                    source_sha256: sourceHash,
+                    target_sha256: await fileSha256(targetFile),
+                    status: "updated"
+                });
+                continue;
+            }
+            if (prev) {
+                items.push({
+                    source: sourceFile,
+                    target: targetFile,
+                    source_sha256: sourceHash,
+                    target_sha256: currentTargetHash,
+                    status: "protected"
+                });
+                continue;
+            }
+            items.push({
+                source: sourceFile,
+                target: targetFile,
+                source_sha256: sourceHash,
+                target_sha256: currentTargetHash,
+                status: "unmanaged"
+            });
+        }
+    }
+    return items;
+}
+async function rollbackFiles(backup) {
+    for (const [target, content] of backup.entries()) {
+        if (content === null) {
+            if (await (0, utils_1.fileExists)(target))
+                await promises_1.default.rm(target, { force: true });
+            continue;
+        }
+        await (0, utils_1.ensureDir)(node_path_1.default.dirname(target));
+        await promises_1.default.writeFile(target, content);
+    }
+}
+function summarizeParity(items) {
+    const byStatus = (status) => items.filter((item) => item.status === status).length;
+    return {
+        match_count: byStatus("match"),
+        drift_count: byStatus("drift"),
+        missing_count: byStatus("missing"),
+        protected_count: byStatus("protected"),
+        updated_count: byStatus("updated"),
+        unmanaged_count: byStatus("unmanaged")
+    };
+}
+async function runInit(cwd, options) {
+    const root = (0, paths_1.prodoPath)(cwd);
+    const artifactDefs = await (0, artifact_registry_1.listArtifactDefinitions)(cwd);
+    const artifactTypes = artifactDefs.map((item) => item.name);
+    const workflowCommands = (0, workflow_commands_1.buildWorkflowCommands)(artifactTypes);
+    const prodoVersion = await readProdoVersion(cwd);
+    const localRepoTemplates = node_path_1.default.join(cwd, "templates");
+    const packagedTemplates = node_path_1.default.resolve(__dirname, "..", "templates");
+    const projectScaffoldTemplates = (await (0, utils_1.fileExists)(localRepoTemplates)) ? localRepoTemplates : packagedTemplates;
+    const copiedAssets = [];
+    const backup = new Map();
+    const previousManifest = await loadPreviousManifest(root);
+    await (0, utils_1.ensureDir)(node_path_1.default.join(root, "briefs"));
+    await (0, utils_1.ensureDir)(node_path_1.default.join(root, "schemas"));
+    await (0, utils_1.ensureDir)(node_path_1.default.join(root, "prompts"));
+    await (0, utils_1.ensureDir)(node_path_1.default.join(root, "commands"));
+    await (0, utils_1.ensureDir)(node_path_1.default.join(root, "presets"));
+    await (0, utils_1.ensureDir)(node_path_1.default.join(root, "templates"));
+    await (0, utils_1.ensureDir)(node_path_1.default.join(root, "templates", "overrides"));
+    await (0, utils_1.ensureDir)(node_path_1.default.join(root, "state"));
+    await (0, utils_1.ensureDir)(node_path_1.default.join(root, "state", "context"));
+    for (const def of artifactDefs) {
+        await (0, utils_1.ensureDir)((0, paths_1.outputDirPath)(cwd, def.name, def.output_dir));
+    }
+    await (0, utils_1.ensureDir)(node_path_1.default.join(cwd, "product-docs", "reports"));
+    await writeFileIfMissing((0, paths_1.outputIndexPath)(cwd), `${JSON.stringify({ active: {}, history: {}, updated_at: new Date(0).toISOString() }, null, 2)}\n`);
+    await writeFileIfMissing((0, paths_1.briefPath)(cwd), templates_1.START_BRIEF_TEMPLATE);
+    await writeFileIfMissing(node_path_1.default.join(root, "briefs", "normalized-brief.json"), `${JSON.stringify(templates_1.NORMALIZED_BRIEF_TEMPLATE, null, 2)}\n`);
+    await writeFileIfMissing(node_path_1.default.join(root, "hooks.yml"), templates_1.HOOKS_TEMPLATE);
+    await writeFileIfMissing(node_path_1.default.join(root, "prompts", "normalize.md"), `${templates_1.NORMALIZE_PROMPT_TEMPLATE}\n`);
+    const scriptType = options?.script ?? (process.platform === "win32" ? "ps" : "sh");
+    await promises_1.default.writeFile(node_path_1.default.join(root, "init-options.json"), `${JSON.stringify({ ai: options?.ai ?? null, lang: options?.lang ?? "en", preset: options?.preset ?? null, script: scriptType }, null, 2)}\n`, "utf8");
+    await copyDirIfMissing(node_path_1.default.join(projectScaffoldTemplates, "artifacts"), node_path_1.default.join(root, "templates"), copiedAssets);
+    for (const artifact of artifactDefs) {
+        const schema = {
+            ...(0, templates_1.schemaTemplate)(artifact.name),
+            x_required_headings: artifact.required_headings
+        };
+        await writeFileIfMissing(node_path_1.default.join(root, "schemas", `${artifact.name}.yaml`), js_yaml_1.default.dump(schema));
+        await writeFileIfMissing(node_path_1.default.join(root, "prompts", `${artifact.name}.md`), `${(0, templates_1.promptTemplate)(artifact.name, options?.lang ?? "en")}\n`);
+        await writeFileIfMissing(node_path_1.default.join(root, "templates", templateFileName(artifact.name)), `${(0, templates_1.artifactTemplateTemplate)(artifact.name, options?.lang ?? "en")}\n`);
+    }
+    await copyDirIfMissing(node_path_1.default.join(projectScaffoldTemplates, "commands"), node_path_1.default.join(root, "commands"), copiedAssets);
+    for (const command of workflowCommands) {
+        await writeFileIfMissing(node_path_1.default.join(root, "commands", `${command.name}.md`), `${(0, templates_1.commandTemplate)(command)}\n`);
+    }
+    await (0, preset_loader_1.applyConfiguredPresets)(cwd, root, prodoVersion, options?.preset);
+    const pairs = [
+        {
+            sourceDir: node_path_1.default.join(projectScaffoldTemplates, "commands"),
+            targetDir: node_path_1.default.join(root, "commands")
+        },
+        {
+            sourceDir: node_path_1.default.join(projectScaffoldTemplates, "artifacts"),
+            targetDir: node_path_1.default.join(root, "templates")
+        }
+    ];
+    let parity = [];
+    try {
+        parity = await buildAssetManifest(pairs, previousManifest, backup);
+    }
+    catch (error) {
+        await rollbackFiles(backup);
+        throw error;
+    }
+    const installedAgentFiles = options?.ai ? await (0, agent_command_installer_1.installAgentCommands)(cwd, options.ai) : [];
+    const manifest = {
+        schema_version: "1.0",
+        generated_at: new Date().toISOString(),
+        prodo_version: prodoVersion,
+        copied_asset_count: copiedAssets.length,
+        copied_assets: copiedAssets,
+        asset_count: parity.length,
+        parity_summary: summarizeParity(parity),
+        assets: parity
+    };
+    await promises_1.default.writeFile(node_path_1.default.join(root, "scaffold-manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+    await (0, registry_1.syncRegistry)(cwd);
+    const settingsPath = await (0, settings_1.writeSettings)(cwd, {
+        lang: (options?.lang ?? "en").trim() || "en",
+        ai: options?.ai
+    });
+    return { installedAgentFiles, settingsPath };
+}

package/dist/markdown.d.ts

@@ -0,0 +1,11 @@
+export type MarkdownSection = {
+    heading: string;
+    headingKey: string;
+    level: number;
+    textLines: string[];
+    listItems: string[];
+};
+export declare function normalizeHeadingKey(heading: string): string;
+export declare function parseMarkdownSections(markdown: string): MarkdownSection[];
+export declare function extractRequiredHeadings(content: string): string[];
+export declare function sectionTextMap(content: string): Map<string, string>;

package/dist/markdown.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHeadingKey = normalizeHeadingKey;
+exports.parseMarkdownSections = parseMarkdownSections;
+exports.extractRequiredHeadings = extractRequiredHeadings;
+exports.sectionTextMap = sectionTextMap;
+function normalizeText(input) {
+    return input.trim().replace(/\s+/g, " ");
+}
+function normalizeHeadingKey(heading) {
+    return normalizeText(heading)
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function parseMarkdownSections(markdown) {
+    const sections = [];
+    let current = null;
+    for (const rawLine of markdown.split(/\r?\n/)) {
+        const headingMatch = rawLine.match(/^\s*(#{1,6})\s+(.+?)\s*$/);
+        if (headingMatch) {
+            const title = normalizeText(headingMatch[2]);
+            current = {
+                heading: title,
+                headingKey: normalizeHeadingKey(title),
+                level: headingMatch[1].length,
+                textLines: [],
+                listItems: []
+            };
+            sections.push(current);
+            continue;
+        }
+        if (!current)
+            continue;
+        const listMatch = rawLine.match(/^\s*(?:[-*+]|\d+\.)\s+(.+?)\s*$/);
+        if (listMatch) {
+            const item = normalizeText(listMatch[1]);
+            if (item.length > 0 && !current.listItems.includes(item))
+                current.listItems.push(item);
+            if (item.length > 0)
+                current.textLines.push(item);
+            continue;
+        }
+        const text = normalizeText(rawLine);
+        if (text.length > 0)
+            current.textLines.push(text);
+    }
+    return sections;
+}
+function extractRequiredHeadings(content) {
+    const sections = parseMarkdownSections(content);
+    return sections
+        .filter((section) => section.level === 2)
+        .map((section) => `## ${section.heading}`)
+        .filter((heading) => heading.length > 3);
+}
+function sectionTextMap(content) {
+    const sections = parseMarkdownSections(content);
+    const mapped = new Map();
+    for (const section of sections) {
+        const parts = [...section.listItems, ...section.textLines].filter((item) => item.length > 0);
+        mapped.set(`## ${section.heading}`, parts.join("\n").trim());
+    }
+    return mapped;
+}

package/dist/normalize.d.ts

@@ -0,0 +1,7 @@
+type NormalizeOptions = {
+    cwd: string;
+    brief?: string;
+    out?: string;
+};
+export declare function runNormalize(options: NormalizeOptions): Promise<string>;
+export {};

package/dist/normalize.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNormalize = runNormalize;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const normalized_brief_1 = require("./normalized-brief");
+const paths_1 = require("./paths");
+const providers_1 = require("./providers");
+const settings_1 = require("./settings");
+const utils_1 = require("./utils");
+function extractJsonObject(raw) {
+    const trimmed = raw.trim();
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidate = fenced ? fenced[1] : trimmed;
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        throw new errors_1.UserError("Normalizer provider did not return valid JSON.");
+    }
+}
+async function runNormalize(options) {
+    const { cwd } = options;
+    const root = (0, paths_1.prodoPath)(cwd);
+    if (!(await (0, utils_1.fileExists)(root))) {
+        throw new errors_1.UserError("Missing .prodo directory. Run `prodo init .` first.");
+    }
+    const inPath = options.brief ? node_path_1.default.resolve(cwd, options.brief) : (0, paths_1.briefPath)(cwd);
+    if (!(await (0, utils_1.fileExists)(inPath))) {
+        throw new errors_1.UserError(`Brief file not found: ${inPath}`);
+    }
+    const rawBrief = await promises_1.default.readFile(inPath, "utf8");
+    const normalizePromptPath = node_path_1.default.join(root, "prompts", "normalize.md");
+    const normalizePrompt = await promises_1.default.readFile(normalizePromptPath, "utf8");
+    const settings = await (0, settings_1.readSettings)(cwd);
+    const provider = (0, providers_1.createProvider)();
+    const generated = await provider.generate(normalizePrompt, {
+        briefMarkdown: rawBrief,
+        sourceBriefPath: inPath,
+        outputLanguage: settings.lang
+    }, {
+        artifactType: "normalize",
+        requiredHeadings: [],
+        requiredContracts: []
+    });
+    const parsed = extractJsonObject(generated.body);
+    const withContracts = {
+        ...parsed,
+        contracts: parsed.contracts ??
+            (0, normalized_brief_1.buildContractsFromArrays)({
+                goals: Array.isArray(parsed.goals) ? parsed.goals.filter((x) => typeof x === "string") : [],
+                core_features: Array.isArray(parsed.core_features)
+                    ? parsed.core_features.filter((x) => typeof x === "string")
+                    : [],
+                constraints: Array.isArray(parsed.constraints)
+                    ? parsed.constraints.filter((x) => typeof x === "string")
+                    : []
+            })
+    };
+    const normalized = (0, normalized_brief_1.parseNormalizedBriefOrThrow)(withContracts);
+    (0, normalized_brief_1.requireConfidenceOrThrow)(normalized, ["product_name", "problem", "audience", "goals", "core_features"], 0.7);
+    const outPath = options.out ? node_path_1.default.resolve(cwd, options.out) : (0, paths_1.normalizedBriefPath)(cwd);
+    if (!(0, utils_1.isPathInside)((0, paths_1.prodoPath)(cwd), outPath)) {
+        throw new errors_1.UserError("Normalize output must be inside `.prodo/`.");
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(outPath), { recursive: true });
+    await promises_1.default.writeFile(outPath, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
+    return outPath;
+}

package/dist/normalized-brief.d.ts

@@ -0,0 +1,39 @@
+import type { ValidationIssue } from "./types";
+export type BriefContractItem = {
+    id: string;
+    text: string;
+};
+export type NormalizedBrief = {
+    schema_version: string;
+    product_name: string;
+    problem: string;
+    audience: string[];
+    goals: string[];
+    core_features: string[];
+    constraints: string[];
+    assumptions: string[];
+    contracts: {
+        goals: BriefContractItem[];
+        core_features: BriefContractItem[];
+        constraints: BriefContractItem[];
+    };
+    confidence?: Record<string, number>;
+};
+type BriefContracts = NormalizedBrief["contracts"];
+export declare function buildContractsFromArrays(input: {
+    goals: string[];
+    core_features: string[];
+    constraints: string[];
+}): BriefContracts;
+export declare function parseNormalizedBrief(input: Record<string, unknown>): {
+    brief: NormalizedBrief;
+    issues: ValidationIssue[];
+};
+export declare function parseNormalizedBriefOrThrow(input: Record<string, unknown>): NormalizedBrief;
+export declare function requireConfidenceOrThrow(brief: NormalizedBrief, fields: Array<keyof Pick<NormalizedBrief, "product_name" | "problem" | "audience" | "goals" | "core_features">>, threshold?: number): void;
+export declare function contractIds(contracts: BriefContracts): {
+    goals: string[];
+    core_features: string[];
+    constraints: string[];
+};
+export {};

package/dist/normalized-brief.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildContractsFromArrays = buildContractsFromArrays;
+exports.parseNormalizedBrief = parseNormalizedBrief;
+exports.parseNormalizedBriefOrThrow = parseNormalizedBriefOrThrow;
+exports.requireConfidenceOrThrow = requireConfidenceOrThrow;
+exports.contractIds = contractIds;
+const _2020_1 = __importDefault(require("ajv/dist/2020"));
+const errors_1 = require("./errors");
+const schema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    required: [
+        "schema_version",
+        "product_name",
+        "problem",
+        "audience",
+        "goals",
+        "core_features",
+        "constraints",
+        "assumptions",
+        "contracts"
+    ],
+    properties: {
+        schema_version: { type: "string", minLength: 1 },
+        product_name: { type: "string", minLength: 2 },
+        problem: { type: "string", minLength: 10 },
+        audience: { type: "array", minItems: 1, items: { type: "string", minLength: 2 } },
+        goals: { type: "array", minItems: 1, items: { type: "string", minLength: 2 } },
+        core_features: { type: "array", minItems: 1, items: { type: "string", minLength: 2 } },
+        constraints: { type: "array", items: { type: "string", minLength: 2 } },
+        assumptions: { type: "array", items: { type: "string", minLength: 2 } },
+        contracts: {
+            type: "object",
+            required: ["goals", "core_features", "constraints"],
+            properties: {
+                goals: { $ref: "#/$defs/contractArray" },
+                core_features: { $ref: "#/$defs/contractArray" },
+                constraints: { $ref: "#/$defs/contractArray" }
+            },
+            additionalProperties: false
+        },
+        confidence: {
+            type: "object",
+            additionalProperties: { type: "number", minimum: 0, maximum: 1 }
+        }
+    },
+    $defs: {
+        contractItem: {
+            type: "object",
+            required: ["id", "text"],
+            properties: {
+                id: { type: "string", pattern: "^[A-Z]+[0-9]+$" },
+                text: { type: "string", minLength: 2 }
+            },
+            additionalProperties: false
+        },
+        contractArray: { type: "array", items: { $ref: "#/$defs/contractItem" } }
+    },
+    additionalProperties: false
+};
+const ajv = new _2020_1.default({ allErrors: true, strict: false });
+const validateFn = ajv.compile(schema);
+function asString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => asString(item))
+        .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;
+        const id = asString(record.id);
+        const text = asString(record.text);
+        if (!id || !text)
+            return null;
+        return { id, text };
+    })
+        .filter((item) => item !== null);
+}
+function asConfidence(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const result = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw !== "number" || Number.isNaN(raw))
+            continue;
+        result[key] = raw;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function normalizeInput(input) {
+    const rawContracts = input.contracts ?? {};
+    return {
+        schema_version: asString(input.schema_version) ?? "1.0",
+        product_name: asString(input.product_name) ?? "",
+        problem: asString(input.problem) ?? "",
+        audience: asStringArray(input.audience),
+        goals: asStringArray(input.goals),
+        core_features: asStringArray(input.core_features),
+        constraints: asStringArray(input.constraints),
+        assumptions: asStringArray(input.assumptions),
+        contracts: {
+            goals: asContracts(rawContracts.goals),
+            core_features: asContracts(rawContracts.core_features),
+            constraints: asContracts(rawContracts.constraints)
+        },
+        confidence: asConfidence(input.confidence)
+    };
+}
+function buildContractsFromArrays(input) {
+    return {
+        goals: input.goals.map((text, index) => ({ id: `G${index + 1}`, text })),
+        core_features: input.core_features.map((text, index) => ({ id: `F${index + 1}`, text })),
+        constraints: input.constraints.map((text, index) => ({ id: `C${index + 1}`, text }))
+    };
+}
+function parseNormalizedBrief(input) {
+    const normalized = normalizeInput(input);
+    const valid = validateFn(normalized);
+    if (valid)
+        return { brief: normalized, issues: [] };
+    const errors = validateFn.errors ?? [];
+    const issues = errors.map((error) => ({
+        level: "error",
+        code: "normalized_brief_invalid",
+        check: "schema",
+        field: error.instancePath || error.schemaPath,
+        message: `Normalized brief schema error: ${error.message ?? "unknown error"}`,
+        suggestion: "Fix missing content in start brief and rerun `prodo normalize`."
+    }));
+    return { brief: normalized, issues };
+}
+function parseNormalizedBriefOrThrow(input) {
+    const { brief, issues } = parseNormalizedBrief(input);
+    if (issues.length > 0) {
+        const detail = issues.map((issue) => `- ${issue.message}`).join("\n");
+        throw new errors_1.UserError(`Normalized brief is invalid:\n${detail}`);
+    }
+    return brief;
+}
+function requireConfidenceOrThrow(brief, fields, threshold = 0.7) {
+    const confidence = brief.confidence ?? {};
+    const missing = fields.filter((field) => (confidence[field] ?? 0) < threshold);
+    if (missing.length > 0) {
+        throw new errors_1.UserError(`Normalization confidence too low for: ${missing.join(", ")}. Improve brief clarity and rerun \`prodo normalize\`.`);
+    }
+}
+function contractIds(contracts) {
+    return {
+        goals: contracts.goals.map((item) => item.id),
+        core_features: contracts.core_features.map((item) => item.id),
+        constraints: contracts.constraints.map((item) => item.id)
+    };
+}