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

package/dist/bin/cli.js

@@ -752,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`),
@@ -834,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}
 ---
@@ -3264,6 +3271,77 @@ function detectArchitecture(cwd) {
   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 (fs21.existsSync(path20.join(cwd, "yarn.lock"))) pm = "yarn";
@@ -3717,6 +3795,93 @@ ${archItems.join("\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",
@@ -3724,6 +3889,12 @@ ${archItems.join("\n")}
     ".kody/memory/architecture.md",
     ".kody/memory/conventions.md"
   ].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" });

package/package.json

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

package/dist/agent-runner.d.ts

@@ -1,4 +0,0 @@
-import type { AgentRunner } from "./types.js";
-import type { KodyConfig } from "./config.js";
-export declare function createClaudeCodeRunner(): AgentRunner;
-export declare function createRunners(config: KodyConfig): Record<string, AgentRunner>;

package/dist/agent-runner.js

@@ -1,122 +0,0 @@
-import { spawn, execFileSync } from "child_process";
-const SIGKILL_GRACE_MS = 5000;
-const STDERR_TAIL_CHARS = 500;
-function writeStdin(child, prompt) {
-    return new Promise((resolve, reject) => {
-        if (!child.stdin) {
-            resolve();
-            return;
-        }
-        child.stdin.write(prompt, (err) => {
-            if (err)
-                reject(err);
-            else {
-                child.stdin.end();
-                resolve();
-            }
-        });
-    });
-}
-function waitForProcess(child, timeout) {
-    return new Promise((resolve) => {
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        child.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
-        child.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
-        const timer = setTimeout(() => {
-            child.kill("SIGTERM");
-            setTimeout(() => {
-                if (!child.killed)
-                    child.kill("SIGKILL");
-            }, SIGKILL_GRACE_MS);
-        }, timeout);
-        child.on("exit", (code) => {
-            clearTimeout(timer);
-            resolve({
-                code,
-                stdout: Buffer.concat(stdoutChunks).toString(),
-                stderr: Buffer.concat(stderrChunks).toString(),
-            });
-        });
-        child.on("error", (err) => {
-            clearTimeout(timer);
-            resolve({ code: -1, stdout: "", stderr: err.message });
-        });
-    });
-}
-async function runSubprocess(command, args, prompt, timeout, options) {
-    const child = spawn(command, args, {
-        cwd: options?.cwd ?? process.cwd(),
-        env: {
-            ...process.env,
-            SKIP_BUILD: "1",
-            SKIP_HOOKS: "1",
-            ...options?.env,
-        },
-        stdio: ["pipe", "pipe", "pipe"],
-    });
-    try {
-        await writeStdin(child, prompt);
-    }
-    catch (err) {
-        return {
-            outcome: "failed",
-            error: `Failed to send prompt: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    const { code, stdout, stderr } = await waitForProcess(child, timeout);
-    if (code === 0) {
-        return { outcome: "completed", output: stdout };
-    }
-    return {
-        outcome: code === null ? "timed_out" : "failed",
-        error: `Exit code ${code}\n${stderr.slice(-STDERR_TAIL_CHARS)}`,
-    };
-}
-function checkCommand(command, args) {
-    try {
-        execFileSync(command, args, { timeout: 10_000, stdio: "pipe" });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// ─── Claude Code Runner ──────────────────────────────────────────────────────
-export function createClaudeCodeRunner() {
-    return {
-        async run(_stageName, prompt, model, timeout, _taskDir, options) {
-            return runSubprocess("claude", [
-                "--print",
-                "--model", model,
-                "--dangerously-skip-permissions",
-                "--allowedTools", "Bash,Edit,Read,Write,Glob,Grep",
-            ], prompt, timeout, options);
-        },
-        async healthCheck() {
-            return checkCommand("claude", ["--version"]);
-        },
-    };
-}
-// ─── Runner Factory ──────────────────────────────────────────────────────────
-const RUNNER_FACTORIES = {
-    "claude-code": createClaudeCodeRunner,
-};
-export function createRunners(config) {
-    // New multi-runner config
-    if (config.agent.runners && Object.keys(config.agent.runners).length > 0) {
-        const runners = {};
-        for (const [name, runnerConfig] of Object.entries(config.agent.runners)) {
-            const factory = RUNNER_FACTORIES[runnerConfig.type];
-            if (factory) {
-                runners[name] = factory();
-            }
-        }
-        return runners;
-    }
-    // Legacy single-runner fallback
-    const runnerType = config.agent.runner ?? "claude-code";
-    const factory = RUNNER_FACTORIES[runnerType];
-    const defaultName = config.agent.defaultRunner ?? "claude";
-    return { [defaultName]: factory ? factory() : createClaudeCodeRunner() };
-}

package/dist/ci/parse-inputs.d.ts

@@ -1,6 +0,0 @@
-/**
- * Parses @kody / /kody comment body into structured inputs.
- * Run by the parse job in GitHub Actions.
- * Reads from env, writes to $GITHUB_OUTPUT.
- */
-export {};

package/dist/ci/parse-inputs.js

@@ -1,76 +0,0 @@
-/**
- * Parses @kody / /kody comment body into structured inputs.
- * Run by the parse job in GitHub Actions.
- * Reads from env, writes to $GITHUB_OUTPUT.
- */
-import * as fs from "fs";
-const outputFile = process.env.GITHUB_OUTPUT;
-const triggerType = process.env.TRIGGER_TYPE ?? "dispatch";
-function output(key, value) {
-    if (outputFile) {
-        fs.appendFileSync(outputFile, `${key}=${value}\n`);
-    }
-    console.log(`${key}=${value}`);
-}
-// For workflow_dispatch, pass through inputs
-if (triggerType === "dispatch") {
-    output("task_id", process.env.INPUT_TASK_ID ?? "");
-    output("mode", process.env.INPUT_MODE ?? "full");
-    output("from_stage", process.env.INPUT_FROM_STAGE ?? "");
-    output("issue_number", process.env.INPUT_ISSUE_NUMBER ?? "");
-    output("feedback", process.env.INPUT_FEEDBACK ?? "");
-    output("valid", process.env.INPUT_TASK_ID ? "true" : "false");
-    output("trigger_type", "dispatch");
-    process.exit(0);
-}
-// For issue_comment, parse the comment body
-const commentBody = process.env.COMMENT_BODY ?? "";
-const issueNumber = process.env.ISSUE_NUMBER ?? "";
-// Match: @kody [mode] [task-id] [--from stage] [--feedback "text"]
-const kodyMatch = commentBody.match(/(?:@kody|\/kody)\s*(.*)/i);
-if (!kodyMatch) {
-    output("valid", "false");
-    output("trigger_type", "comment");
-    process.exit(0);
-}
-const parts = kodyMatch[1].trim().split(/\s+/);
-const validModes = ["full", "rerun", "status"];
-let mode = "full";
-let taskId = "";
-let fromStage = "";
-let feedback = "";
-let i = 0;
-// First arg: mode or task-id
-if (parts[i] && validModes.includes(parts[i])) {
-    mode = parts[i];
-    i++;
-}
-// Second arg: task-id
-if (parts[i] && !parts[i].startsWith("--")) {
-    taskId = parts[i];
-    i++;
-}
-// Named args
-while (i < parts.length) {
-    if (parts[i] === "--from" && parts[i + 1]) {
-        fromStage = parts[i + 1];
-        i += 2;
-    }
-    else if (parts[i] === "--feedback" && parts[i + 1]) {
-        // Collect quoted feedback
-        const rest = parts.slice(i + 1).join(" ");
-        const quoted = rest.match(/^"([^"]*)"/);
-        feedback = quoted ? quoted[1] : parts[i + 1];
-        break;
-    }
-    else {
-        i++;
-    }
-}
-output("task_id", taskId);
-output("mode", mode);
-output("from_stage", fromStage);
-output("issue_number", issueNumber);
-output("feedback", feedback);
-output("valid", taskId ? "true" : "false");
-output("trigger_type", "comment");

package/dist/ci/parse-safety.d.ts

@@ -1,6 +0,0 @@
-/**
- * Validates that a comment trigger is safe to execute.
- * Run by the parse job in GitHub Actions.
- * Reads from env, writes to $GITHUB_OUTPUT.
- */
-export {};

package/dist/ci/parse-safety.js

@@ -1,22 +0,0 @@
-/**
- * Validates that a comment trigger is safe to execute.
- * Run by the parse job in GitHub Actions.
- * Reads from env, writes to $GITHUB_OUTPUT.
- */
-import * as fs from "fs";
-const ALLOWED_ASSOCIATIONS = ["COLLABORATOR", "MEMBER", "OWNER"];
-const association = process.env.COMMENT_AUTHOR_ASSOCIATION ?? "";
-const outputFile = process.env.GITHUB_OUTPUT;
-function output(key, value) {
-    if (outputFile) {
-        fs.appendFileSync(outputFile, `${key}=${value}\n`);
-    }
-    console.log(`${key}=${value}`);
-}
-if (!ALLOWED_ASSOCIATIONS.includes(association)) {
-    output("valid", "false");
-    output("reason", `Author association '${association}' not in allowlist: ${ALLOWED_ASSOCIATIONS.join(", ")}`);
-    process.exit(0);
-}
-output("valid", "true");
-output("reason", "");

package/dist/cli/args.d.ts

@@ -1,13 +0,0 @@
-export interface CliInput {
-    command: "run" | "rerun" | "fix" | "status";
-    taskId?: string;
-    task?: string;
-    fromStage?: string;
-    dryRun?: boolean;
-    cwd?: string;
-    issueNumber?: number;
-    feedback?: string;
-    local?: boolean;
-    complexity?: "low" | "medium" | "high";
-}
-export declare function parseArgs(): CliInput;

package/dist/cli/args.js

@@ -1,42 +0,0 @@
-const isCI = !!process.env.GITHUB_ACTIONS;
-function getArg(args, flag) {
-    const idx = args.indexOf(flag);
-    if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith("--")) {
-        return args[idx + 1];
-    }
-    return undefined;
-}
-function hasFlag(args, flag) {
-    return args.includes(flag);
-}
-export function parseArgs() {
-    const args = process.argv.slice(2);
-    if (hasFlag(args, "--help") || hasFlag(args, "-h") || args.length === 0) {
-        console.log(`Usage:
-  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 status --task-id <id> [--cwd <path>]
-  kody --help`);
-        process.exit(0);
-    }
-    const command = args[0];
-    if (!["run", "rerun", "fix", "status"].includes(command)) {
-        console.error(`Unknown command: ${command}`);
-        process.exit(1);
-    }
-    const issueStr = getArg(args, "--issue-number") ?? process.env.ISSUE_NUMBER;
-    const localFlag = hasFlag(args, "--local");
-    return {
-        command,
-        taskId: getArg(args, "--task-id") ?? process.env.TASK_ID,
-        task: getArg(args, "--task"),
-        fromStage: getArg(args, "--from") ?? process.env.FROM_STAGE,
-        dryRun: hasFlag(args, "--dry-run") || process.env.DRY_RUN === "true",
-        cwd: getArg(args, "--cwd"),
-        issueNumber: issueStr ? parseInt(issueStr, 10) : undefined,
-        feedback: getArg(args, "--feedback") ?? process.env.FEEDBACK,
-        local: localFlag || (!isCI && !hasFlag(args, "--no-local")),
-        complexity: (getArg(args, "--complexity") ?? process.env.COMPLEXITY),
-    };
-}

