@kody-ade/kody-engine-lite 0.1.63 → 0.1.65

package/dist/agent-runner.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,122 @@
+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/bin/cli.js

@@ -96,6 +96,9 @@ function createClaudeCodeRunner() {
         "--allowedTools",
         "Bash,Edit,Read,Write,Glob,Grep"
       ];
+      if (options?.mcpConfigJson) {
+        args2.push("--mcp-config", options.mcpConfigJson);
+      }
       if (options?.sessionId) {
         if (options.resumeSession) {
           args2.push("--resume", options.sessionId);
@@ -274,7 +277,8 @@ function getProjectConfig() {
         git: { ...DEFAULT_CONFIG.git, ...raw.git },
         github: { ...DEFAULT_CONFIG.github, ...raw.github },
         agent: { ...DEFAULT_CONFIG.agent, ...raw.agent },
-        contextTiers: raw.contextTiers ? { ...DEFAULT_CONFIG.contextTiers, ...raw.contextTiers } : DEFAULT_CONFIG.contextTiers
+        contextTiers: raw.contextTiers ? { ...DEFAULT_CONFIG.contextTiers, ...raw.contextTiers } : DEFAULT_CONFIG.contextTiers,
+        mcp: raw.mcp ? { enabled: false, servers: {}, stages: ["build", "verify", "review", "review-fix"], ...raw.mcp } : void 0
       };
     } catch {
       logger.warn("kody.config.json is invalid JSON \u2014 using defaults");
@@ -1104,6 +1108,35 @@ var init_context_tiers = __esm({
   }
 });
 
+// src/mcp-config.ts
+function buildMcpConfigJson(mcpConfig) {
+  if (!mcpConfig?.enabled) return void 0;
+  if (Object.keys(mcpConfig.servers).length === 0) return void 0;
+  const config = { mcpServers: {} };
+  const mcpServers = config.mcpServers;
+  for (const [name, server] of Object.entries(mcpConfig.servers)) {
+    mcpServers[name] = {
+      command: server.command,
+      args: server.args ?? [],
+      ...server.env ? { env: server.env } : {}
+    };
+  }
+  return JSON.stringify(config);
+}
+function isMcpEnabledForStage(stageName, mcpConfig) {
+  if (!mcpConfig?.enabled) return false;
+  if (Object.keys(mcpConfig.servers).length === 0) return false;
+  const allowedStages = mcpConfig.stages ?? DEFAULT_MCP_STAGES;
+  return allowedStages.includes(stageName);
+}
+var DEFAULT_MCP_STAGES;
+var init_mcp_config = __esm({
+  "src/mcp-config.ts"() {
+    "use strict";
+    DEFAULT_MCP_STAGES = ["build", "verify", "review", "review-fix"];
+  }
+});
+
 // src/context.ts
 import * as fs5 from "fs";
 import * as path5 from "path";
@@ -1194,18 +1227,132 @@ ${feedback}
   }
   return prompt.replace("{{TASK_CONTEXT}}", context);
 }
