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

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"() {
@@ -2413,6 +2482,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 +2622,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 +2643,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 +2658,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 +2670,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 +2679,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 +2696,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 +2745,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 +2779,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 +2813,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 +2827,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 +2863,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 +3049,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 +3090,7 @@ var init_entry = __esm({
     init_config();
     init_github_api();
     init_logger();
+    init_review_standalone();
     init_args();
     init_litellm();
     init_task_resolution();
@@ -2883,15 +3112,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 +3136,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 +3208,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 +3234,41 @@ 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;
 }
 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 +3312,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 +3340,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 +3357,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 +3463,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 +3497,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 +3537,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 +3577,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 +3654,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 +3683,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,14 +3707,14 @@ ${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 Git \u2500\u2500");
@@ -3494,7 +3723,7 @@ ${archItems.join("\n")}
     "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)));
   if (filesToCommit.length > 0) {
     try {
       execFileSync11("git", ["add", ...filesToCommit], { cwd, stdio: "pipe" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",