@shahmarasy/prodo 0.1.3 → 0.1.5

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 {};