@shahmarasy/prodo 0.1.4 → 0.1.5

package/dist/cli/index.js

@@ -0,0 +1,465 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const commander_1 = require("commander");
+const node_crypto_1 = require("node:crypto");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const agent_ids_1 = require("./agent-ids");
+const artifact_registry_1 = require("../core/artifact-registry");
+const artifacts_1 = require("../core/artifacts");
+const doctor_1 = require("./doctor");
+const errors_1 = require("../core/errors");
+const hook_executor_1 = require("../core/hook-executor");
+const init_1 = require("./init");
+const init_tui_1 = require("./init-tui");
+const clean_1 = require("../core/clean");
+const fix_1 = require("../core/fix");
+const normalize_1 = require("../core/normalize");
+const normalize_interactive_1 = require("./normalize-interactive");
+const fix_tui_1 = require("./fix-tui");
+const paths_1 = require("../core/paths");
+const utils_1 = require("../core/utils");
+const validate_1 = require("../core/validate");
+const version_1 = require("../core/version");
+const dynamicImport = new Function("specifier", "return import(specifier)");
+function mapForcedCommand(forcedCommand) {
+    if (forcedCommand === "prodo-init")
+        return "init";
+    if (forcedCommand === "prodo-validate")
+        return "validate";
+    if (forcedCommand === "prodo-normalize")
+        return "normalize";
+    if (forcedCommand === "prodo-fix")
+        return "fix";
+    if (forcedCommand === "prodo-prd")
+        return "prd";
+    if (forcedCommand === "prodo-workflow")
+        return "workflow";
+    if (forcedCommand === "prodo-wireframe")
+        return "wireframe";
+    if (forcedCommand === "prodo-stories")
+        return "stories";
+    if (forcedCommand === "prodo-techspec")
+        return "techspec";
+    return undefined;
+}
+async function runArtifactCommand(type, opts, cwd, log, options) {
+    await (0, hook_executor_1.runHookPhase)(cwd, `before_${type}`, log);
+    const agent = (0, agent_ids_1.resolveAgent)(opts.agent);
+    const file = await (0, artifacts_1.generateArtifact)({
+        artifactType: type,
+        cwd,
+        normalizedBriefOverride: opts.from,
+        outPath: opts.out,
+        agent,
+        revisionType: opts.revisionType
+    });
+    const agentMsg = agent ? ` [agent=${agent}]` : "";
+    log(`${type.toUpperCase()} generated${agentMsg}: ${file}`);
+    if (options?.suggestValidate !== false) {
+        log("Tip: run `prodo validate` to check cross-artifact consistency.");
+    }
+    await (0, hook_executor_1.runHookPhase)(cwd, `after_${type}`, log);
+}
+async function snapshotBrief(cwd) {
+    const file = (0, paths_1.briefPath)(cwd);
+    if (!(await (0, utils_1.fileExists)(file)))
+        return null;
+    const [raw, stat] = await Promise.all([promises_1.default.readFile(file), promises_1.default.stat(file)]);
+    return {
+        hash: (0, node_crypto_1.createHash)("sha256").update(raw).digest("hex"),
+        mtimeMs: stat.mtimeMs,
+        size: stat.size
+    };
+}
+async function withBriefReadOnlyGuard(cwd, task) {
+    const before = await snapshotBrief(cwd);
+    await task();
+    const after = await snapshotBrief(cwd);
+    if (!before)
+        return;
+    if (!after) {
+        throw new errors_1.UserError("Input file `brief.md` was removed during execution. Input files are read-only.");
+    }
+    if (before.hash !== after.hash || before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
+        throw new errors_1.UserError("Input file `brief.md` was modified during execution. Input files are read-only.");
+    }
+}
+async function runCli(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const argv = options.argv ?? process.argv;
+    const out = options.log ?? console.log;
+    const err = options.error ?? console.error;
+    const forced = options.forcedCommand ? mapForcedCommand(options.forcedCommand) : undefined;
+    const program = new commander_1.Command();
+    const version = await (0, version_1.readCliVersion)(cwd);
+    program
+        .name("prodo")
+        .description("CLI-first, prompt-powered product artifact kit")
+        .version(`prodo ${version}`, "-v, --version", "Show Prodo version")
+        .showHelpAfterError();
+    const artifactTypes = await (0, artifact_registry_1.listArtifactTypes)(cwd);
+    program
+        .command("init [target]")
+        .option("--ai <name>", "agent integration: codex | gemini-cli | claude-cli")
+        .option("--lang <code>", "document language (e.g. en, tr)")
+        .option("--author <name>", "document author name")
+        .option("--preset <name>", "preset to install during initialization")
+        .action(async (target, opts) => {
+        const projectRoot = node_path_1.default.resolve(cwd, target ?? ".");
+        const selected = await (0, init_tui_1.gatherInitSelections)({
+            projectRoot,
+            aiInput: opts.ai,
+            langInput: opts.lang,
+            authorInput: opts.author
+        });
+        const selectedAi = selected.ai;
+        if (selected.interactive) {
+            const clack = (await dynamicImport("@clack/prompts"));
+            const s = clack.spinner();
+            s.start("Scaffolding Prodo workspace...");
+            const result = await (0, init_1.runInit)(projectRoot, {
+                ai: selectedAi,
+                lang: selected.lang,
+                author: selected.author,
+                preset: opts.preset,
+                script: selected.script
+            });
+            s.stop("Scaffold complete.");
+            await (0, init_tui_1.finishInitInteractive)({
+                projectRoot,
+                settingsPath: result.settingsPath,
+                ai: selectedAi,
+                lang: selected.lang,
+                author: selected.author
+            });
+            return;
+        }
+        const result = await (0, init_1.runInit)(projectRoot, {
+            ai: selectedAi,
+            lang: selected.lang,
+            author: selected.author,
+            preset: opts.preset,
+            script: selected.script
+        });
+        out(`Initialized Prodo scaffold at ${node_path_1.default.join(projectRoot, ".prodo")}`);
+        if (selectedAi) {
+            out(`Agent command set installed for ${selectedAi}.`);
+            out(`Installed ${result.installedAgentFiles.length} command files.`);
+            out("Agent workflow: edit brief.md, then run slash commands in your agent.");
+        }
+        else {
+            out("No agent selected. Use `prodo generate` for end-to-end generation.");
+        }
+        out(`Settings file: ${result.settingsPath}`);
+        out(`Author: ${selected.author}`);
+        out("Next: edit brief.md.");
+    });
+    program
+        .command("generate")
+        .description("Run end-to-end pipeline: normalize -> generate artifacts -> validate")
+        .option("--agent <name>", "agent profile: codex | gemini-cli | claude-cli")
+        .option("--strict", "treat validation warnings as errors")
+        .option("--report <path>", "validation report output path")
+        .option("--dry-run", "show what would be generated without writing files")
+        .action(async (opts) => {
+        if (opts.agent)
+            (0, agent_ids_1.resolveAgent)(opts.agent);
+        if (opts.dryRun) {
+            out("[Dry Run] Pipeline would execute:");
+            out(`  1. Normalize brief.md`);
+            for (const type of artifactTypes) {
+                out(`  2. Generate ${type}`);
+            }
+            out(`  3. Validate all artifacts`);
+            out(`\nArtifact types: ${artifactTypes.join(", ")}`);
+            return;
+        }
+        await withBriefReadOnlyGuard(cwd, async () => {
+            await (0, hook_executor_1.runHookPhase)(cwd, "before_normalize", out);
+            const normalizedPath = await (0, normalize_1.runNormalize)({ cwd });
+            out(`Normalized brief written to: ${normalizedPath}`);
+            await (0, hook_executor_1.runHookPhase)(cwd, "after_normalize", out);
+            for (const type of artifactTypes) {
+                await runArtifactCommand(type, { from: normalizedPath, agent: opts.agent }, cwd, out, {
+                    suggestValidate: false
+                });
+            }
+            await (0, hook_executor_1.runHookPhase)(cwd, "before_validate", out);
+            const result = await (0, validate_1.runValidate)(cwd, {
+                strict: Boolean(opts.strict),
+                report: opts.report
+            });
+            out(`Validation report written to: ${result.reportPath}`);
+            if (!result.pass) {
+                throw new errors_1.UserError("Validation failed. Review report and fix issues.");
+            }
+            out("Generation pipeline completed. Validation passed.");
+            await (0, hook_executor_1.runHookPhase)(cwd, "after_validate", out);
+        });
+    });
+    program
+        .command("fix", { hidden: true })
+        .description("Advanced: auto-regenerate affected artifacts from validation findings")
+        .option("--agent <name>", "agent profile: codex | gemini-cli | claude-cli")
+        .option("--strict", "treat validation warnings as errors")
+        .option("--report <path>", "validation report output path")
+        .option("--dry-run", "show fix proposal without applying changes")
+        .action(async (opts) => {
+        if (opts.agent)
+            (0, agent_ids_1.resolveAgent)(opts.agent);
+        await withBriefReadOnlyGuard(cwd, async () => {
+            const fixOpts = {
+                cwd,
+                agent: opts.agent,
+                strict: Boolean(opts.strict),
+                report: opts.report,
+                dryRun: Boolean(opts.dryRun),
+                log: out
+            };
+            if (opts.dryRun) {
+                const result = await (0, fix_1.runFix)(fixOpts);
+                out(`Validation report: ${result.reportPath}`);
+                if (result.proposal.targets.length > 0) {
+                    await (0, fix_tui_1.displayFixProposal)(result.proposal, out);
+                }
+                return;
+            }
+            const proposal = await (0, fix_1.buildFixProposal)(fixOpts);
+            out(`Validation report: ${proposal.initialReport.reportPath}`);
+            if (proposal.targets.length === 0) {
+                out("No blocking issues found. Nothing to fix.");
+                return;
+            }
+            await (0, fix_tui_1.displayFixProposal)(proposal, out);
+            const confirmed = await (0, fix_tui_1.confirmFixExecution)(proposal);
+            if (!confirmed) {
+                out("Fix cancelled by user.");
+                return;
+            }
+            out(`Regenerating impacted artifacts: ${proposal.targets.join(", ")}`);
+            const result = await (0, fix_1.applyFix)(cwd, proposal, fixOpts);
+            await (0, fix_tui_1.displayFixResult)(result, out);
+            if (!result.finalPass) {
+                throw new errors_1.UserError("Fix completed but validation is still failing. Review report and retry.");
+            }
+        });
+    });
+    program
+        .command("normalize", { hidden: true })
+        .description("Advanced: normalize brief without full pipeline")
+        .option("--brief <path>", "path to start brief markdown")
+        .option("--out <path>", "output normalized brief json path")
+        .option("--agent <name>", "agent profile: codex | gemini-cli | claude-cli")
+        .option("-i, --interactive", "interactively clarify low-confidence fields")
+        .option("--dry-run", "show what would be normalized without writing")
+        .action(async (opts) => {
+        if (opts.agent)
+            (0, agent_ids_1.resolveAgent)(opts.agent);
+        if (opts.dryRun) {
+            const briefFile = opts.brief ?? "brief.md";
+            out(`[Dry Run] Would normalize: ${briefFile}`);
+            out(`[Dry Run] Output would be written to: .prodo/briefs/normalized-brief.json`);
+            return;
+        }
+        await withBriefReadOnlyGuard(cwd, async () => {
+            await (0, hook_executor_1.runHookPhase)(cwd, "before_normalize", out);
+            const outPath = opts.interactive
+                ? await (0, normalize_interactive_1.runInteractiveNormalize)({ cwd, brief: opts.brief, out: opts.out, log: out })
+                : await (0, normalize_1.runNormalize)({ cwd, brief: opts.brief, out: opts.out });
+            out(`Normalized brief written to: ${outPath}`);
+            await (0, hook_executor_1.runHookPhase)(cwd, "after_normalize", out);
+        });
+    });
+    program
+        .command("doctor")
+        .alias("check")
+        .description("Check local environment and toolchain readiness")
+        .action(async () => {
+        await (0, doctor_1.runDoctor)(cwd, out);
+    });
+    program
+        .command("clean")
+        .description("Remove all generated artifacts, keep brief.md and config")
+        .option("--dry-run", "show what would be removed without deleting")
+        .action(async (opts) => {
+        const result = await (0, clean_1.runClean)({
+            cwd,
+            dryRun: Boolean(opts.dryRun),
+            log: out
+        });
+        if (result.removedPaths.length === 0) {
+            out("Nothing to clean.");
+        }
+        else if (!opts.dryRun) {
+            out(`Cleaned ${result.removedPaths.length} path(s). Project is ready for a fresh run.`);
+        }
+    });
+    for (const type of artifactTypes) {
+        program
+            .command(type, { hidden: true })
+            .description(`Advanced: generate only ${type} artifact`)
+            .option("--from <path>", "path to normalized-brief.json")
+            .option("--out <path>", "output file path")
+            .option("--agent <name>", "agent profile: codex | gemini-cli | claude-cli")
+            .action(async (opts) => {
+            await withBriefReadOnlyGuard(cwd, async () => {
+                await runArtifactCommand(type, opts, cwd, out);
+            });
+        });
+    }
+    program
+        .command("agent-commands", { hidden: true })
+        .requiredOption("--agent <name>", "agent profile: codex | gemini-cli | claude-cli")
+        .action(async (opts) => {
+        const agent = (0, agent_ids_1.resolveAgent)(opts.agent);
+        if (!agent)
+            throw new errors_1.UserError("Agent is required.");
+        const set = await (0, agent_ids_1.loadAgentCommandSet)(cwd, agent);
+        out(`Agent: ${set.agent}`);
+        if (set.description)
+            out(`Description: ${set.description}`);
+        out("");
+        out("Recommended sequence:");
+        for (const item of set.recommended_sequence ?? []) {
+            out(`- ${item.command}: ${item.purpose}`);
+        }
+        if (set.artifact_shortcuts) {
+            out("");
+            out("Artifact shortcuts:");
+            for (const [key, command] of Object.entries(set.artifact_shortcuts)) {
+                out(`- ${key}: ${command}`);
+            }
+        }
+    });
+    program
+        .command("validate", { hidden: true })
+        .description("Advanced: run validation only")
+        .option("--strict", "treat warnings as errors")
+        .option("--report <path>", "report output path")
+        .option("--agent <name>", "agent profile: codex | gemini-cli | claude-cli")
+        .action(async (opts) => {
+        if (opts.agent)
+            (0, agent_ids_1.resolveAgent)(opts.agent);
+        await withBriefReadOnlyGuard(cwd, async () => {
+            await (0, hook_executor_1.runHookPhase)(cwd, "before_validate", out);
+            const result = await (0, validate_1.runValidate)(cwd, {
+                strict: Boolean(opts.strict),
+                report: opts.report
+            });
+            out(`Validation report written to: ${result.reportPath}`);
+            if (!result.pass) {
+                throw new errors_1.UserError("Validation failed. Review report and fix issues.");
+            }
+            out("Validation passed.");
+            await (0, hook_executor_1.runHookPhase)(cwd, "after_validate", out);
+        });
+    });
+    program
+        .command("skills", { hidden: true })
+        .description("Advanced: manage and run skills")
+        .argument("[action]", "list or run", "list")
+        .argument("[name]", "skill name (for run)")
+        .option("--input <json>", "JSON input for skill execution")
+        .action(async (action, name, opts) => {
+        const { getGlobalSkillEngine } = await Promise.resolve().then(() => __importStar(require("../skills/engine")));
+        const engine = getGlobalSkillEngine();
+        if (action === "list") {
+            const manifests = engine.listSkills();
+            if (manifests.length === 0) {
+                out("No skills registered.");
+                return;
+            }
+            out("Available skills:\n");
+            for (const m of manifests) {
+                out(`  ${m.name.padEnd(25)} [${m.category}] ${m.description}`);
+            }
+            return;
+        }
+        if (action === "run") {
+            if (!name)
+                throw new errors_1.UserError("Skill name is required. Usage: prodo skills run <name>");
+            const inputs = opts.input ? JSON.parse(opts.input) : {};
+            inputs.cwd = inputs.cwd ?? cwd;
+            const result = await engine.execute(name, { cwd, log: out }, inputs);
+            out(`\nSkill "${name}" completed.`);
+            out(JSON.stringify(result, null, 2));
+            return;
+        }
+        throw new errors_1.UserError(`Unknown skills action: "${action}". Use: list or run`);
+    });
+    try {
+        if (forced) {
+            if (forced === "init") {
+                await program.parseAsync(["node", "prodo", "init", ...argv.slice(2)]);
+            }
+            else if (forced === "normalize") {
+                await program.parseAsync(["node", "prodo", "normalize", ...argv.slice(2)]);
+            }
+            else if (forced === "validate") {
+                await program.parseAsync(["node", "prodo", "validate", ...argv.slice(2)]);
+            }
+            else if (forced === "fix") {
+                await program.parseAsync(["node", "prodo", "fix", ...argv.slice(2)]);
+            }
+            else {
+                await program.parseAsync(["node", "prodo", forced, ...argv.slice(2)]);
+            }
+        }
+        else {
+            await program.parseAsync(argv);
+        }
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof errors_1.UserError) {
+            err(error.message);
+            return 1;
+        }
+        const unknown = error;
+        err(unknown.message);
+        return 1;
+    }
+}
+if (require.main === module) {
+    runCli().then((code) => {
+        process.exitCode = code;
+    });
+}

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

