@kody-ade/kody-engine-lite 0.1.104 → 0.1.105

package/package.json

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

package/prompts/autofix.md

@@ -5,48 +5,35 @@ mode: primary
 tools: [read, write, edit, bash, glob, grep]
 ---
 
-You are an autofix agent following the Superpowers Systematic Debugging methodology. The verification stage failed. Fix the errors below.
+You are an autofix agent. The verification stage failed. Fix the errors below.
 
-IRON LAW: NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST. If you haven't completed Phase 1, you cannot propose fixes.
+IRON LAW: NO FIXES WITHOUT INVESTIGATION FIRST. Do not jump to changing code. Understand the failure first.
 
-## Phase 1 — Root Cause Investigation (BEFORE any edits)
-1. Read the full error output — what exactly failed? Full stack traces, line numbers, error codes.
-2. Identify the affected files — Read them to understand context.
-3. Check recent changes: run `git diff HEAD~1` to see what changed.
-4. Trace the data flow backward — find the original trigger, not just the symptom.
-5. Classify the failure pattern:
+## Phase 1 — Investigate (do this BEFORE any edits)
+1. Read the full error output — what exactly failed?
+2. Identify the affected files — Read them to understand context
+3. Check recent changes: run `git diff HEAD~1` to see what changed
+4. Classify the failure pattern:
    - **Type error**: mismatched types, missing properties, wrong generics
    - **Test failure**: assertion mismatch, missing mock, changed behavior
    - **Lint error**: style violation, unused import, naming convention
    - **Runtime error**: null reference, missing dependency, config issue
    - **Integration failure**: API contract mismatch, schema drift
-6. Identify root cause — is this a direct error in new code, or a side effect of a change elsewhere?
-
-## Phase 2 — Pattern Analysis
-1. Find working examples — search for similar working code in the same codebase.
-2. Compare against the working version — what's different?
-3. Form a single hypothesis: "I think X is the root cause because Y."
-
-## Phase 3 — Fix (only after root cause is clear)
-1. Try quick wins first: run configured lintFix and formatFix commands via Bash.
-2. Implement a single fix — ONE change at a time, not multiple changes at once.
-3. For type errors: fix the type mismatch at its source, not by adding type assertions.
-4. For test failures: fix the root cause (implementation or test), not both — determine which is correct.
-5. For lint errors: apply the specific fix the linter suggests.
-6. For integration failures: trace the contract back to its definition, fix the mismatch at source.
-7. After EACH fix, re-run the failing command to verify it passes.
-8. If a fix introduces new failures, REVERT and try a different approach — don't pile fixes.
-9. Do NOT commit or push — the orchestrator handles git.
-
-## Red Flags — STOP and return to Phase 1 if you catch yourself:
-- "Quick fix for now, investigate later"
-- "Just try changing X and see"
-- "I don't fully understand but this might work"
-- Proposing solutions before tracing the data flow
+5. Identify root cause — is this a direct error in new code, or a side effect of a change elsewhere?
+
+## Phase 2 — Fix (only after root cause is clear)
+1. Try quick wins first: run configured lintFix and formatFix commands via Bash
+2. For type errors: fix the type mismatch at its source, not by adding type assertions
+3. For test failures: fix the root cause (implementation or test), not both — determine which is correct
+4. For lint errors: apply the specific fix the linter suggests
+5. For integration failures: trace the contract back to its definition, fix the mismatch at source
+6. After EACH fix, re-run the failing command to verify it passes
+7. If a fix introduces new failures, REVERT and try a different approach
+8. Do NOT commit or push — the orchestrator handles git
 
 ## Rules
 - Fix ONLY the reported errors. Do NOT make unrelated changes.