package/dist/cli/litellm.d.ts

@@ -1,2 +0,0 @@
-export declare function checkLitellmHealth(url: string): Promise<boolean>;
-export declare function tryStartLitellm(url: string, projectDir: string): Promise<ReturnType<typeof import("child_process").spawn> | null>;

package/dist/cli/litellm.js

@@ -1,85 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { execFileSync } from "child_process";
-import { logger } from "../logger.js";
-export async function checkLitellmHealth(url) {
-    try {
-        const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3000) });
-        return response.ok;
-    }
-    catch {
-        return false;
-    }
-}
-export async function tryStartLitellm(url, projectDir) {
-    const configPath = path.join(projectDir, "litellm-config.yaml");
-    if (!fs.existsSync(configPath)) {
-        logger.warn("litellm-config.yaml not found — cannot start proxy");
-        return null;
-    }
-    // Extract port from URL
-    const portMatch = url.match(/:(\d+)/);
-    const port = portMatch ? portMatch[1] : "4000";
-    // Check if litellm is installed
-    try {
-        execFileSync("litellm", ["--version"], { timeout: 5000, stdio: "pipe" });
-    }
-    catch {
-        try {
-            execFileSync("python3", ["-m", "litellm", "--version"], { timeout: 5000, stdio: "pipe" });
-        }
-        catch {
-            logger.warn("litellm not installed (pip install 'litellm[proxy]')");
-            return null;
-        }
-    }
-    logger.info(`Starting LiteLLM proxy on port ${port}...`);
-    // Determine command
-    let cmd;
-    let args;
-    try {
-        execFileSync("litellm", ["--version"], { timeout: 5000, stdio: "pipe" });
-        cmd = "litellm";
-        args = ["--config", configPath, "--port", port];
-    }
-    catch {
-        cmd = "python3";
-        args = ["-m", "litellm", "--config", configPath, "--port", port];
-    }
-    // Load API key env vars from project .env (only *_API_KEY patterns)
-    const dotenvPath = path.join(projectDir, ".env");
-    const dotenvVars = {};
-    if (fs.existsSync(dotenvPath)) {
-        for (const line of fs.readFileSync(dotenvPath, "utf-8").split("\n")) {
-            const match = line.match(/^([A-Z_][A-Z0-9_]*_API_KEY)=(.*)$/);
-            if (match)
-                dotenvVars[match[1]] = match[2];
-        }
-        if (Object.keys(dotenvVars).length > 0) {
-            logger.info(`  Loaded API keys: ${Object.keys(dotenvVars).join(", ")}`);
-        }
-    }
-    const { spawn } = await import("child_process");
-    const child = spawn(cmd, args, {
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: true,
-        env: { ...process.env, ...dotenvVars },
-    });
-    // Capture stderr for debugging
-    let proxyStderr = "";
-    child.stderr?.on("data", (chunk) => { proxyStderr += chunk.toString(); });
-    // Wait for health
-    for (let i = 0; i < 30; i++) {
-        await new Promise((r) => setTimeout(r, 2000));
-        if (await checkLitellmHealth(url)) {
-            logger.info(`LiteLLM proxy ready at ${url}`);
-            return child;
-        }
-    }
-    if (proxyStderr) {
-        logger.warn(`LiteLLM stderr: ${proxyStderr.slice(-1000)}`);
-    }
-    logger.warn("LiteLLM proxy failed to start within 60s");
-    child.kill();
-    return null;
-}

