@shahmarasy/prodo 0.1.3 → 0.1.5

package/dist/core/fix.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFixTargets = resolveFixTargets;
+exports.buildFixProposal = buildFixProposal;
+exports.createBackup = createBackup;
+exports.restoreBackup = restoreBackup;
+exports.applyFix = applyFix;
+exports.runFix = runFix;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const artifact_registry_1 = require("./artifact-registry");
+const artifacts_1 = require("./artifacts");
+const errors_1 = require("./errors");
+const hook_executor_1 = require("./hook-executor");
+const normalize_1 = require("./normalize");
+const output_index_1 = require("./output-index");
+const paths_1 = require("./paths");
+const utils_1 = require("./utils");
+const validate_1 = require("./validate");
+async function resolveFixTargets(cwd, artifactTypes, issues) {
+    const direct = new Set(issues
+        .map((issue) => issue.artifactType)
+        .filter((artifactType) => typeof artifactType === "string" && artifactTypes.includes(artifactType)));
+    if (direct.size === 0)
+        return artifactTypes;
+    const defs = await (0, artifact_registry_1.listArtifactDefinitions)(cwd);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const def of defs) {
+            const needsRefresh = def.upstream.some((upstream) => direct.has(upstream));
+            if (needsRefresh && !direct.has(def.name)) {
+                direct.add(def.name);
+                changed = true;
+            }
+        }
+    }
+    return artifactTypes.filter((artifactType) => direct.has(artifactType));
+}
+async function buildFixProposal(options) {
+    const { cwd, strict, report } = options;
+    const initialReport = await (0, validate_1.runValidate)(cwd, {
+        strict: Boolean(strict),
+        report
+    });
+    if (initialReport.pass) {
+        return {
+            targets: [],
+            issues: [],
+            issuesByArtifact: new Map(),
+            initialReport
+        };
+    }
+    const artifactTypes = await (0, artifact_registry_1.listArtifactTypes)(cwd);
+    const targets = await resolveFixTargets(cwd, artifactTypes, initialReport.issues);
+    const issuesByArtifact = new Map();
+    for (const issue of initialReport.issues) {
+        if (issue.artifactType) {
+            const existing = issuesByArtifact.get(issue.artifactType) ?? [];
+            existing.push(issue);
+            issuesByArtifact.set(issue.artifactType, existing);
+        }
+    }
+    return {
+        targets,
+        issues: initialReport.issues,
+        issuesByArtifact,
+        initialReport
+    };
+}
+function backupBasePath(cwd) {
+    return node_path_1.default.join((0, paths_1.prodoPath)(cwd), "state", "backups");
+}
+async function createBackup(cwd, targets) {
+    const slug = (0, utils_1.timestampSlug)();
+    const backupDir = node_path_1.default.join(backupBasePath(cwd), slug);
+    await (0, utils_1.ensureDir)(backupDir);
+    const manifest = [];
+    for (const type of targets) {
+        const activePath = await (0, output_index_1.getActiveArtifactPath)(cwd, type);
+        if (!activePath || !(await (0, utils_1.fileExists)(activePath)))
+            continue;
+        const relPath = node_path_1.default.relative(cwd, activePath);
+        const destPath = node_path_1.default.join(backupDir, relPath);
+        await (0, utils_1.ensureDir)(node_path_1.default.dirname(destPath));
+        await promises_1.default.copyFile(activePath, destPath);
+        manifest.push({ type, source: activePath, dest: destPath });
+        const parsed = node_path_1.default.parse(activePath);
+        const sidecar = node_path_1.default.join(parsed.dir, `${parsed.name}.artifact.json`);
+        if (await (0, utils_1.fileExists)(sidecar)) {
+            const sidecarRel = node_path_1.default.relative(cwd, sidecar);
+            const sidecarDest = node_path_1.default.join(backupDir, sidecarRel);
+            await promises_1.default.copyFile(sidecar, sidecarDest);
+        }
+        const companionExtensions = type === "workflow" ? [".mmd"] : type === "wireframe" ? [".html"] : [];
+        for (const ext of companionExtensions) {
+            const companionPath = node_path_1.default.join(parsed.dir, `${parsed.name}${ext}`);
+            if (await (0, utils_1.fileExists)(companionPath)) {
+                const companionRel = node_path_1.default.relative(cwd, companionPath);
+                const companionDest = node_path_1.default.join(backupDir, companionRel);
+                await (0, utils_1.ensureDir)(node_path_1.default.dirname(companionDest));
+                await promises_1.default.copyFile(companionPath, companionDest);
+            }
+        }
+    }
+    await promises_1.default.writeFile(node_path_1.default.join(backupDir, "_manifest.json"), `${JSON.stringify({ timestamp: slug, targets, files: manifest }, null, 2)}\n`, "utf8");
+    return backupDir;
+}
+async function restoreBackup(cwd, backupDir) {
+    const manifestPath = node_path_1.default.join(backupDir, "_manifest.json");
+    if (!(await (0, utils_1.fileExists)(manifestPath))) {
+        throw new errors_1.UserError("Backup manifest not found. Cannot restore.");
+    }
+    const manifest = JSON.parse(await promises_1.default.readFile(manifestPath, "utf8"));
+    for (const entry of manifest.files) {
+        if (await (0, utils_1.fileExists)(entry.dest)) {
+            await (0, utils_1.ensureDir)(node_path_1.default.dirname(entry.source));
+            await promises_1.default.copyFile(entry.dest, entry.source);
+        }
+    }
+}
+async function applyFix(cwd, proposal, options) {
+    const { agent, strict, report, log = console.log } = options;
+    const backupDir = await createBackup(cwd, proposal.targets);
+    await (0, hook_executor_1.runHookPhase)(cwd, "before_normalize", log);
+    const normalizedPath = await (0, normalize_1.runNormalize)({ cwd });
+    log(`Normalized brief refreshed: ${normalizedPath}`);
+    await (0, hook_executor_1.runHookPhase)(cwd, "after_normalize", log);
+    for (const type of proposal.targets) {
+        await (0, hook_executor_1.runHookPhase)(cwd, `before_${type}`, log);
+        const agentResolved = agent ?? undefined;
+        const file = await (0, artifacts_1.generateArtifact)({
+            artifactType: type,
+            cwd,
+            normalizedBriefOverride: normalizedPath,
+            agent: agentResolved,
+            revisionType: "fix"
+        });
+        log(`${type.toUpperCase()} regenerated (fix): ${file}`);
+        await (0, hook_executor_1.runHookPhase)(cwd, `after_${type}`, log);
+    }
+    await (0, hook_executor_1.runHookPhase)(cwd, "before_validate", log);
+    const finalResult = await (0, validate_1.runValidate)(cwd, {
+        strict: Boolean(strict),
+        report
+    });
+    await (0, hook_executor_1.runHookPhase)(cwd, "after_validate", log);
+    return {
+        proposal,
+        applied: true,
+        finalPass: finalResult.pass,
+        reportPath: finalResult.reportPath,
+        backupDir
+    };
+}
+async function runFix(options) {
+    const { cwd, dryRun, log = console.log } = options;
+    const proposal = await buildFixProposal(options);
+    if (proposal.targets.length === 0) {
+        log("No blocking issues found. Nothing to fix.");
+        return {
+            proposal,
+            applied: false,
+            finalPass: true,
+            reportPath: proposal.initialReport.reportPath
+        };
+    }
+    if (dryRun) {
+        log(`[Dry Run] Would regenerate: ${proposal.targets.join(", ")}`);
+        log(`[Dry Run] ${proposal.issues.length} issue(s) identified.`);
+        for (const [type, issues] of proposal.issuesByArtifact) {
+            log(`  ${type}: ${issues.length} issue(s)`);
+            for (const issue of issues) {
+                log(`    - [${issue.level}] ${issue.code}: ${issue.message}`);
+            }
+        }
+        return {
+            proposal,
+            applied: false,
+            finalPass: false,
+            reportPath: proposal.initialReport.reportPath
+        };
+    }
+    return applyFix(cwd, proposal, options);
+}