+function taskHasUI(taskDir) {
+  const taskJsonPath = path5.join(taskDir, "task.json");
+  if (!fs5.existsSync(taskJsonPath)) return true;
+  try {
+    const taskDef = JSON.parse(fs5.readFileSync(taskJsonPath, "utf-8"));
+    return taskDef.hasUI !== false;
+  } catch {
+    return true;
+  }
+}
+function getDevServerInfo(taskDir) {
+  const config = getProjectConfig();
+  const ds = config.mcp?.devServer;
+  if (!ds) return void 0;
+  return {
+    command: ds.command,
+    url: ds.url,
+    readyPattern: ds.readyPattern ?? "Ready in|compiled|started server|Local:",
+    readyTimeout: ds.readyTimeout ?? 30
+  };
+}
+function getBrowserToolGuidance(stageName, taskDir) {
+  const devServer = getDevServerInfo(taskDir);
+  const devServerBlock = devServer ? `
+### Dev Server Setup (REQUIRED before browsing)
+You MUST start the dev server before using any browser navigation tools:
+\`\`\`bash
+# Start the dev server in the background
+${devServer.command} &
+# Wait for it to be ready (look for "${devServer.readyPattern}" in output)
+sleep 5
+\`\`\`
+The dev server URL is: ${devServer.url}
+After you are done browsing, kill the dev server: \`kill %1 2>/dev/null || true\`` : `
+### Dev Server Setup (REQUIRED before browsing)
+You MUST start the project's dev server before using any browser navigation tools.
+Check package.json for the dev command (usually \`pnpm dev\` or \`npm run dev\`).
+\`\`\`bash
+# Start the dev server in the background
+pnpm dev &
+# Wait for it to be ready
+sleep 5
+\`\`\`
+After you are done browsing, kill the dev server: \`kill %1 2>/dev/null || true\``;
+  if (stageName === "build" || stageName === "review-fix") {
+    return `## Browser Visual Verification (MANDATORY for UI tasks)
+
+This task involves UI changes. You MUST visually verify your implementation using the browser tools.
+${devServerBlock}
+
+### Available Browser Tools
+- \`mcp__playwright__browser_navigate\` \u2014 go to a URL
+- \`mcp__playwright__browser_snapshot\` \u2014 capture accessibility tree (shows all elements, text, roles)
+- \`mcp__playwright__browser_take_screenshot\` \u2014 take a visual screenshot
+- \`mcp__playwright__browser_click\` \u2014 click an element (by text, role, or ref from snapshot)
+- \`mcp__playwright__browser_type\` \u2014 type text into an input field
+- \`mcp__playwright__browser_fill_form\` \u2014 fill multiple form fields at once
+- \`mcp__playwright__browser_hover\` \u2014 hover over an element (test hover states)
+- \`mcp__playwright__browser_select_option\` \u2014 select a dropdown option
+- \`mcp__playwright__browser_press_key\` \u2014 press keyboard keys (Enter, Escape, Tab, etc.)
+- \`mcp__playwright__browser_resize\` \u2014 resize viewport (test responsive layouts)
+- \`mcp__playwright__browser_wait_for\` \u2014 wait for text to appear/disappear
+- \`mcp__playwright__browser_evaluate\` \u2014 run JavaScript on the page
+
+### Verification Steps (DO ALL OF THESE)
+1. Start the dev server (see above)
+2. Use \`browser_navigate\` to go to the affected page(s)
+3. Use \`browser_snapshot\` to capture the page and verify elements are present
+4. **Test interactions**: if the task involves buttons, forms, search, toggles, or any interactive elements \u2014 click them, type into them, and verify the result with another snapshot
+5. If the task mentions responsive behavior, use \`browser_resize\` to test at different widths (e.g., 1200px, 768px, 480px) and take snapshots at each
+6. Kill the dev server when done
+
+Do NOT skip the browser verification. The visual check AND interaction testing are required parts of implementing UI changes.`;
+  }
+  if (stageName === "review") {
+    return `## Browser Visual Verification (MANDATORY for UI review)
+
+This task involves UI changes. You MUST visually verify the implementation using the browser tools before giving your verdict.
+${devServerBlock}
+
+### Available Browser Tools
+- \`mcp__playwright__browser_navigate\` \u2014 go to a URL
+- \`mcp__playwright__browser_snapshot\` \u2014 capture accessibility tree (shows all elements, text, roles)
+- \`mcp__playwright__browser_take_screenshot\` \u2014 take a visual screenshot
+- \`mcp__playwright__browser_click\` \u2014 click an element
+- \`mcp__playwright__browser_type\` \u2014 type text into an input
+- \`mcp__playwright__browser_hover\` \u2014 hover over an element
+- \`mcp__playwright__browser_resize\` \u2014 resize viewport
+- \`mcp__playwright__browser_wait_for\` \u2014 wait for text to appear/disappear
+
+### Review Verification Steps (DO ALL OF THESE)
+1. Start the dev server (see above)
+2. Use \`browser_navigate\` to go to the affected page(s)
+3. Use \`browser_snapshot\` to verify elements, layout, and text content
+4. **Test interactions**: click buttons, fill forms, test search \u2014 verify the UI responds correctly
+5. If the task mentions responsive behavior, use \`browser_resize\` to test at different widths
+6. Include your browser verification findings in the review (what you saw, what you interacted with, what worked/failed)
+7. Kill the dev server when done
+
+Do NOT skip the browser verification. A review of UI changes without visual AND interaction verification is incomplete.`;
+  }
+  return `## Browser Tools Available
+
+You have access to Playwright MCP browser tools for visual verification.
+${devServerBlock}
+
+Use browser tools to navigate to pages and take snapshots to verify UI output.`;
+}
 function buildFullPrompt(stageName, taskId, taskDir, projectDir, feedback) {
   const config = getProjectConfig();
+  let assembled;
   if (config.contextTiers?.enabled) {
-    return buildFullPromptTiered(stageName, taskId, taskDir, projectDir, feedback);
-  }
-  const memory = readProjectMemory(projectDir);
-  const promptTemplate = readPromptFile(stageName, projectDir);
-  const prompt = injectTaskContext(promptTemplate, taskId, taskDir, feedback);
-  return memory ? `${memory}
+    assembled = buildFullPromptTiered(stageName, taskId, taskDir, projectDir, feedback);
+  } else {
+    const memory = readProjectMemory(projectDir);
+    const promptTemplate = readPromptFile(stageName, projectDir);
+    const prompt = injectTaskContext(promptTemplate, taskId, taskDir, feedback);
+    assembled = memory ? `${memory}
 ---
 
 ${prompt}` : prompt;
+  }
+  if (isMcpEnabledForStage(stageName, config.mcp) && taskHasUI(taskDir)) {
+    assembled = assembled + "\n\n" + getBrowserToolGuidance(stageName, taskDir);
+  }
+  return assembled;
 }
 function buildFullPromptTiered(stageName, taskId, taskDir, projectDir, feedback) {
   const config = getProjectConfig();
@@ -1241,6 +1388,7 @@ var init_context = __esm({
     init_memory();
     init_config();
     init_context_tiers();
+    init_mcp_config();
     DEFAULT_MODEL_MAP = {
       cheap: "haiku",
       mid: "sonnet",
@@ -1365,11 +1513,16 @@ async function executeAgentStage(ctx, def) {
   if (sessionInfo) {
     logger.info(`  session: ${SESSION_GROUP[def.name]} (${sessionInfo.resumeSession ? "resume" : "new"})`);
   }
+  const mcpConfigJson = isMcpEnabledForStage(def.name, config.mcp) ? buildMcpConfigJson(config.mcp) : void 0;
+  if (mcpConfigJson) {
+    logger.info(`  MCP servers enabled for ${def.name}`);
+  }
   const runner = getRunnerForStage(ctx, def.name);
   const result = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
     cwd: ctx.projectDir,
     env: extraEnv,
-    ...sessionInfo
+    ...sessionInfo,
+    mcpConfigJson
   });
   if (result.outcome !== "completed") {
     return { outcome: result.outcome, error: result.error, retries: 0 };
@@ -1447,6 +1600,7 @@ var init_agent = __esm({
     init_context();
     init_validators();
     init_config();
+    init_mcp_config();
     init_runner_selection();
     init_logger();
     SESSION_GROUP = {

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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,76 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,22 @@
+/**
+ * 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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,85 @@
+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

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

package/dist/cli/task-resolution.js

@@ -0,0 +1,41 @@
+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())}`;
+}