@@ -0,0 +1,23 @@
+import { type SupportedAi } from "./agent-command-installer";
+export type InitSelections = {
+    ai?: SupportedAi;
+    script: "sh" | "ps";
+    lang: "tr" | "en";
+    author: string;
+    interactive: boolean;
+};
+type GatherInitUiOptions = {
+    projectRoot: string;
+    aiInput?: string;
+    langInput?: string;
+    authorInput?: string;
+};
+export declare function gatherInitSelections(options: GatherInitUiOptions): Promise<InitSelections>;
+export declare function finishInitInteractive(summary: {
+    projectRoot: string;
+    settingsPath: string;
+    ai?: SupportedAi;
+    lang: "tr" | "en";
+    author: string;
+}): Promise<void>;
+export {};

package/dist/cli/init-tui.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatherInitSelections = gatherInitSelections;
+exports.finishInitInteractive = finishInitInteractive;
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const agent_command_installer_1 = require("./agent-command-installer");
+const errors_1 = require("../core/errors");
+const utils_1 = require("../core/utils");
+const dynamicImport = new Function("specifier", "return import(specifier)");
+async function loadClack() {
+    return (await dynamicImport("@clack/prompts"));
+}
+function isInteractiveTerminal() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
+}
+function color(text, code) {
+    return `${code}${text}\u001B[0m`;
+}
+function stripAnsi(input) {
+    return input.replace(/\u001B\[[0-9;]*m/g, "");
+}
+function centerLine(line, width) {
+    const visible = stripAnsi(line).length;
+    const left = Math.max(0, Math.floor((width - visible) / 2));
+    return `${" ".repeat(left)}${line}`;
+}
+function centerBlock(lines, width) {
+    return lines.map((line) => centerLine(line, width)).join("\n");
+}
+function terminalWidth() {
+    const columns = process.stdout.columns ?? 100;
+    return Math.max(80, columns);
+}
+function renderLogo() {
+    const cyan = "\u001B[38;5;45m";
+    const blue = "\u001B[38;5;39m";
+    const lines = [
+        "██████╗ ██████╗  ██████╗ ██████╗  ██████╗ ",
+        "██╔══██╗██╔══██╗██╔═══██╗██╔══██╗██╔═══██╗",
+        "██████╔╝██████╔╝██║   ██║██║  ██║██║   ██║",
+        "██╔═══╝ ██╔══██╗██║   ██║██║  ██║██║   ██║",
+        "██║     ██║  ██║╚██████╔╝██████╔╝╚██████╔╝"
+    ];
+    return lines.map((line, idx) => color(line, idx % 2 === 0 ? cyan : blue)).join("\n");
+}
+function renderProjectBox(projectName, projectRoot) {
+    const content = [`Project   ${projectName}`, `Directory ${projectRoot}`];
+    const innerWidth = Math.max(...content.map((line) => line.length)) + 2;
+    const top = `┌${"─".repeat(innerWidth)}┐`;
+    const rows = content.map((line) => `│ ${line.padEnd(innerWidth - 1)}│`);
+    const bottom = `└${"─".repeat(innerWidth)}┘`;
+    return [top, ...rows, bottom].join("\n");
+}
+async function detectAi(projectRoot) {
+    if (await (0, utils_1.fileExists)(node_path_1.default.join(projectRoot, ".agents")))
+        return "codex";
+    if (await (0, utils_1.fileExists)(node_path_1.default.join(projectRoot, ".gemini")))
+        return "gemini-cli";
+    if (await (0, utils_1.fileExists)(node_path_1.default.join(projectRoot, ".claude")))
+        return "claude-cli";
+    return undefined;
+}
+function normalizeLang(lang) {
+    if ((lang ?? "").trim().toLowerCase().startsWith("tr"))
+        return "tr";
+    return "en";
+}
+function modelChoiceFromAi(ai) {
+    if (ai === "codex")
+        return "codex";
+    if (ai === "gemini-cli")
+        return "gemini";
+    return "auto-detect";
+}
+function defaultAuthorName(authorInput) {
+    const explicit = (authorInput ?? "").trim();
+    if (explicit.length > 0)
+        return explicit;
+    try {
+        const username = node_os_1.default.userInfo().username.trim();
+        if (username.length > 0)
+            return username;
+    }
+    catch {
+        // ignore lookup errors and continue with fallback
+    }
+    return "Product Author";
+}
+async function gatherInitSelections(options) {
+    const clack = await loadClack();
+    const defaultLang = normalizeLang(options.langInput);
+    const fallbackScript = process.platform === "win32" ? "ps" : "sh";
+    const parsedAi = (0, agent_command_installer_1.resolveAi)(options.aiInput);
+    const defaultAuthor = defaultAuthorName(options.authorInput);
+    if (!isInteractiveTerminal()) {
+        return {
+            ai: parsedAi,
+            script: fallbackScript,
+            lang: defaultLang,
+            author: defaultAuthor,
+            interactive: false
+        };
+    }
+    const detectedAi = await detectAi(options.projectRoot);
+    const initialModel = modelChoiceFromAi(parsedAi ?? detectedAi);
+    const projectName = node_path_1.default.basename(options.projectRoot) || ".";
+    const width = terminalWidth();
+    const subtitle = color("Prodo — Product Artifact Toolkit", "\u001B[1;37m");
+    const signature = color("Crafted by Codex, guided by Shahmarasy intelligence", "\u001B[38;5;244m");
+    const hero = [
+        "",
+        centerBlock(renderLogo().split("\n"), width),
+        "",
+        centerLine(subtitle, width),
+        centerLine(signature, width),
+        ""
+    ].join("\n");
+    clack.intro(hero);
+    clack.note(renderProjectBox(projectName, options.projectRoot), "Project Setup");
+    const model = await clack.select({
+        message: "Select model",
+        initialValue: initialModel,
+        options: [
+            { value: "codex", label: "codex", hint: "Native Codex flow" },
+            { value: "gemini", label: "gemini", hint: "Gemini CLI command set" },
+            { value: "auto-detect", label: "auto-detect", hint: "Detect from local agent directories" }
+        ]
+    });
+    if (clack.isCancel(model)) {
+        clack.cancel("Initialization cancelled.");
+        throw new errors_1.UserError("Initialization cancelled.");
+    }
+    const lang = await clack.select({
+        message: "Select language",
+        initialValue: defaultLang,
+        options: [
+            { value: "tr", label: "tr", hint: "Turkish" },
+            { value: "en", label: "en", hint: "English" }
+        ]
+    });
+    if (clack.isCancel(lang)) {
+        clack.cancel("Initialization cancelled.");
+        throw new errors_1.UserError("Initialization cancelled.");
+    }
+    const author = await clack.text({
+        message: "Author name",
+        placeholder: "Shahmarasy",
+        defaultValue: defaultAuthor
+    });
+    if (clack.isCancel(author)) {
+        clack.cancel("Initialization cancelled.");
+        throw new errors_1.UserError("Initialization cancelled.");
+    }
+    let selectedAi;
+    if (model === "codex")
+        selectedAi = "codex";
+    else if (model === "gemini")
+        selectedAi = "gemini-cli";
+    else
+        selectedAi = detectedAi;
+    return {
+        ai: selectedAi,
+        script: fallbackScript,
+        lang,
+        author: String(author).trim() || defaultAuthor,
+        interactive: true
+    };
+}
+function finishInitInteractive(summary) {
+    const aiText = summary.ai ?? "none";
+    return loadClack().then((clack) => clack.outro(`Scaffold complete.\nAI: ${aiText}\nLanguage: ${summary.lang}\nAuthor: ${summary.author}\nSettings: ${summary.settingsPath}\nNext: edit brief.md`));
+}

package/dist/cli/init.d.ts

@@ -0,0 +1,11 @@
+import { type SupportedAi } from "./agent-command-installer";
+export declare function runInit(cwd: string, options?: {
+    ai?: SupportedAi;
+    lang?: string;
+    author?: string;
+    preset?: string;
+    script?: "sh" | "ps";
+}): Promise<{
+    installedAgentFiles: string[];
+    settingsPath: string;
+}>;