package/dist/core/hook-executor.d.ts

@@ -0,0 +1 @@
+export declare function runHookPhase(cwd: string, phaseKey: string, log: (message: string) => void): Promise<void>;

package/dist/core/hook-executor.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHookPhase = runHookPhase;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const errors_1 = require("./errors");
+const utils_1 = require("./utils");
+function hooksPath(cwd) {
+    return node_path_1.default.join(cwd, ".prodo", "hooks.yml");
+}
+async function runShellCommand(command, cwd, timeoutMs) {
+    const parsed = parseCommand(command);
+    if (!parsed) {
+        return { code: 1, stdout: "", stderr: "Invalid hook command syntax.", timedOut: false };
+    }
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)(parsed.bin, parsed.args, { cwd, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill();
+        }, Math.max(1000, timeoutMs));
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ code: code ?? 1, stdout, stderr, timedOut });
+        });
+    });
+}
+function parseCommand(command) {
+    const src = command.trim();
+    if (!src)
+        return null;
+    const out = [];
+    let current = "";
+    let quote = null;
+    let escaping = false;
+    for (let i = 0; i < src.length; i += 1) {
+        const ch = src[i];
+        if (escaping) {
+            current += ch;
+            escaping = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escaping = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            quote = ch;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (current.length > 0) {
+                out.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (escaping || quote)
+        return null;
+    if (current.length > 0)
+        out.push(current);
+    if (out.length === 0)
+        return null;
+    return { bin: out[0], args: out.slice(1) };
+}
+function toPositiveInt(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    const normalized = Math.floor(value);
+    return normalized > 0 ? normalized : fallback;
+}
+function toNonNegativeInt(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    const normalized = Math.floor(value);
+    return normalized >= 0 ? normalized : fallback;
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function evaluateCondition(condition, cwd) {
+    const trimmed = condition.trim();
+    if (!trimmed)
+        return true;
+    const result = await runShellCommand(trimmed, cwd, 10_000);
+    return !result.timedOut && result.code === 0;
+}
+async function readHooks(cwd) {
+    const file = hooksPath(cwd);
+    if (!(await (0, utils_1.fileExists)(file)))
+        return null;
+    try {
+        const raw = await promises_1.default.readFile(file, "utf8");
+        const parsed = js_yaml_1.default.load(raw);
+        return parsed ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function runHookPhase(cwd, phaseKey, log) {
+    const config = await readHooks(cwd);
+    const phaseHooks = config?.hooks?.[phaseKey];
+    if (!Array.isArray(phaseHooks) || phaseHooks.length === 0)
+        return;
+    for (const hook of phaseHooks) {
+        if (hook?.enabled === false)
+            continue;
+        const command = typeof hook?.command === "string" ? hook.command.trim() : "";
+        if (!command)
+            continue;
+        if (typeof hook.condition === "string" && hook.condition.trim()) {
+            const pass = await evaluateCondition(hook.condition, cwd);
+            if (!pass) {
+                log(`[Hook:skipped:${phaseKey}] condition=false for ${command}`);
+                continue;
+            }
+        }
+        const label = hook.extension || hook.description || command;
+        if (hook.optional) {
+            log(`[Hook:optional:${phaseKey}] ${label}`);
+            if (hook.prompt)
+                log(`  Prompt: ${hook.prompt}`);
+            log(`  To run manually: ${command}`);
+            continue;
+        }
+        const timeoutMs = toPositiveInt(hook.timeout_ms, 30_000);
+        const retries = toNonNegativeInt(hook.retry, 0);
+        const retryDelayMs = toNonNegativeInt(hook.retry_delay_ms, 500);
+        const attempts = 1 + retries;
+        let lastDetail = "";
+        for (let attempt = 1; attempt <= attempts; attempt += 1) {
+            log(`[Hook:mandatory:${phaseKey}] Running (attempt ${attempt}/${attempts}): ${command}`);
+            const result = await runShellCommand(command, cwd, timeoutMs);
+            if (!result.timedOut && result.code === 0) {
+                lastDetail = "";
+                break;
+            }
+            const stderr = result.stderr.trim();
+            const stdout = result.stdout.trim();
+            lastDetail = result.timedOut ? `Timed out after ${timeoutMs}ms` : stderr || stdout || "unknown error";
+            if (attempt < attempts) {
+                await sleep(retryDelayMs);
+            }
+        }
+        if (lastDetail) {
+            throw new errors_1.UserError(`Mandatory hook failed (${phaseKey}): ${command}\n${lastDetail}`);
+        }
+    }
+}

package/dist/core/markdown.d.ts

@@ -0,0 +1,16 @@
+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 type TaggedLine = {
+    contractId: string;
+    line: string;
+};
+export declare function taggedLinesByContract(body: string): TaggedLine[];
+export declare function sectionTextMap(content: string): Map<string, string>;

package/dist/core/markdown.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHeadingKey = normalizeHeadingKey;
+exports.parseMarkdownSections = parseMarkdownSections;
+exports.extractRequiredHeadings = extractRequiredHeadings;
+exports.taggedLinesByContract = taggedLinesByContract;
+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 taggedLinesByContract(body) {
+    const lines = body
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const tagged = [];
+    for (const line of lines) {
+        const matches = line.match(/\[([GFC][0-9]+)\]/g) ?? [];
+        for (const match of matches) {
+            tagged.push({ contractId: match.slice(1, -1), line });
+        }
+    }
+    return tagged;
+}
+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/core/normalize.d.ts

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

package/dist/core/normalize.js

@@ -0,0 +1,125 @@
+"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 normalizedKey(value) {
+    return value
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/ı/g, "i")
+        .replace(/İ/g, "I")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
+function extractBriefProductName(rawBrief) {
+    const lines = rawBrief.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const headingMatch = lines[index].match(/^\s*#{1,6}\s+(.+?)\s*$/);
+        if (!headingMatch)
+            continue;
+        const headingKey = normalizedKey(headingMatch[1]);
+        const isProductHeading = headingKey === "product name" ||
+            headingKey === "project name" ||
+            headingKey === "urun adi" ||
+            headingKey === "urun ismi";
+        if (!isProductHeading)
+            continue;
+        for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+            const rawLine = lines[cursor].trim();
+            if (!rawLine)
+                continue;
+            if (/^\s*#{1,6}\s+/.test(rawLine))
+                break;
+            const cleaned = rawLine.replace(/^\s*[-*]\s*/, "").trim();
+            if (cleaned.length > 0)
+                return cleaned;
+        }
+    }
+    return undefined;
+}
+function preserveOriginalProductName(parsed, rawBrief) {
+    const briefProductName = extractBriefProductName(rawBrief);
+    if (!briefProductName)
+        return parsed;
+    const generated = typeof parsed.product_name === "string" ? parsed.product_name : "";
+    if (!generated.trim())
+        return { ...parsed, product_name: briefProductName };
+    if (normalizedKey(generated) !== normalizedKey(briefProductName))
+        return parsed;
+    return { ...parsed, product_name: briefProductName };
+}
+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 inputContext = {
+        briefMarkdown: rawBrief,
+        sourceBriefPath: inPath,
+        outputLanguage: settings.lang
+    };
+    if (options.additionalContext && Object.keys(options.additionalContext).length > 0) {
+        inputContext.userClarifications = options.additionalContext;
+    }
+    const generated = await provider.generate(normalizePrompt, inputContext, {
+        artifactType: "normalize",
+        requiredHeadings: [],
+        requiredContracts: []
+    });
+    const parsed = extractJsonObject(generated.body);
+    const preserved = preserveOriginalProductName(parsed, rawBrief);
+    const withContracts = {
+        ...preserved,
+        contracts: preserved.contracts ??
+            (0, normalized_brief_1.buildContractsFromArrays)({
+                goals: Array.isArray(preserved.goals) ? preserved.goals.filter((x) => typeof x === "string") : [],
+                core_features: Array.isArray(preserved.core_features)
+                    ? preserved.core_features.filter((x) => typeof x === "string")
+                    : [],
+                constraints: Array.isArray(preserved.constraints)
+                    ? preserved.constraints.filter((x) => typeof x === "string")
+                    : []
+            })
+    };
+    const normalized = (0, normalized_brief_1.parseNormalizedBriefOrThrow)(withContracts);
+    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");
+    (0, normalized_brief_1.requireConfidenceOrThrow)(normalized, ["product_name", "problem", "audience", "goals", "core_features"], 0.7);
+    return outPath;
+}

package/dist/core/normalized-brief.d.ts

@@ -0,0 +1,48 @@
+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 type ConfidenceCheckResult = {
+    pass: boolean;
+    lowFields: Array<{
+        field: string;
+        confidence: number;
+        threshold: number;
+    }>;
+};
+export declare function checkConfidence(brief: NormalizedBrief, fields: Array<keyof Pick<NormalizedBrief, "product_name" | "problem" | "audience" | "goals" | "core_features">>, threshold?: number): ConfidenceCheckResult;
+export declare function contractIds(contracts: BriefContracts): {
+    goals: string[];
+    core_features: string[];
+    constraints: string[];
+};
+export {};