@kody-ade/kody-engine-lite 0.1.60 → 0.1.62

package/README.md

@@ -138,23 +138,19 @@ Comment on any GitHub issue:
 
 ### Switch to a different model (optional)
 
-Add `litellm-config.yaml` to route all tiers through MiniMax (or any LLM):
-
-```yaml
-# litellm-config.yaml
-model_list:
-  - model_name: claude-haiku-4-5-20251001
-    litellm_params:
-      model: minimax/MiniMax-M2.7-highspeed
-      api_key: os.environ/MINIMAX_API_KEY
-```
+Set the `provider` field in `kody.config.json` — Kody auto-generates the LiteLLM config, starts the proxy, and routes all stages through your provider:
 
 ```json
-// kody.config.json — add litellmUrl
-{ "agent": { "litellmUrl": "http://localhost:4000" } }
+// kody.config.json — use MiniMax (or any LLM)
+{ "agent": { "provider": "minimax" } }
+```
+
+Add the provider's API key to `.env`:
+```
+MINIMAX_API_KEY=your-key-here
 ```
 
-Kody auto-starts the proxy and loads API keys from `.env`. [Full LiteLLM guide →](docs/LITELLM.md)
+That's it. Kody auto-starts the LiteLLM proxy and loads API keys from `.env`. For advanced routing (different models per tier, custom config), add a `litellm-config.yaml`. [Full LiteLLM guide →](docs/LITELLM.md)
 
 ## Commands
 
