@shahmarasy/prodo 0.1.0

package/dist/doctor.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const node_child_process_1 = require("node:child_process");
+const paths_1 = require("./paths");
+const utils_1 = require("./utils");
+const version_1 = require("./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 aiRows = [
+        { 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 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 / Agents", "\u001B[1m"));
+    for (const line of renderRows(aiRows))
+        out(line);
+    out("");
+    out(color("Dev Tools", "\u001B[1m"));
+    for (const line of renderRows(devRows))
+        out(line);
+    out("");
+}

package/dist/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class UserError extends Error {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserError = void 0;
+class UserError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UserError";
+    }
+}
+exports.UserError = UserError;

package/dist/hook-executor.d.ts

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

package/dist/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/init-tui.d.ts

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

package/dist/init-tui.js

@@ -0,0 +1,161 @@
+"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 agent_command_installer_1 = require("./agent-command-installer");
+const errors_1 = require("./errors");
+const utils_1 = require("./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";
+}
+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);
+    if (!isInteractiveTerminal()) {
+        return {
+            ai: parsedAi,
+            script: fallbackScript,
+            lang: defaultLang,
+            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 script = await clack.select({
+        message: "Select script type",
+        initialValue: fallbackScript,
+        options: [
+            { value: "sh", label: "sh", hint: "Command profile (metadata)" },
+            { value: "ps", label: "ps", hint: "Command profile (metadata)" }
+        ]
+    });
+    if (clack.isCancel(script)) {
+        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.");
+    }
+    let selectedAi;
+    if (model === "codex")
+        selectedAi = "codex";
+    else if (model === "gemini")
+        selectedAi = "gemini-cli";
+    else
+        selectedAi = detectedAi;
+    return {
+        ai: selectedAi,
+        script,
+        lang,
+        interactive: true
+    };
+}
+function finishInitInteractive(summary) {
+    const aiText = summary.ai ?? "none";
+    return loadClack().then((clack) => clack.outro(`Scaffold complete.\nAI: ${aiText}\nScript: ${summary.script}\nLanguage: ${summary.lang}\nSettings: ${summary.settingsPath}\nNext: edit brief.md`));
+}

package/dist/init.d.ts

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