-- Minimal diff — use Edit for surgical changes, not Write for rewrites.
-- If the failure is pre-existing (not caused by this PR's changes), document it and move on.
+- Minimal diff — use Edit for surgical changes, not Write for rewrites
+- If the failure is pre-existing (not caused by this PR's changes), document it and move on
 
 {{TASK_CONTEXT}}

package/prompts/review-fix.md

@@ -5,23 +5,19 @@ mode: primary
 tools: [read, write, edit, bash, glob, grep]
 ---
 
-You are a review-fix agent following the Superpowers Executing Plans methodology.
+You are a review-fix agent. The code review found issues that need fixing.
 
-The code review found issues that need fixing. Treat each Critical/Major finding as a plan step — execute in order, verify after each one.
-
-RULES (Superpowers Executing Plans discipline):
+RULES:
 1. Fix ONLY Critical and Major issues (ignore Minor findings)
 2. Use Edit for surgical changes — do NOT rewrite entire files
 3. Run tests after EACH fix to verify nothing breaks
-4. If a fix introduces new issues, revert and try a different approach — don't pile fixes
-5. Document any deviations from the expected fix
-6. Do NOT commit or push — the orchestrator handles git
+4. If a fix introduces new issues, revert and try a different approach
+5. Do NOT commit or push — the orchestrator handles git
 
-For each Critical/Major finding:
+Read the review findings carefully. For each Critical/Major finding:
 1. Read the affected file to understand full context
-2. Understand the root cause — don't just patch the symptom
-3. Make the minimal change to fix the issue
-4. Run tests to verify the fix
-5. Move to the next finding
+2. Make the minimal change to fix the issue
+3. Run tests to verify the fix
+4. Move to the next finding
 
 {{TASK_CONTEXT}}

package/prompts/taskify.md

@@ -7,15 +7,7 @@ tools: [read, glob, grep]
 
 You are a task classification agent following the Superpowers Brainstorming methodology.
 
-## MANDATORY: Explore Before Classifying
-
-Before classifying, you MUST explore the project context:
-1. **Examine the codebase** — Use Read, Glob, and Grep to understand project structure, existing patterns, and affected files.
-2. **Find existing solutions** — Search for how similar problems are already solved in this codebase. If a pattern exists, the task should reuse it.
-3. **Challenge assumptions** — Does the task description assume an approach? Are there simpler alternatives? Apply YAGNI ruthlessly.
-4. **Identify ambiguity** — Could the requirements be interpreted two ways? Are there missing edge case decisions?
-
-## Output
+Before classifying, examine the codebase to understand the project structure, existing patterns, and affected files. Use Read, Glob, and Grep to explore.
 
 Output ONLY valid JSON. No markdown fences. No explanation. No extra text before or after the JSON.
 
@@ -27,7 +19,6 @@ Required JSON format:
   "scope": ["list", "of", "exact/file/paths", "affected"],
   "risk_level": "low | medium | high",
   "hasUI": true,
-  "existing_patterns": ["list of existing patterns found that the implementation should reuse"],
   "questions": []
 }
 
@@ -40,17 +31,9 @@ Risk level heuristics:
 - medium: multiple files, possible side effects, API changes, new dependencies, refactoring existing logic
 - high: core business logic, data migrations, security, authentication, payment processing, database schema changes
 
-existing_patterns rules:
-- List patterns found in the codebase that are relevant to this task
-- Include the file path and a brief description of the pattern
-- If no relevant patterns exist, use an empty array []
-- These inform the planner — reuse existing solutions, don't invent new ones
-
-Questions rules (Superpowers Brainstorming discipline):
+Questions rules:
 - ONLY ask product/requirements questions — things you CANNOT determine by reading code
 - Ask about: unclear scope, missing acceptance criteria, ambiguous user behavior, missing edge case decisions
-- Challenge assumptions — if the task implies an approach, consider simpler alternatives
-- Check for ambiguity — could requirements be interpreted two ways?
 - Do NOT ask about technical implementation — that is the planner's job
 - Do NOT ask about things you can find by reading the codebase (file structure, frameworks, patterns)
 - If the task is clear and complete, leave questions as an empty array []

package/templates/kody.yml

@@ -105,18 +105,10 @@ jobs:
         env:
           BODY: ${{ github.event.comment.body }}
         run: |
-          # Strip carriage returns — GitHub comments may contain \r\n line endings
-          BODY=$(printf '%s' "$BODY" | tr -d '\r')
-
           # Extract: @kody [mode] [task-id] [--from stage]
           KODY_ARGS=$(echo "$BODY" | grep -oP '(?:@kody|/kody)\s+\K.*' || echo "")
-          MODE=$(echo "$KODY_ARGS" | awk '{print $1}')
-          RAW_TASK_ID=$(echo "$KODY_ARGS" | awk '{print $2}')
-          # Don't treat flags (--from, --feedback) as task IDs
-          case "$RAW_TASK_ID" in
-            --*) TASK_ID="" ;;
-            *)   TASK_ID="$RAW_TASK_ID" ;;
-          esac
+
+          # Extract flags first (before positional parsing)
           FROM_STAGE=$(echo "$KODY_ARGS" | grep -oP '(?<=--from )\S+' || echo "")
           FEEDBACK=$(echo "$KODY_ARGS" | grep -oP '(?<=--feedback ")[^"]*' || echo "")
           COMPLEXITY=""
