@kody-ade/kody-engine-lite 0.1.44 → 0.1.46

package/dist/bin/cli.js

@@ -582,6 +582,75 @@ function setLifecycleLabel(issueNumber, phase) {
   }
   setLabel(issueNumber, `kody:${phase}`);
 }
+function getPRsForIssue(issueNumber) {
+  try {
+    const output = gh([
+      "pr",
+      "list",
+      "--search",
+      `${issueNumber} in:body`,
+      "--json",
+      "number,title,url,headRefName",
+      "--state",
+      "open"
+    ]);
+    const prs = JSON.parse(output);
+    const branchPrs = (() => {
+      try {
+        const branchOutput = gh([
+          "pr",
+          "list",
+          "--json",
+          "number,title,url,headRefName",
+          "--state",
+          "open"
+        ]);
+        return JSON.parse(branchOutput).filter((pr) => pr.headRefName.startsWith(`${issueNumber}-`));
+      } catch {
+        return [];
+      }
+    })();
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const pr of [...prs, ...branchPrs]) {
+      if (!seen.has(pr.number)) {
+        seen.add(pr.number);
+        merged.push({ number: pr.number, title: pr.title, url: pr.url, headBranch: pr.headRefName });
+      }
+    }
+    return merged;
+  } catch (err) {
+    logger.error(`  Failed to get PRs for issue #${issueNumber}: ${err}`);
+    return [];
+  }
+}
+function getPRDetails(prNumber) {
+  try {
+    const output = gh([
+      "pr",
+      "view",
+      String(prNumber),
+      "--json",
+      "title,body,headRefName,baseRefName"
+    ]);
+    const data = JSON.parse(output);
+    return { title: data.title, body: data.body, headBranch: data.headRefName, baseBranch: data.baseRefName };
+  } catch (err) {
+    logger.error(`  Failed to get PR #${prNumber}: ${err}`);
+    return null;
+  }
+}
+function postPRComment(prNumber, body) {
+  try {
+    gh(
+      ["pr", "comment", String(prNumber), "--body-file", "-"],
+      { input: body }
+    );
+    logger.info(`  Comment posted on PR #${prNumber}`);
+  } catch (err) {
+    logger.warn(`  Failed to post PR comment: ${err}`);
+  }
+}
 var API_TIMEOUT_MS, LIFECYCLE_LABELS, _ghCwd;
 var init_github_api = __esm({
   "src/github-api.ts"() {
@@ -683,7 +752,14 @@ var init_memory = __esm({
 // src/context.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
-function readPromptFile(stageName) {
+function readPromptFile(stageName, projectDir) {
+  if (projectDir) {
+    const stepFile = path4.join(projectDir, ".kody", "steps", `${stageName}.md`);
+    if (fs4.existsSync(stepFile)) {
+      return fs4.readFileSync(stepFile, "utf-8");
+    }
+    console.warn(`  \u26A0 No step file at ${stepFile}, falling back to engine defaults. Run 'kody-engine-lite init --force' to generate step files.`);
+  }
   const scriptDir = new URL(".", import.meta.url).pathname;
   const candidates = [
     path4.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
@@ -765,7 +841,7 @@ ${feedback}
 }
 function buildFullPrompt(stageName, taskId, taskDir, projectDir, feedback) {
   const memory = readProjectMemory(projectDir);
-  const promptTemplate = readPromptFile(stageName);
+  const promptTemplate = readPromptFile(stageName, projectDir);
   const prompt = injectTaskContext(promptTemplate, taskId, taskDir, feedback);
   return memory ? `${memory}
 ---
@@ -2413,6 +2489,128 @@ var init_preflight = __esm({
   }
 });
 
+// src/cli/task-resolution.ts
+import * as fs16 from "fs";
+import * as path15 from "path";
+import { execFileSync as execFileSync9 } from "child_process";
+function findLatestTaskForIssue(issueNumber, projectDir) {
+  const tasksDir = path15.join(projectDir, ".tasks");
+  if (!fs16.existsSync(tasksDir)) return null;
+  const allDirs = fs16.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+  const prefix = `${issueNumber}-`;
+  const direct = allDirs.find((d) => d.startsWith(prefix));
+  if (direct) return direct;
+  try {
+    const branch = execFileSync9("git", ["branch", "--show-current"], {
+      encoding: "utf-8",
+      cwd: projectDir,
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const branchIssueMatch = branch.match(/^(\d+)-/);
+    if (branchIssueMatch) {
+      const branchIssueNum = branchIssueMatch[1];
+      const branchPrefix = `${branchIssueNum}-`;
+      const fromBranch = allDirs.find((d) => d.startsWith(branchPrefix));
+      if (fromBranch) return fromBranch;
+    }
+  } catch {
+  }
+  return null;
+}
+function generateTaskId() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${String(now.getFullYear()).slice(2)}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+var init_task_resolution = __esm({
+  "src/cli/task-resolution.ts"() {
+    "use strict";
+  }
+});
+
+// src/review-standalone.ts
+import * as fs17 from "fs";
+import * as path16 from "path";
+function resolveReviewTarget(input) {
+  if (input.prs.length === 0) {
+    return {
+      action: "none",
+      message: `Issue #${input.issueNumber} has no open PRs. Nothing to review.`
+    };
+  }
+  if (input.prs.length === 1) {
+    return { action: "review", prNumber: input.prs[0].number };
+  }
+  const prList = input.prs.map((pr) => `  - #${pr.number}: ${pr.title}`).join("\n");
+  return {
+    action: "pick",
+    prs: input.prs,
+    message: `\u26A0\uFE0F Issue #${input.issueNumber} has ${input.prs.length} open PRs:
+${prList}
+
+Run: \`pnpm kody review --pr-number <n>\`
+Or comment on the specific PR: \`@kody review\``
+  };
+}
+async function runStandaloneReview(input) {
+  const taskId = input.taskId ?? `review-${generateTaskId()}`;
+  const taskDir = path16.join(input.projectDir, ".tasks", taskId);
+  fs17.mkdirSync(taskDir, { recursive: true });
+  const taskContent = `# ${input.prTitle}
+
+${input.prBody ?? ""}`;
+  fs17.writeFileSync(path16.join(taskDir, "task.md"), taskContent);
+  const reviewDef = STAGES.find((s) => s.name === "review");
+  const ctx = {
+    taskId,
+    taskDir,
+    projectDir: input.projectDir,
+    runners: input.runners,
+    sessions: {},
+    input: {
+      mode: "full",
+      local: input.local
+    }
+  };
+  logger.info(`[review] standalone review for: ${input.prTitle}`);
+  const result = await executeAgentStage(ctx, reviewDef);
+  if (result.outcome !== "completed") {
+    return {
+      outcome: "failed",
+      taskDir,
+      error: result.error ?? "Review stage failed"
+    };
+  }
+  const reviewPath = path16.join(taskDir, "review.md");
+  let reviewContent;
+  if (fs17.existsSync(reviewPath)) {
+    reviewContent = fs17.readFileSync(reviewPath, "utf-8");
+  }
+  return {
+    outcome: "completed",
+    reviewContent,
+    taskDir
+  };
+}
+function formatReviewComment(reviewContent, taskId) {
+  return `## \u{1F50D} Kody Review (\`${taskId}\`)
+
+${reviewContent}
+
+---
+\u{1F916} Generated by Kody`;
+}
+var init_review_standalone = __esm({
+  "src/review-standalone.ts"() {
+    "use strict";
+    init_definitions();
+    init_agent();
+    init_task_resolution();
+    init_logger();
+  }
+});
+
 // src/cli/args.ts
 function getArg(args2, flag) {
   const idx = args2.indexOf(flag);
@@ -2431,16 +2629,18 @@ function parseArgs() {
   kody run    --task-id <id> [--task "<desc>"] [--cwd <path>] [--issue-number <n>] [--complexity low|medium|high] [--feedback "<text>"] [--local] [--dry-run]
   kody rerun  --task-id <id> --from <stage> [--cwd <path>] [--issue-number <n>]
   kody fix    --task-id <id> [--cwd <path>] [--issue-number <n>] [--feedback "<text>"]
+  kody review [--pr-number <n>] [--issue-number <n>] [--cwd <path>] [--local]
   kody status --task-id <id> [--cwd <path>]
   kody --help`);
     process.exit(0);
   }
   const command2 = args2[0];
-  if (!["run", "rerun", "fix", "status"].includes(command2)) {
+  if (!["run", "rerun", "fix", "status", "review"].includes(command2)) {
     console.error(`Unknown command: ${command2}`);
     process.exit(1);
   }
   const issueStr = getArg(args2, "--issue-number") ?? process.env.ISSUE_NUMBER;
+  const prStr = getArg(args2, "--pr-number") ?? process.env.PR_NUMBER;
   const localFlag = hasFlag(args2, "--local");
   return {
     command: command2,
@@ -2450,6 +2650,7 @@ function parseArgs() {
     dryRun: hasFlag(args2, "--dry-run") || process.env.DRY_RUN === "true",
     cwd: getArg(args2, "--cwd"),
     issueNumber: issueStr ? parseInt(issueStr, 10) : void 0,
+    prNumber: prStr ? parseInt(prStr, 10) : void 0,
     feedback: getArg(args2, "--feedback") ?? process.env.FEEDBACK,
     local: localFlag || !isCI2 && !hasFlag(args2, "--no-local"),
     complexity: getArg(args2, "--complexity") ?? process.env.COMPLEXITY
@@ -2464,9 +2665,9 @@ var init_args = __esm({
 });
 
 // src/cli/litellm.ts
-import * as fs16 from "fs";
-import * as path15 from "path";
-import { execFileSync as execFileSync9 } from "child_process";
+import * as fs18 from "fs";
+import * as path17 from "path";
+import { execFileSync as execFileSync10 } from "child_process";
 async function checkLitellmHealth(url) {
   try {
     const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3e3) });
@@ -2476,8 +2677,8 @@ async function checkLitellmHealth(url) {
   }
 }
 async function tryStartLitellm(url, projectDir) {
-  const configPath = path15.join(projectDir, "litellm-config.yaml");
-  if (!fs16.existsSync(configPath)) {
+  const configPath = path17.join(projectDir, "litellm-config.yaml");
+  if (!fs18.existsSync(configPath)) {
     logger.warn("litellm-config.yaml not found \u2014 cannot start proxy");
     return null;
   }
@@ -2485,11 +2686,11 @@ async function tryStartLitellm(url, projectDir) {
   const port = portMatch ? portMatch[1] : "4000";
   let litellmFound = false;
   try {
-    execFileSync9("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync10("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     litellmFound = true;
   } catch {
     try {
-      execFileSync9("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
+      execFileSync10("python3", ["-c", "import litellm"], { timeout: 1e4, stdio: "pipe" });
       litellmFound = true;
     } catch {
     }
@@ -2502,17 +2703,17 @@ async function tryStartLitellm(url, projectDir) {
   let cmd;
   let args2;
   try {
-    execFileSync9("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
+    execFileSync10("which", ["litellm"], { timeout: 3e3, stdio: "pipe" });
     cmd = "litellm";
     args2 = ["--config", configPath, "--port", port];
   } catch {
     cmd = "python3";
     args2 = ["-m", "litellm", "--config", configPath, "--port", port];
   }
-  const dotenvPath = path15.join(projectDir, ".env");
+  const dotenvPath = path17.join(projectDir, ".env");
   const dotenvVars = {};
-  if (fs16.existsSync(dotenvPath)) {
-    for (const line of fs16.readFileSync(dotenvPath, "utf-8").split("\n")) {
+  if (fs18.existsSync(dotenvPath)) {
+    for (const line of fs18.readFileSync(dotenvPath, "utf-8").split("\n")) {
       const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
       if (match) dotenvVars[match[1]] = match[2];
     }
@@ -2551,49 +2752,9 @@ var init_litellm = __esm({
   }
 });
 
-// src/cli/task-resolution.ts
-import * as fs17 from "fs";
-import * as path16 from "path";
-import { execFileSync as execFileSync10 } from "child_process";
-function findLatestTaskForIssue(issueNumber, projectDir) {
-  const tasksDir = path16.join(projectDir, ".tasks");
-  if (!fs17.existsSync(tasksDir)) return null;
-  const allDirs = fs17.readdirSync(tasksDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
-  const prefix = `${issueNumber}-`;
-  const direct = allDirs.find((d) => d.startsWith(prefix));
-  if (direct) return direct;
-  try {
-    const branch = execFileSync10("git", ["branch", "--show-current"], {
-      encoding: "utf-8",
-      cwd: projectDir,
-      timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const branchIssueMatch = branch.match(/^(\d+)-/);
-    if (branchIssueMatch) {
-      const branchIssueNum = branchIssueMatch[1];
-      const branchPrefix = `${branchIssueNum}-`;
-      const fromBranch = allDirs.find((d) => d.startsWith(branchPrefix));
-      if (fromBranch) return fromBranch;
-    }
-  } catch {
-  }
-  return null;
-}
-function generateTaskId() {
-  const now = /* @__PURE__ */ new Date();
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${String(now.getFullYear()).slice(2)}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
-}
-var init_task_resolution = __esm({
-  "src/cli/task-resolution.ts"() {
-    "use strict";
-  }
-});
-
 // src/cli/task-state.ts
-import * as fs18 from "fs";
-import * as path17 from "path";
+import * as fs19 from "fs";
+import * as path18 from "path";
 function resolveTaskAction(issueNumber, existingTaskId, existingState) {
   if (!existingTaskId || !existingState) {
     return { action: "start-fresh", taskId: `${issueNumber}-${generateTaskId()}` };
@@ -2625,11 +2786,11 @@ function resolveTaskAction(issueNumber, existingTaskId, existingState) {
 function resolveForIssue(issueNumber, projectDir) {
   const existingTaskId = findLatestTaskForIssue(issueNumber, projectDir);
   if (existingTaskId) {
-    const statusPath = path17.join(projectDir, ".tasks", existingTaskId, "status.json");
+    const statusPath = path18.join(projectDir, ".tasks", existingTaskId, "status.json");
     let existingState = null;
-    if (fs18.existsSync(statusPath)) {
+    if (fs19.existsSync(statusPath)) {
       try {
-        existingState = JSON.parse(fs18.readFileSync(statusPath, "utf-8"));
+        existingState = JSON.parse(fs19.readFileSync(statusPath, "utf-8"));
       } catch {
       }
     }
@@ -2659,13 +2820,13 @@ var init_task_state = __esm({
 
 // src/entry.ts
 var entry_exports = {};
-import * as fs19 from "fs";
-import * as path18 from "path";
+import * as fs20 from "fs";
+import * as path19 from "path";
 async function main() {
   const input = parseArgs();
-  const projectDir = input.cwd ? path18.resolve(input.cwd) : process.cwd();
+  const projectDir = input.cwd ? path19.resolve(input.cwd) : process.cwd();
   if (input.cwd) {
-    if (!fs19.existsSync(projectDir)) {
+    if (!fs20.existsSync(projectDir)) {
       console.error(`--cwd path does not exist: ${projectDir}`);
       process.exit(1);
     }
@@ -2673,7 +2834,7 @@ async function main() {
     setGhCwd(projectDir);
     logger.info(`Working directory: ${projectDir}`);
   }
-  if (input.issueNumber) {
+  if (input.issueNumber && input.command !== "review") {
     const taskAction = resolveForIssue(input.issueNumber, projectDir);
     logger.info(`Task action: ${taskAction.action}`);
     if (taskAction.action === "already-completed") {
@@ -2709,35 +2870,109 @@ async function main() {
       taskId = `${input.issueNumber}-${generateTaskId()}`;
     } else if (input.command === "run" && input.task) {
       taskId = generateTaskId();
+    } else if (input.command === "review") {
+      taskId = input.prNumber ? `review-pr-${input.prNumber}-${generateTaskId()}` : `review-${generateTaskId()}`;
     } else {
       console.error("--task-id is required (or provide --issue-number to auto-generate)");
       process.exit(1);
     }
   }
-  const taskDir = path18.join(projectDir, ".tasks", taskId);
-  fs19.mkdirSync(taskDir, { recursive: true });
+  const taskDir = path19.join(projectDir, ".tasks", taskId);
+  fs20.mkdirSync(taskDir, { recursive: true });
   if (input.command === "status") {
     printStatus(taskId, taskDir);
     return;
   }
+  if (input.command === "review") {
+    runPreflight();
+    let prTitle = "Code review";
+    let prBody = "";
+    let prNumber = input.prNumber;
+    if (!prNumber && input.issueNumber) {
+      const prs = getPRsForIssue(input.issueNumber);
+      const target = resolveReviewTarget({ issueNumber: input.issueNumber, prs });
+      if (target.action === "none" || target.action === "pick") {
+        console.log(target.message);
+        if (!input.local && input.issueNumber) {
+          try {
+            postComment(input.issueNumber, target.message);
+          } catch {
+          }
+        }
+        process.exit(target.action === "none" ? 1 : 0);
+      }
+      prNumber = target.prNumber;
+    }
+    if (prNumber) {
+      const details = getPRDetails(prNumber);
+      if (details) {
+        prTitle = details.title;
+        prBody = details.body ?? "";
+      }
+    }
+    const config2 = getProjectConfig();
+    let litellmProcess2 = null;
+    if (config2.agent.litellmUrl) {
+      const proxyRunning = await checkLitellmHealth(config2.agent.litellmUrl);
+      if (!proxyRunning) {
+        litellmProcess2 = await tryStartLitellm(config2.agent.litellmUrl, projectDir);
+      }
+      if (config2.agent.litellmUrl) {
+        process.env.ANTHROPIC_BASE_URL = config2.agent.litellmUrl;
+      }
+    }
+    const runners2 = createRunners(config2);
+    const defaultRunnerName2 = config2.agent.defaultRunner ?? Object.keys(runners2)[0] ?? "claude";
+    const defaultRunner2 = runners2[defaultRunnerName2];
+    if (!defaultRunner2) {
+      console.error(`Default runner "${defaultRunnerName2}" not configured`);
+      process.exit(1);
+    }
+    const healthy2 = await defaultRunner2.healthCheck();
+    if (!healthy2) {
+      console.error(`Runner "${defaultRunnerName2}" health check failed`);
+      process.exit(1);
+    }
+    const result = await runStandaloneReview({
+      projectDir,
+      runners: runners2,
+      prTitle,
+      prBody,
+      local: input.local ?? true,
+      taskId
+    });
+    if (litellmProcess2) litellmProcess2.kill();
+    if (result.outcome === "failed") {
+      console.error(`Review failed: ${result.error}`);
+      process.exit(1);
+    }
+    if (result.reviewContent) {
+      console.log(result.reviewContent);
+      if (!input.local && prNumber) {
+        const comment = formatReviewComment(result.reviewContent, taskId);
+        postPRComment(prNumber, comment);
+      }
+    }
+    process.exit(0);
+  }
   logger.info("Preflight checks:");
   runPreflight();
   if (input.task) {
-    fs19.writeFileSync(path18.join(taskDir, "task.md"), input.task);
+    fs20.writeFileSync(path19.join(taskDir, "task.md"), input.task);
   }
-  const taskMdPath = path18.join(taskDir, "task.md");
-  if (!fs19.existsSync(taskMdPath) && input.issueNumber) {
+  const taskMdPath = path19.join(taskDir, "task.md");
+  if (!fs20.existsSync(taskMdPath) && input.issueNumber) {
     logger.info(`Fetching issue #${input.issueNumber} body as task...`);
     const issue = getIssue(input.issueNumber);
     if (issue) {
       const taskContent = `# ${issue.title}
 
 ${issue.body ?? ""}`;
-      fs19.writeFileSync(taskMdPath, taskContent);
+      fs20.writeFileSync(taskMdPath, taskContent);
       logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
     }
   }
-  if (!fs19.existsSync(taskMdPath)) {
+  if (!fs20.existsSync(taskMdPath)) {
     console.error("No task.md found. Provide --task, --issue-number, or ensure .tasks/<id>/task.md exists.");
     process.exit(1);
   }
@@ -2821,7 +3056,7 @@ To rerun: \`@kody rerun ${taskId} --from <stage>\``
     }
   }
   const state = await runPipeline(ctx);
-  const files = fs19.readdirSync(taskDir);
+  const files = fs20.readdirSync(taskDir);
   console.log(`
 Artifacts in ${taskDir}:`);
   for (const f of files) {
@@ -2862,6 +3097,7 @@ var init_entry = __esm({
     init_config();
     init_github_api();
     init_logger();
+    init_review_standalone();
     init_args();
     init_litellm();
     init_task_resolution();
@@ -2883,15 +3119,15 @@ var init_entry = __esm({
 });
 
 // src/bin/cli.ts
-import * as fs20 from "fs";
-import * as path19 from "path";
+import * as fs21 from "fs";
+import * as path20 from "path";
 import { execFileSync as execFileSync11 } from "child_process";
 import { fileURLToPath } from "url";
-var __dirname = path19.dirname(fileURLToPath(import.meta.url));
-var PKG_ROOT = path19.resolve(__dirname, "..", "..");
+var __dirname = path20.dirname(fileURLToPath(import.meta.url));
+var PKG_ROOT = path20.resolve(__dirname, "..", "..");
 function getVersion() {
-  const pkgPath = path19.join(PKG_ROOT, "package.json");
-  const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf-8"));
+  const pkgPath = path20.join(PKG_ROOT, "package.json");
+  const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
   return pkg.version;
 }
 function checkCommand2(name, args2, fix) {
@@ -2907,7 +3143,7 @@ function checkCommand2(name, args2, fix) {
   }
 }
 function checkFile(filePath, description, fix) {
-  if (fs20.existsSync(filePath)) {
+  if (fs21.existsSync(filePath)) {
     return { name: description, ok: true, detail: filePath };
   }
   return { name: description, ok: false, fix };
@@ -2979,10 +3215,10 @@ function checkGhSecret(repoSlug, secretName) {
 }
 function detectArchitecture(cwd) {
   const detected = [];
-  const pkgPath = path19.join(cwd, "package.json");
-  if (fs20.existsSync(pkgPath)) {
+  const pkgPath = path20.join(cwd, "package.json");
+  if (fs21.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf-8"));
+      const pkg = JSON.parse(fs21.readFileSync(pkgPath, "utf-8"));
       const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
       if (allDeps.next) detected.push(`- Framework: Next.js ${allDeps.next}`);
       else if (allDeps.react) detected.push(`- Framework: React ${allDeps.react}`);
@@ -3005,41 +3241,112 @@ function detectArchitecture(cwd) {
       if (allDeps.tailwindcss) detected.push(`- CSS: Tailwind CSS ${allDeps.tailwindcss}`);
       if (pkg.type === "module") detected.push("- Module system: ESM");
       else detected.push("- Module system: CommonJS");
-      if (fs20.existsSync(path19.join(cwd, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
-      else if (fs20.existsSync(path19.join(cwd, "yarn.lock"))) detected.push("- Package manager: yarn");
-      else if (fs20.existsSync(path19.join(cwd, "bun.lockb"))) detected.push("- Package manager: bun");
-      else if (fs20.existsSync(path19.join(cwd, "package-lock.json"))) detected.push("- Package manager: npm");
+      if (fs21.existsSync(path20.join(cwd, "pnpm-lock.yaml"))) detected.push("- Package manager: pnpm");
+      else if (fs21.existsSync(path20.join(cwd, "yarn.lock"))) detected.push("- Package manager: yarn");
+      else if (fs21.existsSync(path20.join(cwd, "bun.lockb"))) detected.push("- Package manager: bun");
+      else if (fs21.existsSync(path20.join(cwd, "package-lock.json"))) detected.push("- Package manager: npm");
     } catch {
     }
   }
   try {
-    const entries = fs20.readdirSync(cwd, { withFileTypes: true });
+    const entries = fs21.readdirSync(cwd, { withFileTypes: true });
     const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
     if (dirs.length > 0) detected.push(`- Top-level directories: ${dirs.join(", ")}`);
   } catch {
   }
-  const srcDir = path19.join(cwd, "src");
-  if (fs20.existsSync(srcDir)) {
+  const srcDir = path20.join(cwd, "src");
+  if (fs21.existsSync(srcDir)) {
     try {
-      const srcEntries = fs20.readdirSync(srcDir, { withFileTypes: true });
+      const srcEntries = fs21.readdirSync(srcDir, { withFileTypes: true });
       const srcDirs = srcEntries.filter((e) => e.isDirectory()).map((e) => e.name);
       if (srcDirs.length > 0) detected.push(`- src/ structure: ${srcDirs.join(", ")}`);
     } catch {
     }
   }
   const configs = [];
-  if (fs20.existsSync(path19.join(cwd, "tsconfig.json"))) configs.push("tsconfig.json");
-  if (fs20.existsSync(path19.join(cwd, "docker-compose.yml")) || fs20.existsSync(path19.join(cwd, "docker-compose.yaml"))) configs.push("docker-compose");
-  if (fs20.existsSync(path19.join(cwd, "Dockerfile"))) configs.push("Dockerfile");
-  if (fs20.existsSync(path19.join(cwd, ".env")) || fs20.existsSync(path19.join(cwd, ".env.local"))) configs.push(".env");
+  if (fs21.existsSync(path20.join(cwd, "tsconfig.json"))) configs.push("tsconfig.json");
+  if (fs21.existsSync(path20.join(cwd, "docker-compose.yml")) || fs21.existsSync(path20.join(cwd, "docker-compose.yaml"))) configs.push("docker-compose");
+  if (fs21.existsSync(path20.join(cwd, "Dockerfile"))) configs.push("Dockerfile");
+  if (fs21.existsSync(path20.join(cwd, ".env")) || fs21.existsSync(path20.join(cwd, ".env.local"))) configs.push(".env");
   if (configs.length > 0) detected.push(`- Config files: ${configs.join(", ")}`);
   return detected;
 }
+var STEP_STAGES = ["taskify", "plan", "build", "autofix", "review", "review-fix"];
+function gatherSampleSourceFiles(cwd, maxFiles = 3, maxCharsEach = 2e3) {
+  const srcDir = path20.join(cwd, "src");
+  const baseDir = fs21.existsSync(srcDir) ? srcDir : cwd;
+  const results = [];
+  function walk(dir) {
+    const entries = [];
+    try {
+      for (const entry of fs21.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+        const full = path20.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          entries.push(...walk(full));
+        } else if (/\.(ts|js)$/.test(entry.name) && !/\.(test|spec|config|d)\.(ts|js)$/.test(entry.name)) {
+          try {
+            const stat = fs21.statSync(full);
+            if (stat.size >= 200 && stat.size <= 5e3) {
+              entries.push({ filePath: full, size: stat.size });
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+    return entries;
+  }
+  const files = walk(baseDir).sort((a, b) => b.size - a.size).slice(0, maxFiles);
+  for (const { filePath } of files) {
+    const rel = path20.relative(cwd, filePath);
+    const content = fs21.readFileSync(filePath, "utf-8").slice(0, maxCharsEach);
+    results.push(`### File: ${rel}
+\`\`\`typescript
+${content}
+\`\`\``);
+  }
+  return results.join("\n\n");
+}
+function buildStepCustomizationPrompt(stageName, defaultPrompt, repoContext, architecture, conventions) {
+  return `You are customizing a Kody pipeline prompt for a specific repository.
+
+## Your Task
+Take the default prompt template below and produce a CUSTOMIZED version tailored to this specific repository.
+
+## Rules
+1. KEEP the entire original prompt intact \u2014 its role definition, rules, output format, and {{TASK_CONTEXT}} placeholder. Do not remove or rephrase any existing content.
+2. APPEND three new sections after the original content but BEFORE the {{TASK_CONTEXT}} line:
+   - ## Repo Patterns \u2014 Real code examples from this repo that demonstrate the patterns to follow. Include specific file paths, function signatures, and brief code snippets. Show what GOOD looks like in this repo.
+   - ## Improvement Areas \u2014 Gaps, anti-patterns, or inconsistencies found in the codebase that this stage should address when touching related code. Be specific with file paths and what to fix. Do NOT refactor unrelated code \u2014 only improve what the task touches.
+   - ## Acceptance Criteria \u2014 A concrete checklist (using markdown checkboxes) that defines "done" for this stage in this specific repo.
+3. Be SPECIFIC \u2014 reference actual file paths, function names, and conventions from the repo context provided below.
+4. Keep each appended section concise (10-20 lines max).
+5. Output ONLY the complete customized prompt markdown. No explanation before or after.
+
+## Stage Being Customized
+Stage: ${stageName}
+
+## Default Prompt Template
+${defaultPrompt}
+
+## Repository Context
+
+### Architecture
+${architecture}
+
+### Conventions
+${conventions}
+
+### Project Details
+${repoContext}`;
+}
 function detectBasicConfig(cwd) {
   let pm = "pnpm";
-  if (fs20.existsSync(path19.join(cwd, "yarn.lock"))) pm = "yarn";
-  else if (fs20.existsSync(path19.join(cwd, "bun.lockb"))) pm = "bun";
-  else if (!fs20.existsSync(path19.join(cwd, "pnpm-lock.yaml")) && fs20.existsSync(path19.join(cwd, "package-lock.json"))) pm = "npm";
+  if (fs21.existsSync(path20.join(cwd, "yarn.lock"))) pm = "yarn";
+  else if (fs21.existsSync(path20.join(cwd, "bun.lockb"))) pm = "bun";
+  else if (!fs21.existsSync(path20.join(cwd, "pnpm-lock.yaml")) && fs21.existsSync(path20.join(cwd, "package-lock.json"))) pm = "npm";
   let defaultBranch = "main";
   try {
     const ref = execFileSync11("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
@@ -3083,9 +3390,9 @@ function smartInit(cwd) {
   const basic = detectBasicConfig(cwd);
   let context = "";
   const readIfExists = (rel, maxChars = 3e3) => {
-    const p = path19.join(cwd, rel);
-    if (fs20.existsSync(p)) {
-      const content = fs20.readFileSync(p, "utf-8");
+    const p = path20.join(cwd, rel);
+    if (fs21.existsSync(p)) {
+      const content = fs21.readFileSync(p, "utf-8");
       return content.slice(0, maxChars);
     }
     return null;
@@ -3111,14 +3418,14 @@ ${claudeMd}
 
 `;
   try {
-    const topDirs = fs20.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    const topDirs = fs21.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
     context += `## Top-level directories
 ${topDirs.join(", ")}
 
 `;
-    const srcDir = path19.join(cwd, "src");
-    if (fs20.existsSync(srcDir)) {
-      const srcDirs = fs20.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    const srcDir = path20.join(cwd, "src");
+    if (fs21.existsSync(srcDir)) {
+      const srcDirs = fs21.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       context += `## src/ subdirectories
 ${srcDirs.join(", ")}
 
@@ -3128,7 +3435,7 @@ ${srcDirs.join(", ")}
   }
   const existingFiles = [];
   for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
-    if (fs20.existsSync(path19.join(cwd, f))) existingFiles.push(f);
+    if (fs21.existsSync(path20.join(cwd, f))) existingFiles.push(f);
   }
   if (existingFiles.length) context += `## Config files present
 ${existingFiles.join(", ")}
@@ -3234,7 +3541,7 @@ ${context}`;
 function validateQualityCommands(cwd, config, pm) {
   let scripts = {};
   try {
-    const pkg = JSON.parse(fs20.readFileSync(path19.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs21.readFileSync(path20.join(cwd, "package.json"), "utf-8"));
     scripts = pkg.scripts ?? {};
   } catch {
     return;
@@ -3268,7 +3575,7 @@ function validateQualityCommands(cwd, config, pm) {
 function buildFallbackConfig(cwd, basic) {
   const pkg = (() => {
     try {
-      return JSON.parse(fs20.readFileSync(path19.join(cwd, "package.json"), "utf-8"));
+      return JSON.parse(fs21.readFileSync(path20.join(cwd, "package.json"), "utf-8"));
     } catch {
       return {};
     }
@@ -3308,34 +3615,34 @@ function initCommand(opts) {
   console.log(`Project: ${cwd}
 `);
   console.log("\u2500\u2500 Files \u2500\u2500");
-  const templatesDir = path19.join(PKG_ROOT, "templates");
-  const workflowSrc = path19.join(templatesDir, "kody.yml");
-  const workflowDest = path19.join(cwd, ".github", "workflows", "kody.yml");
-  if (!fs20.existsSync(workflowSrc)) {
+  const templatesDir = path20.join(PKG_ROOT, "templates");
+  const workflowSrc = path20.join(templatesDir, "kody.yml");
+  const workflowDest = path20.join(cwd, ".github", "workflows", "kody.yml");
+  if (!fs21.existsSync(workflowSrc)) {
     console.error("  \u2717 Template kody.yml not found in package");
     process.exit(1);
   }
-  if (fs20.existsSync(workflowDest) && !opts.force) {
+  if (fs21.existsSync(workflowDest) && !opts.force) {
     console.log("  \u25CB .github/workflows/kody.yml (exists, use --force to overwrite)");
   } else {
-    fs20.mkdirSync(path19.dirname(workflowDest), { recursive: true });
-    fs20.copyFileSync(workflowSrc, workflowDest);
+    fs21.mkdirSync(path20.dirname(workflowDest), { recursive: true });
+    fs21.copyFileSync(workflowSrc, workflowDest);
     console.log("  \u2713 .github/workflows/kody.yml");
   }
-  const configDest = path19.join(cwd, "kody.config.json");
+  const configDest = path20.join(cwd, "kody.config.json");
   let smartResult = null;
-  if (!fs20.existsSync(configDest) || opts.force) {
+  if (!fs21.existsSync(configDest) || opts.force) {
     smartResult = smartInit(cwd);
-    fs20.writeFileSync(configDest, JSON.stringify(smartResult.config, null, 2) + "\n");
+    fs21.writeFileSync(configDest, JSON.stringify(smartResult.config, null, 2) + "\n");
     console.log("  \u2713 kody.config.json (auto-configured)");
   } else {
     console.log("  \u25CB kody.config.json (exists)");
   }
-  const gitignorePath = path19.join(cwd, ".gitignore");
-  if (fs20.existsSync(gitignorePath)) {
-    const content = fs20.readFileSync(gitignorePath, "utf-8");
+  const gitignorePath = path20.join(cwd, ".gitignore");
+  if (fs21.existsSync(gitignorePath)) {
+    const content = fs21.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".tasks/")) {
-      fs20.appendFileSync(gitignorePath, "\n.tasks/\n");
+      fs21.appendFileSync(gitignorePath, "\n.tasks/\n");
       console.log("  \u2713 .gitignore (added .tasks/)");
     } else {
       console.log("  \u25CB .gitignore (.tasks/ already present)");
@@ -3348,7 +3655,7 @@ function initCommand(opts) {
     checkCommand2("git", ["--version"], "Install git"),
     checkCommand2("node", ["--version"], "Install Node.js >= 22"),
     checkCommand2("pnpm", ["--version"], "Install: npm i -g pnpm"),
-    checkFile(path19.join(cwd, "package.json"), "package.json", "Run: pnpm init")
+    checkFile(path20.join(cwd, "package.json"), "package.json", "Run: pnpm init")
   ];
   for (const c of checks) {
     if (c.ok) {
@@ -3425,9 +3732,9 @@ function initCommand(opts) {
     }
   }
   console.log("\n\u2500\u2500 Config \u2500\u2500");
-  if (fs20.existsSync(configDest)) {
+  if (fs21.existsSync(configDest)) {
     try {
-      const config = JSON.parse(fs20.readFileSync(configDest, "utf-8"));
+      const config = JSON.parse(fs21.readFileSync(configDest, "utf-8"));
       const configChecks = [];
       if (config.github?.owner && config.github?.repo) {
         configChecks.push({ name: "github.owner/repo", ok: true, detail: `${config.github.owner}/${config.github.repo}` });
@@ -3454,21 +3761,21 @@ function initCommand(opts) {
     }
   }
   console.log("\n\u2500\u2500 Project Memory \u2500\u2500");
-  const memoryDir = path19.join(cwd, ".kody", "memory");
-  fs20.mkdirSync(memoryDir, { recursive: true });
-  const archPath = path19.join(memoryDir, "architecture.md");
-  const conventionsPath = path19.join(memoryDir, "conventions.md");
-  if (fs20.existsSync(archPath) && !opts.force) {
+  const memoryDir = path20.join(cwd, ".kody", "memory");
+  fs21.mkdirSync(memoryDir, { recursive: true });
+  const archPath = path20.join(memoryDir, "architecture.md");
+  const conventionsPath = path20.join(memoryDir, "conventions.md");
+  if (fs21.existsSync(archPath) && !opts.force) {
     console.log("  \u25CB .kody/memory/architecture.md (exists, use --force to regenerate)");
   } else if (smartResult?.architecture) {
-    fs20.writeFileSync(archPath, smartResult.architecture);
+    fs21.writeFileSync(archPath, smartResult.architecture);
     const lineCount = smartResult.architecture.split("\n").length;
     console.log(`  \u2713 .kody/memory/architecture.md (${lineCount} lines, LLM-generated)`);
   } else {
     const archItems = detectArchitecture(cwd);
     if (archItems.length > 0) {
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      fs20.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
+      fs21.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${archItems.join("\n")}
@@ -3478,23 +3785,116 @@ ${archItems.join("\n")}
       console.log("  \u25CB No architecture detected");
     }
   }
-  if (fs20.existsSync(conventionsPath) && !opts.force) {
+  if (fs21.existsSync(conventionsPath) && !opts.force) {
     console.log("  \u25CB .kody/memory/conventions.md (exists, use --force to regenerate)");
   } else if (smartResult?.conventions) {
-    fs20.writeFileSync(conventionsPath, smartResult.conventions);
+    fs21.writeFileSync(conventionsPath, smartResult.conventions);
     const lineCount = smartResult.conventions.split("\n").length;
     console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines, LLM-generated)`);
   } else {
-    fs20.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
+    fs21.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
     console.log("  \u2713 .kody/memory/conventions.md (seed)");
   }
+  console.log("\n\u2500\u2500 Step Files \u2500\u2500");
+  const stepsDir = path20.join(cwd, ".kody", "steps");
+  const stepsExist = fs21.existsSync(stepsDir) && fs21.readdirSync(stepsDir).some((f) => f.endsWith(".md"));
+  if (stepsExist && !opts.force) {
+    console.log("  \u25CB .kody/steps/ (exists, use --force to regenerate)");
+  } else {
+    fs21.mkdirSync(stepsDir, { recursive: true });
+    const readIfExistsForSteps = (rel, maxChars = 3e3) => {
+      const p = path20.join(cwd, rel);
+      if (fs21.existsSync(p)) return fs21.readFileSync(p, "utf-8").slice(0, maxChars);
+      return null;
+    };
+    let repoContext = "";
+    const pkgForSteps = readIfExistsForSteps("package.json");
+    if (pkgForSteps) repoContext += `## package.json
+${pkgForSteps}
+
+`;
+    const readmeForSteps = readIfExistsForSteps("README.md", 2e3);
+    if (readmeForSteps) repoContext += `## README.md
+${readmeForSteps}
+
+`;
+    const claudeMdForSteps = readIfExistsForSteps("CLAUDE.md", 3e3);
+    if (claudeMdForSteps) repoContext += `## CLAUDE.md
+${claudeMdForSteps}
+
+`;
+    const agentsMdForSteps = readIfExistsForSteps("AGENTS.md", 3e3);
+    if (agentsMdForSteps) repoContext += `## AGENTS.md
+${agentsMdForSteps}
+
+`;
+    const sampleFiles = gatherSampleSourceFiles(cwd);
+    if (sampleFiles) repoContext += `## Sample Source Files
+${sampleFiles}
+
+`;
+    try {
+      const srcEntries = fs21.readdirSync(path20.join(cwd, "src"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      if (srcEntries.length > 0) repoContext += `## src/ structure
+${srcEntries.join(", ")}
+
+`;
+    } catch {
+    }
+    const arch = fs21.existsSync(archPath) ? fs21.readFileSync(archPath, "utf-8") : "";
+    const conv = fs21.existsSync(conventionsPath) ? fs21.readFileSync(conventionsPath, "utf-8") : "";
+    console.log("  \u23F3 Customizing step files with Claude (sonnet)...");
+    let stepCount = 0;
+    for (const stage of STEP_STAGES) {
+      const templatePath = path20.join(PKG_ROOT, "prompts", `${stage}.md`);
+      if (!fs21.existsSync(templatePath)) {
+        console.log(`  \u2717 ${stage}.md \u2014 template not found in engine`);
+        continue;
+      }
+      const defaultPrompt = fs21.readFileSync(templatePath, "utf-8");
+      const customizationPrompt = buildStepCustomizationPrompt(stage, defaultPrompt, repoContext, arch, conv);
+      try {
+        const output = execFileSync11("claude", [
+          "--print",
+          "--model",
+          "sonnet",
+          "--dangerously-skip-permissions",
+          customizationPrompt
+        ], {
+          encoding: "utf-8",
+          timeout: 12e4,
+          cwd,
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        if (!output.includes("{{TASK_CONTEXT}}")) {
+          console.log(`  \u26A0 ${stage}.md \u2014 AI dropped {{TASK_CONTEXT}}, using default template`);
+          fs21.writeFileSync(path20.join(stepsDir, `${stage}.md`), defaultPrompt);
+        } else {
+          fs21.writeFileSync(path20.join(stepsDir, `${stage}.md`), output);
+        }
+        stepCount++;
+        console.log(`  \u2713 ${stage}.md`);
+      } catch (err) {
+        console.log(`  \u26A0 ${stage}.md \u2014 customization failed, using default template`);
+        fs21.copyFileSync(templatePath, path20.join(stepsDir, `${stage}.md`));
+        stepCount++;
+      }
+    }
+    console.log(`  \u2713 Generated ${stepCount} step files in .kody/steps/`);
+  }
   console.log("\n\u2500\u2500 Git \u2500\u2500");
   const filesToCommit = [
     ".github/workflows/kody.yml",
     "kody.config.json",
     ".kody/memory/architecture.md",
     ".kody/memory/conventions.md"
-  ].filter((f) => fs20.existsSync(path19.join(cwd, f)));
+  ].filter((f) => fs21.existsSync(path20.join(cwd, f)));
+  for (const stage of STEP_STAGES) {
+    const stepFile = `.kody/steps/${stage}.md`;
+    if (fs21.existsSync(path20.join(cwd, stepFile))) {
+      filesToCommit.push(stepFile);
+    }
+  }
   if (filesToCommit.length > 0) {
     try {
       execFileSync11("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });