@shahmarasy/prodo 0.1.4 → 0.1.5

package/dist/agents/google/index.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAgent = void 0;
+const base_1 = require("../base");
+const system_prompts_1 = require("../system-prompts");
+const errors_1 = require("../../core/errors");
+const dynamicImport = new Function("specifier", "return import(specifier)");
+class GoogleAgent extends base_1.BaseAgent {
+    name = "google";
+    displayName = "Google Gemini";
+    sdkRequired = "@google/generative-ai";
+    getConfig() {
+        return {
+            name: this.name,
+            displayName: this.displayName,
+            sdkRequired: this.sdkRequired,
+            envVars: ["GOOGLE_API_KEY"],
+            defaultModel: "gemini-2.0-flash"
+        };
+    }
+    async generate(prompt, inputContext, schemaHint) {
+        const apiKey = process.env.GOOGLE_API_KEY;
+        if (!apiKey) {
+            throw new errors_1.UserError("GOOGLE_API_KEY is not set. Set it to use the Google Gemini agent.");
+        }
+        const model = process.env.PRODO_GOOGLE_MODEL ?? "gemini-2.0-flash";
+        const outputLanguage = typeof inputContext.outputLanguage === "string" && inputContext.outputLanguage.trim()
+            ? inputContext.outputLanguage.trim()
+            : "en";
+        const system = (0, system_prompts_1.buildSystemPrompt)(schemaHint, outputLanguage);
+        const user = (0, system_prompts_1.buildUserMessage)(prompt, inputContext);
+        let GoogleGenerativeAI;
+        try {
+            const mod = (await dynamicImport("@google/generative-ai"));
+            GoogleGenerativeAI = mod.GoogleGenerativeAI;
+        }
+        catch {
+            throw new errors_1.UserError("Google Generative AI SDK is not installed. Run: npm install @google/generative-ai");
+        }
+        const client = new GoogleGenerativeAI(apiKey);
+        const generativeModel = client.getGenerativeModel({
+            model,
+            systemInstruction: system
+        });
+        const result = await generativeModel.generateContent(user);
+        const content = result.response.text().trim();
+        if (!content) {
+            throw new errors_1.UserError("Google Gemini agent returned an empty response.");
+        }
+        return { body: content };
+    }
+}
+exports.GoogleAgent = GoogleAgent;

package/dist/agents/mock/index.d.ts

@@ -0,0 +1,11 @@
+import { BaseAgent, type AgentConfig } from "../base";
+import type { GenerateResult, ProviderSchemaHint } from "../../core/types";
+export declare class MockAgent extends BaseAgent {
+    readonly name = "mock";
+    readonly displayName = "Mock (Testing)";
+    readonly sdkRequired: null;
+    private readonly provider;
+    generate(prompt: string, inputContext: Record<string, unknown>, schemaHint: ProviderSchemaHint): Promise<GenerateResult>;
+    isAvailable(): Promise<boolean>;
+    getConfig(): AgentConfig;
+}

package/dist/agents/mock/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockAgent = void 0;
+const base_1 = require("../base");
+const mock_provider_1 = require("../../providers/mock-provider");
+class MockAgent extends base_1.BaseAgent {
+    name = "mock";
+    displayName = "Mock (Testing)";
+    sdkRequired = null;
+    provider = new mock_provider_1.MockProvider();
+    async generate(prompt, inputContext, schemaHint) {
+        return this.provider.generate(prompt, inputContext, schemaHint);
+    }
+    async isAvailable() {
+        return true;
+    }
+    getConfig() {
+        return {
+            name: this.name,
+            displayName: this.displayName,
+            sdkRequired: null,
+            envVars: []
+        };
+    }
+}
+exports.MockAgent = MockAgent;

package/dist/agents/openai/index.d.ts

