@shahmarasy/prodo 0.1.5 → 0.1.6

package/src/cli/init-tui.ts

@@ -1,208 +1,220 @@
-import path from "node:path";
-import os from "node:os";
-import { resolveAi, type SupportedAi } from "./agent-command-installer";
-import { UserError } from "../core/errors";
-import { fileExists } from "../core/utils";
-
-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;
-};
-
-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";
-}
-
-function defaultAuthorName(authorInput?: string): string {
-  const explicit = (authorInput ?? "").trim();
-  if (explicit.length > 0) return explicit;
-  try {
-    const username = os.userInfo().username.trim();
-    if (username.length > 0) return username;
-  } catch {
-    // ignore lookup errors and continue with fallback
-  }
-  return "Product Author";
-}
-
-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);
-  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 = 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 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.");
-  }
-
-  const author = await clack.text({
-    message: "Author name",
-    placeholder: "Shahmarasy",
-    defaultValue: defaultAuthor
-  });
-  if (clack.isCancel(author)) {
-    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: fallbackScript,
-    lang,
-    author: String(author).trim() || defaultAuthor,
-    interactive: true
-  };
-}
-
-export function finishInitInteractive(summary: {
-  projectRoot: string;
-  settingsPath: string;
-  ai?: SupportedAi;
-  lang: "tr" | "en";
-  author: string;
-}): Promise<void> {
-  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`
-  ));
-}
+import path from "node:path";
+import os from "node:os";
+import { resolveAi, type SupportedAi } from "./agent-command-installer";
+import { UserError } from "../core/errors";
+import { fileExists } from "../core/utils";
+
+export type InitSelections = {
+  ai?: SupportedAi;
+  script: "sh" | "ps";
+  lang: string;
+  author: string;
+  interactive: boolean;
+};
+
+type GatherInitUiOptions = {
+  projectRoot: string;
+  aiInput?: string;
+  langInput?: string;
+  authorInput?: 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, ".claude"))) return "claude-cli";
+  if (await fileExists(path.join(projectRoot, ".agents"))) return "codex";
+  if (await fileExists(path.join(projectRoot, ".gemini"))) return "gemini-cli";
+  return undefined;
+}
+
+function normalizeLang(lang?: string): string {
+  const raw = (lang ?? "").trim().toLowerCase();
+  if (raw.startsWith("tr")) return "tr";
+  return "en";
+}
+
+function defaultAuthorName(authorInput?: string): string {
+  const explicit = (authorInput ?? "").trim();
+  if (explicit.length > 0) return explicit;
+  try {
+    const username = os.userInfo().username.trim();
+    if (username.length > 0) return username;
+  } catch {
+    // ignore
+  }
+  return "Product Author";
+}
+
+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);
+  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 projectName = path.basename(options.projectRoot) || ".";
+  const width = terminalWidth();
+  const subtitle = color("Prodo — AI-Powered Product Owner", "\u001B[1;37m");
+  const signature = color("Built by Shahmarasy · Works with Claude, Codex, and Gemini", "\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 agentChoice = await clack.select({
+    message: "Which AI agent will you use?",
+    initialValue: parsedAi ?? detectedAi ?? "claude-cli",
+    options: [
+      { value: "claude-cli", label: "Claude Code", hint: "Slash commands → .claude/commands/" },
+      { value: "codex", label: "Codex", hint: "Skills → .agents/skills/" },
+      { value: "gemini-cli", label: "Gemini CLI", hint: "Commands → .gemini/commands/" }
+    ]
+  });
+  if (clack.isCancel(agentChoice)) {
+    clack.cancel("Initialization cancelled.");
+    throw new UserError("Initialization cancelled.");
+  }
+
+  const lang = await clack.select({
+    message: "Document language",
+    initialValue: defaultLang,
+    options: [
+      { value: "en", label: "English" },
+      { value: "tr", label: "Türkçe" }
+    ]
+  });
+  if (clack.isCancel(lang)) {
+    clack.cancel("Initialization cancelled.");
+    throw new UserError("Initialization cancelled.");
+  }
+
+  const author = await clack.text({
+    message: "Author name",
+    placeholder: "Your name",
+    defaultValue: defaultAuthor
+  });
+  if (clack.isCancel(author)) {
+    clack.cancel("Initialization cancelled.");
+    throw new UserError("Initialization cancelled.");
+  }
+
+  return {
+    ai: agentChoice as SupportedAi,
+    script: fallbackScript,
+    lang: String(lang),
+    author: String(author).trim() || defaultAuthor,
+    interactive: true
+  };
+}
+
+export function finishInitInteractive(summary: {
+  projectRoot: string;
+  settingsPath: string;
+  ai?: SupportedAi;
+  lang: string;
+  author: string;
+}): Promise<void> {
+  const agentLabel = summary.ai === "claude-cli" ? "Claude Code"
+    : summary.ai === "codex" ? "Codex"
+    : summary.ai === "gemini-cli" ? "Gemini CLI"
+    : "none";
+
+  const commandPrefix = summary.ai === "codex" ? "$" : "/";
+  const commands = [
+    `${commandPrefix}prodo-normalize`,
+    `${commandPrefix}prodo-prd`,
+    `${commandPrefix}prodo-workflow`,
+    `${commandPrefix}prodo-wireframe`,
+    `${commandPrefix}prodo-stories`,
+    `${commandPrefix}prodo-techspec`,
+    `${commandPrefix}prodo-validate`
+  ];
+
+  return loadClack().then((clack) => clack.outro(
+    `Scaffold complete!\n\n` +
+    `  Agent:    ${agentLabel}\n` +
+    `  Language: ${summary.lang}\n` +
+    `  Author:   ${summary.author}\n\n` +
+    `Next steps:\n` +
+    `  1. Edit brief.md with your product description\n` +
+    `  2. Open this folder in ${agentLabel}\n` +
+    `  3. Run commands in sequence:\n` +
+    `     ${commands.join("\n     ")}`
+  ));
+}

package/src/cli/init.ts

@@ -284,7 +284,7 @@ function summarizeParity(items: AssetManifestItem[]): ScaffoldManifest["parity_s
 
 export async function runInit(
   cwd: string,
-  options?: { ai?: SupportedAi; lang?: string; author?: string; preset?: string; script?: "sh" | "ps" }
+  options?: { ai?: SupportedAi; lang?: string; author?: string; preset?: string; script?: "sh" | "ps"; provider?: string }
 ): Promise<{ installedAgentFiles: string[]; settingsPath: string }> {
   const root = prodoPath(cwd);
   const artifactDefs = await listArtifactDefinitions(cwd);
@@ -392,7 +392,8 @@ export async function runInit(
   const settingsPath = await writeSettings(cwd, {
     lang: (options?.lang ?? "en").trim() || "en",
     ai: options?.ai,
-    author: (options?.author ?? "").trim() || undefined
+    author: (options?.author ?? "").trim() || undefined,
+    provider: options?.provider
   });
   return { installedAgentFiles, settingsPath };
 }

package/src/core/settings.ts

@@ -1,35 +1,41 @@
-import fs from "node:fs/promises";
-import { settingsPath } from "./paths";
-import { fileExists } from "./utils";
-
-export type ProdoSettings = {
-  lang: string;
-  ai?: string;
-  author?: string;
-};
-
-const DEFAULT_SETTINGS: ProdoSettings = {
-  lang: "en"
-};
-
-export async function readSettings(cwd: string): Promise<ProdoSettings> {
-  const path = settingsPath(cwd);
-  if (!(await fileExists(path))) return { ...DEFAULT_SETTINGS };
-  try {
-    const raw = await fs.readFile(path, "utf8");
-    const parsed = JSON.parse(raw) as Partial<ProdoSettings>;
-    return {
-      lang: typeof parsed.lang === "string" && parsed.lang.trim() ? parsed.lang.trim() : "en",
-      ai: typeof parsed.ai === "string" && parsed.ai.trim() ? parsed.ai.trim() : undefined,
-      author: typeof parsed.author === "string" && parsed.author.trim() ? parsed.author.trim() : undefined
-    };
-  } catch {
-    return { ...DEFAULT_SETTINGS };
-  }
-}
-
-export async function writeSettings(cwd: string, settings: ProdoSettings): Promise<string> {
-  const path = settingsPath(cwd);
-  await fs.writeFile(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
-  return path;
-}
+import fs from "node:fs/promises";
+import { settingsPath } from "./paths";
+import { fileExists } from "./utils";
+
+export type ProdoSettings = {
+  lang: string;
+  ai?: string;
+  author?: string;
+  provider?: string;
+};
+
+const DEFAULT_SETTINGS: ProdoSettings = {
+  lang: "en"
+};
+
+export async function readSettings(cwd: string): Promise<ProdoSettings> {
+  const path = settingsPath(cwd);
+  if (!(await fileExists(path))) return { ...DEFAULT_SETTINGS };
+  try {
+    const raw = await fs.readFile(path, "utf8");
+    const parsed = JSON.parse(raw) as Partial<ProdoSettings>;
+    return {
+      lang: typeof parsed.lang === "string" && parsed.lang.trim() ? parsed.lang.trim() : "en",
+      ai: typeof parsed.ai === "string" && parsed.ai.trim() ? parsed.ai.trim() : undefined,
+      author: typeof parsed.author === "string" && parsed.author.trim() ? parsed.author.trim() : undefined,
+      provider: typeof parsed.provider === "string" && parsed.provider.trim() ? parsed.provider.trim() : undefined
+    };
+  } catch {
+    return { ...DEFAULT_SETTINGS };
+  }
+}
+
+export async function writeSettings(cwd: string, settings: ProdoSettings): Promise<string> {
+  const path = settingsPath(cwd);
+  const clean: Record<string, unknown> = { lang: settings.lang };
+  if (settings.ai) clean.ai = settings.ai;
+  if (settings.author) clean.author = settings.author;
+  if (settings.provider) clean.provider = settings.provider;
+  await fs.writeFile(path, `${JSON.stringify(clean, null, 2)}\n`, "utf8");
+  return path;
+}

package/src/skill-engine/context.ts

@@ -0,0 +1,90 @@
+import { normalizedBriefPath } from "../core/paths";
+import { getActiveArtifactPath } from "../core/output-index";
+import { fileExists } from "../core/utils";
+import type { ArtifactType } from "../core/types";
+import type { PipelineState } from "./types";
+
+export function createPipelineState(cwd: string): PipelineState {
+  return {
+    cwd,
+    normalizedBriefPath: undefined,
+    generatedArtifacts: new Map(),
+    validationResult: undefined,
+    custom: {},
+    startedAt: new Date().toISOString(),
+    completedSkills: []
+  };
+}
+
+export async function hydrateStateFromDisk(
+  cwd: string,
+  state: PipelineState,
+  artifactTypes: ArtifactType[]
+): Promise<void> {
+  const nbPath = normalizedBriefPath(cwd);
+  if (!state.normalizedBriefPath && (await fileExists(nbPath))) {
+    state.normalizedBriefPath = nbPath;
+  }
+
+  for (const type of artifactTypes) {
+    if (!state.generatedArtifacts.has(type)) {
+      const active = await getActiveArtifactPath(cwd, type);
+      if (active) {
+        state.generatedArtifacts.set(type, active);
+      }
+    }
+  }
+}
+
+export function isOutputSatisfied(
+  outputName: string,
+  state: PipelineState,
+  artifactType?: string
+): boolean {
+  if (outputName === "normalizedBriefPath") {
+    return typeof state.normalizedBriefPath === "string" && state.normalizedBriefPath.length > 0;
+  }
+  if (outputName === "artifactPath" && artifactType) {
+    return state.generatedArtifacts.has(artifactType);
+  }
+  if (outputName === "validationResult") {
+    return state.validationResult !== undefined;
+  }
+  return false;
+}
+
+export function wireInputsFromState(
+  inputNames: string[],
+  state: PipelineState
+): Record<string, unknown> {
+  const inputs: Record<string, unknown> = {};
+  for (const name of inputNames) {
+    if (name === "cwd") inputs.cwd = state.cwd;
+    else if (name === "normalizedBriefPath") inputs.normalizedBriefPath = state.normalizedBriefPath;
+    else if (name in state.custom) inputs[name] = state.custom[name];
+  }
+  return inputs;
+}
+
+export function wireOutputsToState(
+  outputs: Record<string, unknown>,
+  state: PipelineState,
+  skillName: string
+): void {
+  if ("normalizedBriefPath" in outputs && typeof outputs.normalizedBriefPath === "string") {
+    state.normalizedBriefPath = outputs.normalizedBriefPath;
+  }
+  if ("artifactPath" in outputs && typeof outputs.artifactPath === "string") {
+    const artifactType = skillName;
+    state.generatedArtifacts.set(artifactType, outputs.artifactPath);
+  }
+  if ("validationResult" in outputs && outputs.validationResult && typeof outputs.validationResult === "object") {
+    state.validationResult = outputs.validationResult as PipelineState["validationResult"];
+  }
+
+  for (const [key, value] of Object.entries(outputs)) {
+    if (!["normalizedBriefPath", "artifactPath", "validationResult"].includes(key)) {
+      state.custom[key] = value;
+    }
+  }
+}