@shahmarasy/prodo 0.1.0

package/src/doctor.ts

@@ -0,0 +1,137 @@
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { prodoPath } from "./paths";
+import { fileExists } from "./utils";
+import { readCliVersion } from "./version";
+
+type RowStatus = "available" | "not_found" | "ide";
+
+type DoctorRow = {
+  name: string;
+  status: RowStatus;
+  detail: string;
+};
+
+function termWidth(): number {
+  return Math.max(80, process.stdout.columns ?? 100);
+}
+
+function stripAnsi(input: string): string {
+  return input.replace(/\u001B\[[0-9;]*m/g, "");
+}
+
+function color(input: string, code: string): string {
+  if (!process.stdout.isTTY) return input;
+  return `${code}${input}\u001B[0m`;
+}
+
+function center(input: string, width: number): string {
+  const visible = stripAnsi(input).length;
+  const left = Math.max(0, Math.floor((width - visible) / 2));
+  return `${" ".repeat(left)}${input}`;
+}
+
+function iconFor(status: RowStatus): string {
+  if (status === "available") return color("✔", "\u001B[32m");
+  if (status === "not_found") return color("✖", "\u001B[31m");
+  return color("•", "\u001B[33m");
+}
+
+function labelFor(status: RowStatus): string {
+  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: DoctorRow[]): string[] {
+  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: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const lookup = process.platform === "win32" ? "where" : "which";
+    const child = spawn(lookup, [command], { stdio: "ignore" });
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+  });
+}
+
+async function firstAvailable(commands: string[]): Promise<boolean> {
+  for (const command of commands) {
+    if (await commandExists(command)) return true;
+  }
+  return false;
+}
+
+function renderLogo(width: number): string {
+  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");
+}
+
+export async function runDoctor(cwd: string, out: (line: string) => void): Promise<void> {
+  const width = termWidth();
+  const version = await readCliVersion(cwd);
+  const isInitialized = await fileExists(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: DoctorRow[] = [
+    { name: "Prodo CLI", status: "available", detail: `v${version}` },
+    {
+      name: "Project initialized",
+      status: isInitialized ? "available" : "not_found",
+      detail: isInitialized ? ".prodo found" : ".prodo missing"
+    }
+  ];
+
+  const aiRows: DoctorRow[] = [
+    { 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: DoctorRow[] = [
+    { 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/src/errors.ts

@@ -0,0 +1,7 @@
+export class UserError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "UserError";
+  }
+}
+

package/src/hook-executor.ts

@@ -0,0 +1,196 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import yaml from "js-yaml";
+import { UserError } from "./errors";
+import { fileExists } from "./utils";
+
+type HookItem = {
+  command?: string;
+  optional?: boolean;
+  enabled?: boolean;
+  description?: string;
+  prompt?: string;
+  extension?: string;
+  condition?: string;
+  timeout_ms?: number;
+  retry?: number;
+  retry_delay_ms?: number;
+};
+
+type HooksConfig = {
+  hooks?: Record<string, HookItem[]>;
+};
+
+function hooksPath(cwd: string): string {
+  return path.join(cwd, ".prodo", "hooks.yml");
+}
+
+async function runShellCommand(
+  command: string,
+  cwd: string,
+  timeoutMs: number
+): Promise<{ code: number; stdout: string; stderr: string; timedOut: boolean }> {
+  const parsed = parseCommand(command);
+  if (!parsed) {
+    return { code: 1, stdout: "", stderr: "Invalid hook command syntax.", timedOut: false };
+  }
+  return new Promise((resolve) => {
+    const child = 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: string): { bin: string; args: string[] } | null {
+  const src = command.trim();
+  if (!src) return null;
+  const out: string[] = [];
+  let current = "";
+  let quote: '"' | "'" | null = 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: unknown, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  const normalized = Math.floor(value);
+  return normalized > 0 ? normalized : fallback;
+}
+
+function toNonNegativeInt(value: unknown, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  const normalized = Math.floor(value);
+  return normalized >= 0 ? normalized : fallback;
+}
+
+async function sleep(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function evaluateCondition(condition: string, cwd: string): Promise<boolean> {
+  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: string): Promise<HooksConfig | null> {
+  const file = hooksPath(cwd);
+  if (!(await fileExists(file))) return null;
+  try {
+    const raw = await fs.readFile(file, "utf8");
+    const parsed = yaml.load(raw) as HooksConfig;
+    return parsed ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export async function runHookPhase(
+  cwd: string,
+  phaseKey: string,
+  log: (message: string) => void
+): Promise<void> {
+  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 UserError(`Mandatory hook failed (${phaseKey}): ${command}\n${lastDetail}`);
+    }
+  }
+}

package/src/init-tui.ts

@@ -0,0 +1,193 @@
+import path from "node:path";
+import { resolveAi, type SupportedAi } from "./agent-command-installer";
+import { UserError } from "./errors";
+import { fileExists } from "./utils";
+
+export type InitSelections = {
+  ai?: SupportedAi;
+  script: "sh" | "ps";
+  lang: "tr" | "en";
+  interactive: boolean;
+};
+
+type GatherInitUiOptions = {
+  projectRoot: string;
+  aiInput?: string;
+  langInput?: string;
+};
+
+type ClackPrompts = typeof import("@clack/prompts");
+
+const dynamicImport = new Function("specifier", "return import(specifier)") as (
+  specifier: string
+) => Promise<unknown>;
+
+async function loadClack(): Promise<ClackPrompts> {
+  return (await dynamicImport("@clack/prompts")) as ClackPrompts;
+}
+
+function isInteractiveTerminal(): boolean {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
+}
+
+function color(text: string, code: string): string {
+  return `${code}${text}\u001B[0m`;
+}
+
+function stripAnsi(input: string): string {
+  return input.replace(/\u001B\[[0-9;]*m/g, "");
+}
+
+function centerLine(line: string, width: number): string {
+  const visible = stripAnsi(line).length;
+  const left = Math.max(0, Math.floor((width - visible) / 2));
+  return `${" ".repeat(left)}${line}`;
+}
+
+function centerBlock(lines: string[], width: number): string {
+  return lines.map((line) => centerLine(line, width)).join("\n");
+}
+
+function terminalWidth(): number {
+  const columns = process.stdout.columns ?? 100;
+  return Math.max(80, columns);
+}
+
+function renderLogo(): string {
+  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: string, projectRoot: string): string {
+  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: string): Promise<SupportedAi | undefined> {
+  if (await fileExists(path.join(projectRoot, ".agents"))) return "codex";
+  if (await fileExists(path.join(projectRoot, ".gemini"))) return "gemini-cli";
+  if (await fileExists(path.join(projectRoot, ".claude"))) return "claude-cli";
+  return undefined;
+}
+
+function normalizeLang(lang?: string): "tr" | "en" {
+  if ((lang ?? "").trim().toLowerCase().startsWith("tr")) return "tr";
+  return "en";
+}
+
+function modelChoiceFromAi(ai?: SupportedAi): "codex" | "gemini" | "auto-detect" {
+  if (ai === "codex") return "codex";
+  if (ai === "gemini-cli") return "gemini";
+  return "auto-detect";
+}
+
+export async function gatherInitSelections(options: GatherInitUiOptions): Promise<InitSelections> {
+  const clack = await loadClack();
+  const defaultLang = normalizeLang(options.langInput);
+  const fallbackScript: "sh" | "ps" = process.platform === "win32" ? "ps" : "sh";
+  const parsedAi = 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 = path.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 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 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 UserError("Initialization cancelled.");
+  }
+
+  let selectedAi: SupportedAi | undefined;
+  if (model === "codex") selectedAi = "codex";
+  else if (model === "gemini") selectedAi = "gemini-cli";
+  else selectedAi = detectedAi;
+
+  return {
+    ai: selectedAi,
+    script,
+    lang,
+    interactive: true
+  };
+}
+
+export function finishInitInteractive(summary: {
+  projectRoot: string;
+  settingsPath: string;
+  ai?: SupportedAi;
+  script: "sh" | "ps";
+  lang: "tr" | "en";
+}): Promise<void> {
+  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`
+  ));
+}