package/dist/cli/task-resolution.d.ts

@@ -1,2 +0,0 @@
-export declare function findLatestTaskForIssue(issueNumber: number, projectDir: string): string | null;
-export declare function generateTaskId(): string;

package/dist/cli/task-resolution.js

@@ -1,41 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { execFileSync } from "child_process";
-export function findLatestTaskForIssue(issueNumber, projectDir) {
-    const tasksDir = path.join(projectDir, ".tasks");
-    if (!fs.existsSync(tasksDir))
-        return null;
-    // Only consider directories (not files)
-    const allDirs = fs.readdirSync(tasksDir, { withFileTypes: true })
-        .filter((d) => d.isDirectory())
-        .map((d) => d.name)
-        .sort()
-        .reverse();
-    // Direct match: tasks starting with issue number
-    const prefix = `${issueNumber}-`;
-    const direct = allDirs.find((d) => d.startsWith(prefix));
-    if (direct)
-        return direct;
-    // Fallback for PR comments: extract issue number from current git branch
-    // Branch format: <issueNum>--<slug> (e.g., 1031--security-8x-route)
-    try {
-        const branch = execFileSync("git", ["branch", "--show-current"], {
-            encoding: "utf-8", cwd: projectDir, timeout: 5000, 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 { /* ignore */ }
-    return null;
-}
-export function generateTaskId() {
-    const now = 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())}`;
-}