@@ -167,16 +163,18 @@ Kody auto-starts the proxy and loads API keys from `.env`. [Full LiteLLM guide
 | `@kody fix` | Re-run from build stage. Write feedback in the comment body — it gets injected into the build prompt |
 | `@kody rerun` | Resume from the failed or paused stage |
 | `@kody rerun --from <stage>` | Resume from a specific stage |
+| `@kody bootstrap` | Regenerate project memory and step files |
 
 ### CLI
 
 ```bash
+kody-engine-lite init [--force]          # Setup repo: workflow, config, memory, step files
+kody-engine-lite bootstrap               # Regenerate memory + step files (runs in GH Actions)
 kody-engine-lite run --issue-number 42 --local --cwd ./project
 kody-engine-lite run --task "Add retry utility" --local
 kody-engine-lite fix --issue-number 42 --feedback "Use middleware pattern"
 kody-engine-lite rerun --issue-number 42 --from verify
 kody-engine-lite status --task-id 42-260327-102254
-kody-engine-lite init [--force]
 ```
 
 ## Key Features

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

@@ -114,17 +114,15 @@ function createRunners(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 factory2 = RUNNER_FACTORIES[runnerConfig.type];
-      if (factory2) {
-        runners[name] = factory2();
+      const factory = RUNNER_FACTORIES[runnerConfig.type];
+      if (factory) {
+        runners[name] = factory();
       }
     }
     return runners;
   }
-  const runnerType = config.agent.runner ?? "claude-code";
-  const factory = RUNNER_FACTORIES[runnerType];
   const defaultName = config.agent.defaultRunner ?? "claude";
-  return { [defaultName]: factory ? factory() : createClaudeCodeRunner() };
+  return { [defaultName]: createClaudeCodeRunner() };
 }
 var SIGKILL_GRACE_MS, STDERR_TAIL_CHARS, RUNNER_FACTORIES;
 var init_agent_runner = __esm({
@@ -253,12 +251,10 @@ var init_logger = __esm({
 import * as fs from "fs";
 import * as path from "path";
 function needsLitellmProxy(config) {
-  if (config.agent.litellmUrl) return true;
-  if (config.agent.provider && config.agent.provider !== "anthropic") return true;
-  return false;
+  return !!(config.agent.provider && config.agent.provider !== "anthropic");
 }
-function getLitellmUrl(config) {
-  return config.agent.litellmUrl ?? LITELLM_DEFAULT_URL;
+function getLitellmUrl() {
+  return LITELLM_DEFAULT_URL;
 }
 function providerApiKeyEnvVar(provider) {
   return `${provider.toUpperCase()}_API_KEY`;
@@ -277,7 +273,6 @@ function getProjectConfig() {
         quality: { ...DEFAULT_CONFIG.quality, ...raw.quality },
         git: { ...DEFAULT_CONFIG.git, ...raw.git },
         github: { ...DEFAULT_CONFIG.github, ...raw.github },
-        paths: { ...DEFAULT_CONFIG.paths, ...raw.paths },
         agent: { ...DEFAULT_CONFIG.agent, ...raw.agent },
         contextTiers: raw.contextTiers ? { ...DEFAULT_CONFIG.contextTiers, ...raw.contextTiers } : DEFAULT_CONFIG.contextTiers
       };
@@ -300,7 +295,6 @@ var init_config = __esm({
         typecheck: "pnpm -s tsc --noEmit",
         lint: "pnpm -s lint",
         lintFix: "pnpm lint:fix",
-        format: "pnpm -s format:check",
         formatFix: "pnpm format:fix",
         testUnit: "pnpm -s test"
       },
@@ -311,12 +305,7 @@ var init_config = __esm({
         owner: "",
         repo: ""
       },
-      paths: {
-        taskDir: ".kody/tasks"
-      },
       agent: {
-        runner: "claude-code",
-        defaultRunner: "claude",
         modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
       },
       contextTiers: {
@@ -1238,9 +1227,6 @@ ${prompt}` : prompt;
 }
 function resolveModel(modelTier, stageName) {
   const config = getProjectConfig();
-  if (config.agent.usePerStageRouting && stageName) {
-    return stageName;
-  }
   if (config.agent.provider && config.agent.provider !== "anthropic") {
     return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
   }
@@ -1372,7 +1358,7 @@ async function executeAgentStage(ctx, def) {
   logger.info(`  runner=${runnerName} model=${model} timeout=${def.timeout / 1e3}s`);
   const extraEnv = {};
   if (needsLitellmProxy(config)) {
-    extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl(config);
+    extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl();
   }
   const sessions = ctx.sessions ?? {};
   const sessionInfo = getSessionInfo(def.name, sessions);
@@ -1751,8 +1737,8 @@ async function executeVerifyWithAutofix(ctx, def) {
       const defaultRunner = getRunnerForStage(ctx, "taskify");
       const diagConfig = getProjectConfig();
       const diagEnv = {};
-      if (diagConfig.agent.litellmUrl) {
-        diagEnv.ANTHROPIC_BASE_URL = diagConfig.agent.litellmUrl;
+      if (needsLitellmProxy(diagConfig)) {
+        diagEnv.ANTHROPIC_BASE_URL = getLitellmUrl();
       }
       const diagnosis = await diagnoseFailure(
         "verify",
@@ -2047,7 +2033,14 @@ Updated existing PR: ${existingPr.url}
 PR #${existingPr.number}
 `);
     } else {
-      const pr = createPR(head, base, title, body);
+      let pr = createPR(head, base, title, body);
+      if (!pr) {
+        const recovered = getPRForBranch(head);
+        if (recovered) {
+          logger.info(`  PR recovered after create error: ${recovered.url}`);
+          pr = recovered;
+        }
+      }
       if (pr) {
         if (ctx.input.issueNumber && !ctx.input.local) {
           try {
@@ -2537,8 +2530,8 @@ ${previousText}
     const model = resolveModel("cheap");
     const config = getProjectConfig();
     const extraEnv = {};
-    if (config.agent.litellmUrl) {
-      extraEnv.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
+    if (needsLitellmProxy(config)) {
+      extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl();
     }
     const result = await runner.run("retrospective", prompt, model, 3e4, "", {
       cwd: ctx.projectDir,
@@ -3274,7 +3267,7 @@ import * as fs21 from "fs";
 import * as path20 from "path";
 async function ensureLitellmProxy(config, projectDir) {
   if (!needsLitellmProxy(config)) return null;
-  const litellmUrl = getLitellmUrl(config);
+  const litellmUrl = getLitellmUrl();
   const proxyRunning = await checkLitellmHealth(litellmUrl);
   let litellmProcess = null;
   if (!proxyRunning) {
@@ -3770,16 +3763,13 @@ function buildConfig(cwd, basic) {
       typecheck: find("typecheck", "type-check") || (pkg.devDependencies?.typescript ? `${basic.pm} tsc --noEmit` : ""),
       lint: find("lint"),
       lintFix: find("lint:fix", "lint-fix"),
-      format: find("format:check"),
       formatFix: find("format", "format:fix"),
       testUnit: find("test:unit", "test", "test:ci")
     },
     git: { defaultBranch: basic.defaultBranch },
     github: { owner: basic.owner, repo: basic.repo },
-    paths: { taskDir: ".kody/tasks" },
     agent: {
-      runner: "claude-code",
-      defaultRunner: "claude",
+      provider: "anthropic",
       modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
     }
   };
@@ -3858,55 +3848,8 @@ function initCommand(opts) {
         console.log(`  \u2717 ${c.name} \u2014 ${c.fix}`);
       }
     }
-    const labels = [
-      { name: "kody:planning", color: "c5def5", description: "Kody is analyzing and planning" },
-      { name: "kody:building", color: "0e8a16", description: "Kody is building code" },
-      { name: "kody:review", color: "fbca04", description: "Kody is reviewing code" },
-      { name: "kody:done", color: "0e8a16", description: "Kody completed successfully" },
-      { name: "kody:failed", color: "d93f0b", description: "Kody pipeline failed" },
-      { name: "kody:waiting", color: "fef2c0", description: "Kody is waiting for answers" },
-      { name: "kody:low", color: "bfdadc", description: "Low complexity \u2014 skip plan/review" },
-      { name: "kody:medium", color: "c5def5", description: "Medium complexity \u2014 skip review-fix" },
-      { name: "kody:high", color: "d4c5f9", description: "High complexity \u2014 full pipeline" },
-      { name: "kody:feature", color: "0e8a16", description: "New feature" },
-      { name: "kody:bugfix", color: "d93f0b", description: "Bug fix" },
-      { name: "kody:refactor", color: "fbca04", description: "Code refactoring" },
-      { name: "kody:docs", color: "0075ca", description: "Documentation" },
-      { name: "kody:chore", color: "e4e669", description: "Maintenance task" }
-    ];
     console.log("\n\u2500\u2500 Labels \u2500\u2500");
-    for (const label of labels) {
-      try {
-        execFileSync11("gh", [
-          "label",
-          "create",
-          label.name,
-          "--repo",
-          repoSlug,
-          "--color",
-          label.color,
-          "--description",
-          label.description,
-          "--force"
-        ], {
-          encoding: "utf-8",
-          timeout: 1e4,
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        console.log(`  \u2713 ${label.name}`);
-      } catch {
-        try {
-          execFileSync11("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
-            encoding: "utf-8",
-            timeout: 1e4,
-            stdio: ["pipe", "pipe", "pipe"]
-          });
-          console.log(`  \u25CB ${label.name} (exists)`);
-        } catch {
-          console.log(`  \u2717 ${label.name} \u2014 failed to create`);
-        }
-      }
-    }
+    console.log("  \u25CB Labels will be created automatically during bootstrap");
   }
   console.log("\n\u2500\u2500 Config \u2500\u2500");
   if (fs22.existsSync(configDest)) {
@@ -4295,6 +4238,76 @@ REMINDER: Output the full prompt template first (unchanged), then your three app
     }
   }
   console.log(`  \u2713 Generated ${stepCount} step files in .kody/steps/`);
+  console.log("\n\u2500\u2500 Labels \u2500\u2500");
+  try {
+    let repoSlug = "";
+    try {
+      const configPath = path21.join(cwd, "kody.config.json");
+      if (fs22.existsSync(configPath)) {
+        const config = JSON.parse(fs22.readFileSync(configPath, "utf-8"));
+        if (config.github?.owner && config.github?.repo) {
+          repoSlug = `${config.github.owner}/${config.github.repo}`;
+        }
+      }
+    } catch {
+    }
+    if (repoSlug) {
+      const labels = [
+        { name: "kody:planning", color: "c5def5", description: "Kody is analyzing and planning" },
+        { name: "kody:building", color: "0e8a16", description: "Kody is building code" },
+        { name: "kody:review", color: "fbca04", description: "Kody is reviewing code" },
+        { name: "kody:done", color: "0e8a16", description: "Kody completed successfully" },
+        { name: "kody:failed", color: "d93f0b", description: "Kody pipeline failed" },
+        { name: "kody:waiting", color: "fef2c0", description: "Kody is waiting for answers" },
+        { name: "kody:low", color: "bfdadc", description: "Low complexity \u2014 skip plan/review" },
+        { name: "kody:medium", color: "c5def5", description: "Medium complexity \u2014 skip review-fix" },
+        { name: "kody:high", color: "d4c5f9", description: "High complexity \u2014 full pipeline" },
+        { name: "kody:feature", color: "0e8a16", description: "New feature" },
+        { name: "kody:bugfix", color: "d93f0b", description: "Bug fix" },
+        { name: "kody:refactor", color: "fbca04", description: "Code refactoring" },
+        { name: "kody:docs", color: "0075ca", description: "Documentation" },
+        { name: "kody:chore", color: "e4e669", description: "Maintenance task" }
+      ];
+      for (const label of labels) {
+        try {
+          execFileSync11("gh", [
+            "label",
+            "create",
+            label.name,
+            "--repo",
+            repoSlug,
+            "--color",
+            label.color,
+            "--description",
+            label.description,
+            "--force"
+          ], {
+            cwd,
+            encoding: "utf-8",
+            timeout: 1e4,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          console.log(`  \u2713 ${label.name}`);
+        } catch {
+          try {
+            execFileSync11("gh", ["label", "list", "--repo", repoSlug, "--search", label.name], {
+              cwd,
+              encoding: "utf-8",
+              timeout: 1e4,
+              stdio: ["pipe", "pipe", "pipe"]
+            });
+            console.log(`  \u25CB ${label.name} (exists)`);
+          } catch {
+            console.log(`  \u2717 ${label.name} \u2014 failed to create`);
+          }
+        }
+      }
+    } else {
+      console.log("  \u25CB Skipped \u2014 could not determine repo from kody.config.json");
+    }
+  } catch {
+    console.log("  \u25CB Label creation skipped");
+  }
   console.log("\n\u2500\u2500 Git \u2500\u2500");
   const filesToCommit = [
     ".kody/memory/architecture.md",

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>;