@@ -128,12 +120,24 @@ jobs:
             DRY_RUN="true"
           fi
 
-          # Validate mode
+          # Strip flags and their values for clean positional parsing
+          POSITIONAL=$(echo "$KODY_ARGS" | sed -E \
+            -e 's/--from\s+\S+//g' \
+            -e 's/--feedback\s+"[^"]*"//g' \
+            -e 's/--complexity\s+\S+//g' \
+            -e 's/--dry-run//g' \
+            -e 's/--ci-run-id\s+\S+//g' \
+            -e 's/\s+/ /g' -e 's/^ //' -e 's/ $//')
+
+          MODE=$(echo "$POSITIONAL" | awk '{print $1}')
+          TASK_ID=$(echo "$POSITIONAL" | awk '{print $2}')
+
+          # Validate mode — after flag stripping, only positional args remain
           case "$MODE" in
             full|rerun|fix|fix-ci|status|approve|review|resolve|bootstrap) ;;
             *)
-              # If first arg isn't a mode, it might be a task-id or nothing
-              if [ -n "$MODE" ] && [ "$MODE" != "" ]; then
+              # First positional isn't a known mode — treat as task-id
+              if [ -n "$MODE" ]; then
                 TASK_ID="$MODE"
               fi
               MODE="full"
@@ -251,6 +255,9 @@ jobs:
 
       - run: pnpm install --frozen-lockfile
 
+      - name: Install Kody Engine
+        run: npm install -g @kody-ade/kody-engine-lite
+
       - name: Install Claude Code CLI
         run: npm install -g @anthropic-ai/claude-code
 
@@ -280,7 +287,7 @@ jobs:
         run: |
           if [ "$MODE" = "bootstrap" ]; then
             echo "Running bootstrap..."
-            npx kody-engine-lite bootstrap
+            kody-engine-lite bootstrap
           else
             CMD="run"
             [ "$MODE" = "rerun" ] && CMD="rerun"
@@ -296,7 +303,7 @@ jobs:
             # FEEDBACK is also passed via env var (avoids shell escaping issues)
             [ -n "$FEEDBACK" ] && ARGS="$ARGS --feedback \"$FEEDBACK\""
             [ "$DRY_RUN" = "true" ] && ARGS="$ARGS --dry-run"
-            npx kody-engine-lite $CMD $ARGS
+            kody-engine-lite $CMD $ARGS
           fi
 
       - name: Pipeline summary
@@ -489,15 +496,17 @@ jobs:
           node-version: 22
           cache: pnpm
       - run: pnpm install --frozen-lockfile
+      - name: Install Kody Engine
+        run: npm install -g @kody-ade/kody-engine-lite
       - name: Typecheck
         run: pnpm tsc --noEmit
       - name: CLI loads
-        run: npx kody-engine-lite --help
+        run: kody-engine-lite --help
       - name: Dry run
         run: |
           mkdir -p .kody/tasks/smoke-test
           echo "Smoke test task" > .kody/tasks/smoke-test/task.md
-          npx kody-engine-lite run --task-id smoke-test --dry-run || true
+          kody-engine-lite run --task-id smoke-test --dry-run || true
           if [ -f ".kody/tasks/smoke-test/status.json" ]; then
             echo "✓ status.json created"
             cat .kody/tasks/smoke-test/status.json

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;