@@ -0,0 +1,9 @@
+import { BaseAgent, type AgentConfig } from "../base";
+import type { GenerateResult, ProviderSchemaHint } from "../../core/types";
+export declare class OpenAIAgent extends BaseAgent {
+    readonly name = "openai";
+    readonly displayName = "OpenAI";
+    readonly sdkRequired = "openai";
+    getConfig(): AgentConfig;
+    generate(prompt: string, inputContext: Record<string, unknown>, schemaHint: ProviderSchemaHint): Promise<GenerateResult>;
+}

package/dist/agents/openai/index.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIAgent = void 0;
+const base_1 = require("../base");
+const system_prompts_1 = require("../system-prompts");
+const errors_1 = require("../../core/errors");
+const dynamicImport = new Function("specifier", "return import(specifier)");
+class OpenAIAgent extends base_1.BaseAgent {
+    name = "openai";
+    displayName = "OpenAI";
+    sdkRequired = "openai";
+    getConfig() {
+        return {
+            name: this.name,
+            displayName: this.displayName,
+            sdkRequired: this.sdkRequired,
+            envVars: ["OPENAI_API_KEY"],
+            defaultModel: "gpt-4o-mini"
+        };
+    }
+    async generate(prompt, inputContext, schemaHint) {
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new errors_1.UserError("OPENAI_API_KEY is not set. Set it to use the OpenAI agent.");
+        }
+        const model = process.env.PRODO_OPENAI_MODEL ?? "gpt-4o-mini";
+        const baseURL = process.env.PRODO_OPENAI_BASE_URL ?? undefined;
+        const outputLanguage = typeof inputContext.outputLanguage === "string" && inputContext.outputLanguage.trim()
+            ? inputContext.outputLanguage.trim()
+            : "en";
+        const system = (0, system_prompts_1.buildSystemPrompt)(schemaHint, outputLanguage);
+        const user = (0, system_prompts_1.buildUserMessage)(prompt, inputContext);
+        let OpenAIConstructor;
+        try {
+            const mod = (await dynamicImport("openai"));
+            OpenAIConstructor = mod.default;
+        }
+        catch {
+            throw new errors_1.UserError("OpenAI SDK is not installed. Run: npm install openai");
+        }
+        const client = new OpenAIConstructor({ apiKey, baseURL });
+        const response = await client.chat.completions.create({
+            model,
+            messages: [
+                { role: "system", content: system },
+                { role: "user", content: user }
+            ],
+            temperature: 0.2
+        });
+        const content = response.choices[0]?.message?.content?.trim();
+        if (!content) {
+            throw new errors_1.UserError("OpenAI agent returned an empty response.");
+        }
+        return { body: content };
+    }
+}
+exports.OpenAIAgent = OpenAIAgent;

package/dist/agents/system-prompts.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderSchemaHint } from "../core/types";
+export declare function buildSystemPrompt(schemaHint: ProviderSchemaHint, outputLanguage: string): string;
+export declare function buildUserMessage(prompt: string, inputContext: Record<string, unknown>): string;

package/dist/agents/system-prompts.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSystemPrompt = buildSystemPrompt;
+exports.buildUserMessage = buildUserMessage;
+function buildSystemPrompt(schemaHint, outputLanguage) {
+    const mode = schemaHint.artifactType;
+    if (mode === "normalize") {
+        return `You normalize messy human product briefs into strict JSON.
+Return valid JSON only, no markdown. Include confidence scores (0..1) for critical fields.
+Preserve source language and Unicode characters exactly; never transliterate Turkish letters to ASCII.`;
+    }
+    if (mode === "semantic_consistency") {
+        return `You detect semantic inconsistencies between paired artifacts.
+Return valid JSON only: { "issues": [{level, code, check, contract_id, file, message, suggestion}] }.`;
+    }
+    if (mode === "contract_relevance") {
+        return `You verify whether tagged content actually matches the referenced contract text.
+Return valid JSON only: { "relevant": boolean, "score": number, "reason": string }.`;
+    }
+    return `You are a product-document generator.
+Return only Markdown body content.
+Headings required:
+${schemaHint.requiredHeadings.join("\n")}
+Required contract tags:
+${schemaHint.requiredContracts.join(", ")}
+Use tags like [G1], [F2], [C1] where relevant.
+Output language: ${outputLanguage}
+Do not translate required headings.`;
+}
+function buildUserMessage(prompt, inputContext) {
+    return `${prompt}\n\nContext JSON:\n${JSON.stringify(inputContext, null, 2)}`;
+}

