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

package/dist/bin/cli.js

@@ -3911,7 +3911,7 @@ function buildConfig(cwd, basic) {
     }
     return "";
   };
-  return {
+  const config = {
     "$schema": "https://raw.githubusercontent.com/aharonyaircohen/Kody-Engine-Lite/main/kody.config.schema.json",
     quality: {
       typecheck: find("typecheck", "type-check") || (pkg.devDependencies?.typescript ? `${basic.pm} tsc --noEmit` : ""),
@@ -3927,6 +3927,37 @@ function buildConfig(cwd, basic) {
       modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
     }
   };
+  const mcp = detectMcpConfig(cwd, basic.pm, pkg);
+  if (mcp) config.mcp = mcp;
+  return config;
+}
+var FRONTEND_DEPS = ["next", "react", "vue", "svelte", "nuxt", "astro", "solid-js", "angular", "@angular/core"];
+function detectMcpConfig(cwd, pm, pkg) {
+  const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  const hasFrontend = FRONTEND_DEPS.some((dep) => dep in allDeps);
+  if (!hasFrontend) return void 0;
+  const scripts = pkg.scripts ?? {};
+  const hasDevScript = !!scripts.dev;
+  const isNext = "next" in allDeps || "nuxt" in allDeps;
+  const isVite = "vite" in allDeps;
+  const defaultPort = isNext ? 3e3 : isVite ? 5173 : 3e3;
+  const mcp = {
+    enabled: true,
+    servers: {
+      playwright: {
+        command: "npx",
+        args: ["@playwright/mcp@latest"]
+      }
+    },
+    stages: ["build", "review"]
+  };
+  if (hasDevScript) {
+    mcp.devServer = {
+      command: `${pm} dev`,
+      url: `http://localhost:${defaultPort}`
+    };
+  }
+  return mcp;
 }
 function initCommand(opts) {
   const cwd = process.cwd();
@@ -4170,7 +4201,7 @@ function ghComment(issueNumber, body, cwd) {
   } catch {
   }
 }
-function bootstrapCommand() {
+function bootstrapCommand(opts = { force: false }) {
   const cwd = process.cwd();
   const issueNumber = parseInt(process.env.ISSUE_NUMBER ?? "", 10) || 0;
   console.log(`
@@ -4244,6 +4275,23 @@ ${existingFiles.join(", ")}
   fs22.mkdirSync(memoryDir, { recursive: true });
   const archPath = path21.join(memoryDir, "architecture.md");
   const conventionsPath = path21.join(memoryDir, "conventions.md");
+  const existingArch = fs22.existsSync(archPath) ? fs22.readFileSync(archPath, "utf-8") : "";
+  const existingConv = fs22.existsSync(conventionsPath) ? fs22.readFileSync(conventionsPath, "utf-8") : "";
+  const hasExisting = !!(existingArch || existingConv);
+  const extendInstruction = hasExisting && !opts.force ? `
+## Existing Documentation (EXTEND, do not replace)
+You are UPDATING existing documentation. Follow these rules strictly:
+- PRESERVE all existing sections and content that are still accurate
+- REMOVE only lines that reference files, patterns, or dependencies that no longer exist in the project
+- APPEND new sections or lines for newly discovered patterns, files, or conventions
+- Do NOT rewrite sections that are still correct \u2014 keep them verbatim
+
+### Existing architecture.md:
+${existingArch}
+
+### Existing conventions.md:
+${existingConv}
+` : "";
   const memoryPrompt = `You are analyzing a project to generate documentation for an autonomous SDLC pipeline.
 
 Given this project context, output ONLY a JSON object with EXACTLY this structure:
@@ -4263,7 +4311,7 @@ Rules for conventions (markdown string):
 - Extract actual patterns from the project
 - If CLAUDE.md exists, reference it
 - Keep under 30 lines
-
+${extendInstruction}
 Output ONLY valid JSON. No markdown fences. No explanation.
 
 ${repoContext}`;
@@ -4321,11 +4369,16 @@ ${detected.join("\n")}
       console.log(`  \u2717 ${stage}.md \u2014 template not found in engine`);
       continue;
     }
+    const stepOutputPath = path21.join(stepsDir, `${stage}.md`);
+    if (fs22.existsSync(stepOutputPath) && !opts.force) {
+      console.log(`  \u25CB ${stage}.md \u2014 already exists (use --force to regenerate)`);
+      continue;
+    }
     const defaultPrompt = fs22.readFileSync(templatePath, "utf-8");
     const contextPlaceholder = "{{TASK_CONTEXT}}";
     const placeholderIdx = defaultPrompt.indexOf(contextPlaceholder);
     if (placeholderIdx === -1) {
-      fs22.copyFileSync(templatePath, path21.join(stepsDir, `${stage}.md`));
+      fs22.copyFileSync(templatePath, stepOutputPath);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
       continue;
@@ -4382,12 +4435,12 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
       let cleaned = output.replace(/^```(?:markdown|md)?\s*\n?/, "").replace(/\n?```\s*$/, "");
       cleaned = cleaned.replace(/\n*\{\{TASK_CONTEXT\}\}\s*$/, "").trimEnd();
       const finalPrompt = cleaned + "\n\n" + afterPlaceholder;
-      fs22.writeFileSync(path21.join(stepsDir, `${stage}.md`), finalPrompt);
+      fs22.writeFileSync(stepOutputPath, finalPrompt);
       stepCount++;
       console.log(`  \u2713 ${stage}.md`);
     } catch {
       console.log(`  \u26A0 ${stage}.md \u2014 customization failed, using default template`);
-      fs22.copyFileSync(templatePath, path21.join(stepsDir, `${stage}.md`));
+      fs22.copyFileSync(templatePath, stepOutputPath);
       stepCount++;
     }
   }
@@ -4462,11 +4515,17 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
   } catch {
     console.log("  \u25CB Label creation skipped");
   }
+  console.log("\n\u2500\u2500 Skills \u2500\u2500");
+  const installedSkillPaths = installSkillsForProject(cwd);
   console.log("\n\u2500\u2500 Git \u2500\u2500");
   const filesToCommit = [
     ".kody/memory/architecture.md",
-    ".kody/memory/conventions.md"
+    ".kody/memory/conventions.md",
+    ...installedSkillPaths
   ].filter((f) => fs22.existsSync(path21.join(cwd, f)));
+  if (fs22.existsSync(path21.join(cwd, "skills-lock.json"))) {
+    filesToCommit.push("skills-lock.json");
+  }
   for (const stage of STEP_STAGES) {
     const stepFile = `.kody/steps/${stage}.md`;
     if (fs22.existsSync(path21.join(cwd, stepFile))) {
@@ -4599,12 +4658,101 @@ function detectArchitectureBasic(cwd) {
   }
   return detected;
 }
+var SKILL_MAPPINGS = [
+  {
+    detect: (deps) => "next" in deps,
+    skills: [
+      { package: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices (Vercel)" }
+    ]
+  },
+  {
+    detect: (deps) => "react" in deps && !("next" in deps),
+    skills: [
+      { package: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices (Vercel)" }
+    ]
+  },
+  {
+    detect: (deps) => FRONTEND_DEPS.some((d) => d in deps),
+    skills: [
+      { package: "microsoft/playwright-cli@playwright-cli", label: "Playwright browser automation" }
+    ]
+  }
+];
+function detectSkillsForProject(cwd) {
+  const pkgPath = path21.join(cwd, "package.json");
+  if (!fs22.existsSync(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse(fs22.readFileSync(pkgPath, "utf-8"));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const seen = /* @__PURE__ */ new Set();
+    const skills = [];
+    for (const mapping of SKILL_MAPPINGS) {
+      if (mapping.detect(allDeps)) {
+        for (const skill of mapping.skills) {
+          if (!seen.has(skill.package)) {
+            seen.add(skill.package);
+            skills.push(skill);
+          }
+        }
+      }
+    }
+    return skills;
+  } catch {
+    return [];
+  }
+}
+function installSkillsForProject(cwd) {
+  const skills = detectSkillsForProject(cwd);
+  if (skills.length === 0) {
+    console.log("  \u25CB No skills to install (no frontend framework detected)");
+    return [];
+  }
+  let installedSkills = {};
+  const lockPath = path21.join(cwd, "skills-lock.json");
+  if (fs22.existsSync(lockPath)) {
+    try {
+      const lock = JSON.parse(fs22.readFileSync(lockPath, "utf-8"));
+      installedSkills = lock.skills ?? {};
+    } catch {
+    }
+  }
+  const installedPaths = [];
+  for (const skill of skills) {
+    const skillName = skill.package.split("@").pop() ?? "";
+    if (skillName in installedSkills) {
+      console.log(`  \u25CB ${skill.label} \u2014 already installed`);
+      const agentPath = `.agents/skills/${skillName}`;
+      const claudePath = `.claude/skills/${skillName}`;
+      if (fs22.existsSync(path21.join(cwd, agentPath))) installedPaths.push(agentPath);
+      if (fs22.existsSync(path21.join(cwd, claudePath))) installedPaths.push(claudePath);
+      continue;
+    }
+    try {
+      console.log(`  Installing: ${skill.label} (${skill.package})`);
+      execFileSync11("npx", ["skills", "add", skill.package, "--yes"], {
+        cwd,
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const skillName2 = skill.package.split("@").pop() ?? "";
+      const agentPath = `.agents/skills/${skillName2}`;
+      const claudePath = `.claude/skills/${skillName2}`;
+      if (fs22.existsSync(path21.join(cwd, agentPath))) installedPaths.push(agentPath);
+      if (fs22.existsSync(path21.join(cwd, claudePath))) installedPaths.push(claudePath);
+      console.log(`  \u2713 ${skill.label}`);
+    } catch (err) {
+      console.log(`  \u2717 ${skill.label} \u2014 failed to install`);
+    }
+  }
+  return installedPaths;
+}
 var args = process.argv.slice(2);
 var command = args[0];
 if (command === "init") {
   initCommand({ force: args.includes("--force") });
 } else if (command === "bootstrap") {
-  bootstrapCommand();
+  bootstrapCommand({ force: args.includes("--force") });
 } else if (command === "version" || command === "--version" || command === "-v") {
   console.log(getVersion());
 } else {
@@ -4618,5 +4766,6 @@ export {
   checkGhRepoAccess,
   checkGhSecret,
   detectArchitectureBasic,
-  detectBasicConfig
+  detectBasicConfig,
+  detectSkillsForProject
 };

package/package.json

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

package/templates/kody.yml

@@ -295,10 +295,11 @@ jobs:
       - name: Upload artifacts
         if: always()
         uses: actions/upload-artifact@v4
+        continue-on-error: true
         with:
           name: kody-tasks-${{ github.event.inputs.task_id || needs.parse.outputs.task_id }}
           path: .kody/tasks/
-          retention-days: 7
+          retention-days: 3
 
   # ─── Error Notifications ─────────────────────────────────────────────────────
   notify-parse-error:

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;