package/dist/cli/agent-command-installer.d.ts

@@ -0,0 +1,4 @@
+export declare const AI_ALIASES: Record<string, "codex" | "gemini-cli" | "claude-cli">;
+export type SupportedAi = "codex" | "gemini-cli" | "claude-cli";
+export declare function resolveAi(ai?: string): SupportedAi | undefined;
+export declare function installAgentCommands(projectRoot: string, ai: SupportedAi): Promise<string[]>;

package/dist/cli/agent-command-installer.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_ALIASES = void 0;
+exports.resolveAi = resolveAi;
+exports.installAgentCommands = installAgentCommands;
+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("../core/errors");
+const utils_1 = require("../core/utils");
+exports.AI_ALIASES = {
+    codex: "codex",
+    gemini: "gemini-cli",
+    "gemmini-cli": "gemini-cli",
+    "gemmini": "gemini-cli",
+    "gemini-cli": "gemini-cli",
+    claude: "claude-cli",
+    "claude-cli": "claude-cli"
+};
+const AGENT_CONFIG = {
+    "claude-cli": {
+        baseDir: ".claude/commands",
+        format: "markdown",
+        extension: ".md",
+        argsPlaceholder: "$ARGUMENTS"
+    },
+    "gemini-cli": {
+        baseDir: ".gemini/commands",
+        format: "toml",
+        extension: ".toml",
+        argsPlaceholder: "{{args}}"
+    },
+    codex: {
+        baseDir: ".agents/skills",
+        format: "skill",
+        extension: "/SKILL.md",
+        argsPlaceholder: "$ARGUMENTS"
+    }
+};
+function parseFrontmatter(content) {
+    if (!content.startsWith("---"))
+        return { frontmatter: {}, body: content };
+    const end = content.indexOf("\n---", 4);
+    if (end === -1)
+        return { frontmatter: {}, body: content };
+    const fmRaw = content.slice(3, end).trim();
+    const body = content.slice(end + 4).trimStart();
+    const frontmatter = js_yaml_1.default.load(fmRaw) ?? {};
+    return { frontmatter, body };
+}
+function renderFrontmatter(frontmatter) {
+    if (Object.keys(frontmatter).length === 0)
+        return "";
+    return `---\n${js_yaml_1.default.dump(frontmatter)}---\n`;
+}
+function sanitizeFrontmatter(frontmatter) {
+    const out = { ...frontmatter };
+    delete out.run;
+    delete out.scripts;
+    return out;
+}
+function toTomlPrompt(body, frontmatter, argsPlaceholder) {
+    const description = String(frontmatter.description ?? "Prodo command");
+    const promptBody = body.replaceAll("$ARGUMENTS", argsPlaceholder);
+    return `description = "${description.replace(/"/g, '\\"')}"
+
+prompt = """
+Important execution rule:
+- This is an agent slash command, not a shell command.
+- Do NOT run \`prodo-normalize\`, \`prodo-prd\`, or \`prodo ...\` in shell.
+- Execute the workflow directly using workspace files.
+
+${promptBody}
+"""`;
+}
+function toSkill(name, body, frontmatter) {
+    const description = String(frontmatter.description ?? "Prodo workflow command");
+    return `---
+name: ${name}
+description: ${description}
+compatibility: Requires Prodo project scaffold (.prodo)
+metadata:
+  author: prodo
+  source: .prodo/commands/${name}.md
+---
+
+${body}`;
+}
+function resolveAi(ai) {
+    if (!ai)
+        return undefined;
+    const normalized = exports.AI_ALIASES[ai.trim().toLowerCase()];
+    if (!normalized) {
+        throw new errors_1.UserError("Unsupported --ai value. Use: codex | gemini-cli | claude-cli");
+    }
+    return normalized;
+}
+async function loadCommandTemplateNames(commandTemplatesDir) {
+    if (!(await (0, utils_1.fileExists)(commandTemplatesDir))) {
+        throw new errors_1.UserError(`Missing command templates directory: ${commandTemplatesDir}`);
+    }
+    const entries = await promises_1.default.readdir(commandTemplatesDir, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .filter((name) => name.endsWith(".md") && name.startsWith("prodo-"))
+        .map((name) => name.replace(/\.md$/, ""))
+        .sort();
+}
+async function installAgentCommands(projectRoot, ai) {
+    const cfg = AGENT_CONFIG[ai];
+    const target = node_path_1.default.join(projectRoot, cfg.baseDir);
+    const commandTemplatesDir = node_path_1.default.join(projectRoot, ".prodo", "commands");
+    const commandNames = await loadCommandTemplateNames(commandTemplatesDir);
+    await (0, utils_1.ensureDir)(target);
+    const written = [];
+    for (const commandName of commandNames) {
+        const templatePath = node_path_1.default.join(commandTemplatesDir, `${commandName}.md`);
+        if (!(await (0, utils_1.fileExists)(templatePath))) {
+            throw new errors_1.UserError(`Missing command template: ${templatePath}`);
+        }
+        const raw = await promises_1.default.readFile(templatePath, "utf8");
+        const parsed = parseFrontmatter(raw);
+        if (cfg.format === "skill") {
+            const skillDir = node_path_1.default.join(target, commandName);
+            await (0, utils_1.ensureDir)(skillDir);
+            const outPath = node_path_1.default.join(skillDir, "SKILL.md");
+            const content = toSkill(commandName, parsed.body.replaceAll("$ARGUMENTS", cfg.argsPlaceholder), parsed.frontmatter);
+            await promises_1.default.writeFile(outPath, content, "utf8");
+            written.push(outPath);
+            continue;
+        }
+        if (cfg.format === "toml") {
+            const outPath = node_path_1.default.join(target, `${commandName}${cfg.extension}`);
+            await promises_1.default.writeFile(outPath, toTomlPrompt(parsed.body, parsed.frontmatter, cfg.argsPlaceholder), "utf8");
+            written.push(outPath);
+            continue;
+        }
+        const outPath = node_path_1.default.join(target, `${commandName}${cfg.extension}`);
+        const replacedBody = parsed.body.replaceAll("$ARGUMENTS", cfg.argsPlaceholder);
+        await promises_1.default.writeFile(outPath, `${renderFrontmatter(sanitizeFrontmatter(parsed.frontmatter))}\n${replacedBody}`, "utf8");
+        written.push(outPath);
+    }
+    return written;
+}

package/dist/cli/agent-ids.d.ts

@@ -0,0 +1,15 @@
+export declare const AGENT_IDS: readonly ["codex", "gemini-cli", "claude-cli"];
+export type AgentId = (typeof AGENT_IDS)[number];
+export declare function isSupportedAgent(agent?: string): agent is AgentId;
+export declare function resolveAgent(agent?: string): AgentId | undefined;
+export type CommandSetItem = {
+    command: string;
+    purpose: string;
+};
+export type AgentCommandSet = {
+    agent: string;
+    description?: string;
+    recommended_sequence?: CommandSetItem[];
+    artifact_shortcuts?: Record<string, string>;
+};
+export declare function loadAgentCommandSet(_cwd: string, agent: AgentId): Promise<AgentCommandSet>;

package/dist/cli/agent-ids.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_IDS = void 0;
+exports.isSupportedAgent = isSupportedAgent;
+exports.resolveAgent = resolveAgent;
+exports.loadAgentCommandSet = loadAgentCommandSet;
+const errors_1 = require("../core/errors");
+exports.AGENT_IDS = ["codex", "gemini-cli", "claude-cli"];
+function isSupportedAgent(agent) {
+    if (!agent)
+        return false;
+    return exports.AGENT_IDS.includes(agent);
+}
+function resolveAgent(agent) {
+    if (!agent)
+        return undefined;
+    if (!isSupportedAgent(agent)) {
+        throw new errors_1.UserError(`Unsupported agent: ${agent}. Supported: ${exports.AGENT_IDS.join(", ")}`);
+    }
+    return agent;
+}
+async function loadAgentCommandSet(_cwd, agent) {
+    const prefix = "/prodo";
+    return {
+        agent,
+        description: "Agent-specific command set for Prodo artifact pipeline.",
+        recommended_sequence: [
+            { command: "prodo init . --ai <agent> --lang <en|tr>", purpose: "Initialize Prodo scaffold and agent commands." },
+            { command: `${prefix}-normalize`, purpose: "Normalize start brief into normalized brief JSON." },
+            { command: `${prefix}-prd`, purpose: "Generate PRD artifact." },
+            { command: `${prefix}-workflow`, purpose: "Generate workflow artifact." },
+            { command: `${prefix}-wireframe`, purpose: "Generate wireframe artifact." },
+            { command: `${prefix}-stories`, purpose: "Generate stories artifact." },
+            { command: `${prefix}-techspec`, purpose: "Generate techspec artifact." },
+            { command: `${prefix}-validate`, purpose: "Run validation report." },
+            { command: `${prefix}-fix`, purpose: "Fix artifacts when validation fails." }
+        ],
+        artifact_shortcuts: {
+            normalize: `${prefix}-normalize`,
+            prd: `${prefix}-prd`,
+            workflow: `${prefix}-workflow`,
+            wireframe: `${prefix}-wireframe`,
+            stories: `${prefix}-stories`,
+            techspec: `${prefix}-techspec`,
+            validate: `${prefix}-validate`,
+            fix: `${prefix}-fix`
+        }
+    };
+}

package/dist/cli/doctor.d.ts

@@ -0,0 +1 @@
+export declare function runDoctor(cwd: string, out: (line: string) => void): Promise<void>;

package/dist/cli/doctor.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const node_child_process_1 = require("node:child_process");
+const agent_registry_1 = require("../agents/agent-registry");
+const paths_1 = require("../core/paths");
+const utils_1 = require("../core/utils");
+const version_1 = require("../core/version");
+function termWidth() {
+    return Math.max(80, process.stdout.columns ?? 100);
+}
+function stripAnsi(input) {
+    return input.replace(/\u001B\[[0-9;]*m/g, "");
+}
+function color(input, code) {
+    if (!process.stdout.isTTY)
+        return input;
+    return `${code}${input}\u001B[0m`;
+}
+function center(input, width) {
+    const visible = stripAnsi(input).length;
+    const left = Math.max(0, Math.floor((width - visible) / 2));
+    return `${" ".repeat(left)}${input}`;
+}
+function iconFor(status) {
+    if (status === "available")
+        return color("✔", "\u001B[32m");
+    if (status === "not_found")
+        return color("✖", "\u001B[31m");
+    return color("•", "\u001B[33m");
+}
+function labelFor(status) {
+    if (status === "available")
+        return color("available", "\u001B[32m");
+    if (status === "not_found")
+        return color("not found", "\u001B[31m");
+    return color("IDE-based", "\u001B[2;33m");
+}
+function renderRows(rows) {
+    const leftWidth = Math.max(...rows.map((row) => row.name.length), 10);
+    return rows.map((row) => {
+        const left = row.name.padEnd(leftWidth, " ");
+        const status = `${labelFor(row.status)}${row.detail ? ` (${row.detail})` : ""}`;
+        return ` ${iconFor(row.status)}  ${left}  ${status}`;
+    });
+}
+async function commandExists(command) {
+    return new Promise((resolve) => {
+        const lookup = process.platform === "win32" ? "where" : "which";
+        const child = (0, node_child_process_1.spawn)(lookup, [command], { stdio: "ignore" });
+        child.on("error", () => resolve(false));
+        child.on("close", (code) => resolve(code === 0));
+    });
+}
+async function firstAvailable(commands) {
+    for (const command of commands) {
+        if (await commandExists(command))
+            return true;
+    }
+    return false;
+}
+function renderLogo(width) {
+    const cyan = "\u001B[38;5;45m";
+    const blue = "\u001B[38;5;39m";
+    const logo = [
+        "██████╗ ██████╗  ██████╗ ██████╗  ██████╗ ",
+        "██╔══██╗██╔══██╗██╔═══██╗██╔══██╗██╔═══██╗",
+        "██████╔╝██████╔╝██║   ██║██║  ██║██║   ██║",
+        "██╔═══╝ ██╔══██╗██║   ██║██║  ██║██║   ██║",
+        "██║     ██║  ██║╚██████╔╝██████╔╝╚██████╔╝"
+    ];
+    const painted = logo.map((line, idx) => color(line, idx % 2 === 0 ? cyan : blue));
+    return painted.map((line) => center(line, width)).join("\n");
+}
+async function runDoctor(cwd, out) {
+    const width = termWidth();
+    const version = await (0, version_1.readCliVersion)(cwd);
+    const isInitialized = await (0, utils_1.fileExists)((0, paths_1.prodoPath)(cwd));
+    const codex = await firstAvailable(["codex"]);
+    const gemini = await firstAvailable(["gemini", "gemini-cli"]);
+    const claude = await firstAvailable(["claude", "claude-cli"]);
+    const git = await firstAvailable(["git"]);
+    const node = await firstAvailable(["node"]);
+    const vscode = await firstAvailable(["code"]);
+    const coreRows = [
+        { name: "Prodo CLI", status: "available", detail: `v${version}` },
+        {
+            name: "Project initialized",
+            status: isInitialized ? "available" : "not_found",
+            detail: isInitialized ? ".prodo found" : ".prodo missing"
+        }
+    ];
+    const aiCliRows = [
+        { name: "Codex CLI", status: codex ? "available" : "not_found", detail: codex ? "available" : "not found" },
+        { name: "Gemini CLI", status: gemini ? "available" : "not_found", detail: gemini ? "available" : "not found" },
+        { name: "Claude CLI", status: claude ? "available" : "not_found", detail: claude ? "available" : "not found" }
+    ];
+    const registry = (0, agent_registry_1.getGlobalRegistry)();
+    const agentRows = [];
+    for (const agent of registry.list()) {
+        if (agent.name === "mock")
+            continue;
+        const available = await agent.isAvailable();
+        const config = agent.getConfig();
+        const sdkLabel = config.sdkRequired ? `SDK: ${config.sdkRequired}` : "";
+        const envLabel = config.envVars.filter((v) => !process.env[v]).map((v) => `${v} missing`).join(", ");
+        const detail = available ? "ready" : [sdkLabel, envLabel].filter(Boolean).join(", ") || "not configured";
+        agentRows.push({
+            name: config.displayName,
+            status: available ? "available" : "not_found",
+            detail
+        });
+    }
+    const devRows = [
+        { name: "Git", status: git ? "available" : "not_found", detail: git ? "available" : "not found" },
+        { name: "Node.js", status: node ? "available" : "not_found", detail: node ? "available" : "not found" },
+        { name: "Visual Studio Code", status: vscode ? "available" : "not_found", detail: vscode ? "available" : "not found" },
+        { name: "Cursor", status: "ide", detail: "IDE-based, no CLI check" }
+    ];
+    out("");
+    out(renderLogo(width));
+    out("");
+    out(center(color("Prodo — Product Artifact Toolkit", "\u001B[1;37m"), width));
+    out(center(color("Crafted by Codex, guided by Shahmarasy intelligence", "\u001B[2;37m"), width));
+    out("");
+    out("Checking environment...");
+    out("");
+    out(color("Core", "\u001B[1m"));
+    for (const line of renderRows(coreRows))
+        out(line);
+    out("");
+    out(color("AI CLI Tools", "\u001B[1m"));
+    for (const line of renderRows(aiCliRows))
+        out(line);
+    out("");
+    out(color("LLM Agents (SDK)", "\u001B[1m"));
+    for (const line of renderRows(agentRows))
+        out(line);
+    out("");
+    out(color("Dev Tools", "\u001B[1m"));
+    for (const line of renderRows(devRows))
+        out(line);
+    out("");
+}

package/dist/cli/fix-tui.d.ts

@@ -0,0 +1,4 @@
+import type { FixProposal, FixResult } from "../core/fix";
+export declare function displayFixProposal(proposal: FixProposal, log: (message: string) => void): Promise<void>;
+export declare function confirmFixExecution(proposal: FixProposal): Promise<boolean>;
+export declare function displayFixResult(result: FixResult, log: (message: string) => void): Promise<void>;

package/dist/cli/fix-tui.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayFixProposal = displayFixProposal;
+exports.confirmFixExecution = confirmFixExecution;
+exports.displayFixResult = displayFixResult;
+const dynamicImport = new Function("specifier", "return import(specifier)");
+async function loadClack() {
+    try {
+        return (await dynamicImport("@clack/prompts"));
+    }
+    catch {
+        return null;
+    }
+}
+async function displayFixProposal(proposal, log) {
+    const errorCount = proposal.issues.filter((i) => i.level === "error").length;
+    const warningCount = proposal.issues.filter((i) => i.level === "warning").length;
+    log("");
+    log(`Fix Proposal`);
+    log(`${"─".repeat(50)}`);
+    log(`Issues found: ${errorCount} error(s), ${warningCount} warning(s)`);
+    log(`Artifacts to regenerate: ${proposal.targets.join(", ")}`);
+    log("");
+    for (const [type, issues] of proposal.issuesByArtifact) {
+        log(`  ${type.toUpperCase()} (${issues.length} issue${issues.length > 1 ? "s" : ""}):`);
+        for (const issue of issues) {
+            const prefix = issue.level === "error" ? "  ✖" : "  ⚠";
+            log(`    ${prefix} [${issue.code}] ${issue.message}`);
+            if (issue.suggestion) {
+                log(`      → ${issue.suggestion}`);
+            }
+        }
+        log("");
+    }
+    const orphanIssues = proposal.issues.filter((i) => !i.artifactType);
+    if (orphanIssues.length > 0) {
+        log(`  General (${orphanIssues.length} issue${orphanIssues.length > 1 ? "s" : ""}):`);
+        for (const issue of orphanIssues) {
+            const prefix = issue.level === "error" ? "  ✖" : "  ⚠";
+            log(`    ${prefix} [${issue.code}] ${issue.message}`);
+        }
+        log("");
+    }
+}
+async function confirmFixExecution(proposal) {
+    if (process.stdout.isTTY !== true) {
+        return true;
+    }
+    const clack = await loadClack();
+    if (!clack) {
+        return true;
+    }
+    clack.intro("Prodo Fix");
+    const proceed = await clack.confirm({
+        message: `Regenerate ${proposal.targets.length} artifact(s): ${proposal.targets.join(", ")}?`
+    });
+    if (clack.isCancel(proceed)) {
+        clack.cancel("Fix cancelled.");
+        return false;
+    }
+    return proceed === true;
+}
+async function displayFixResult(result, log) {
+    log("");
+    if (result.finalPass) {
+        log("Fix complete — validation passed.");
+    }
+    else {
+        log("Fix applied but validation still failing.");
+        log(`Review report: ${result.reportPath}`);
+        if (result.backupDir) {
+            log(`Backup saved: ${result.backupDir}`);
+        }
+    }
+    const clack = await loadClack();
+    if (clack && process.stdout.isTTY) {
+        clack.outro(result.finalPass ? "All gates passed!" : "Review report and retry.");
+    }
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,9 @@
+type RunOptions = {
+    forcedCommand?: string;
+    cwd?: string;
+    argv?: string[];
+    log?: (message: string) => void;
+    error?: (message: string) => void;
+};
+export declare function runCli(options?: RunOptions): Promise<number>;
+export {};