@kody-ade/kody-engine-lite 0.1.71 → 0.1.73

package/README.md

@@ -7,25 +7,19 @@
 
 Kody is a 7-stage autonomous SDLC pipeline that runs in GitHub Actions. It uses Claude Code (or any LLM via LiteLLM) to turn issues into production-ready PRs — with quality gates, AI-powered failure diagnosis, risk-based human approval, and shared context between stages.
 
+> **Kody is the only AI coding tool that generates repo-customized prompts.** Every other tool sends the same generic instructions regardless of your codebase. Kody analyzes your repo's patterns, conventions, and gaps — then generates tailored instruction files for every pipeline stage. The AI writes code that looks like it belongs in your project because it was taught *from* your project. [Learn more →](docs/FEATURES.md#repo-aware-step-files-kodysteps)
+
 ## Why Kody?
 
 Most AI coding tools are **autocomplete** (Copilot) or **chat-based** (Cursor, Cline). You still drive. Kody is an **autonomous pipeline** — comment `@kody`, walk away, come back to a PR.
 
-| | Kody | Copilot Workspace | Devin | Cursor Agent |
-|---|---|---|---|---|
-| **Repo-aware instructions** | AI-customized per-stage prompts with your repo's patterns, gaps, and acceptance criteria | Generic prompts | Generic prompts | Generic prompts |
-| **Runs in CI** | GitHub Actions | GitHub Cloud | Devin Cloud | Local IDE |
-| **Fire and forget** | Yes | No — interactive | Partially | No — IDE must be open |
-| **Pipeline stages** | 7 stages with quality gates | Plan → implement | Single agent | Single agent |
-| **Shared sessions** | Stages share Claude Code sessions (no cold starts) | Single conversation | Single conversation | Single conversation |
-| **Risk gate** | Pauses HIGH-risk for human approval | No | No | No |
-| **AI failure diagnosis** | Classifies errors before retry (fixable/infra/abort) | No | No | No |
-| **Incremental codebase improvement** | Step files encode gaps to fix — every task raises quality | No | No | No |
-| **Model flexible** | Any LLM via LiteLLM | GitHub models only | Proprietary | Cursor models |
-| **Open source** | MIT | Proprietary | Proprietary | Proprietary |
-| **Cost** | **Free** with free-tier models (Gemini, etc.) or pay-per-use with any LLM | $10-39/month | $20-500/month | Subscription |
-
-[Full comparison →](docs/COMPARISON.md)
+- **Repo-aware prompts** — auto-generated step files with your repo's patterns, gaps, and acceptance criteria
+- **7 stages with quality gates** — not a single agent conversation
+- **Fire and forget** — runs in GitHub Actions, no IDE required
+- **Any LLM** — route through LiteLLM to use MiniMax, GPT, Gemini, or local models
+- **Free** with free-tier models — no subscriptions, no per-seat pricing
+
+[How Kody compares to Copilot, Devin, Cursor, OpenHands, and others →](docs/COMPARISON.md)
 
 ## Pipeline
 
@@ -147,99 +141,44 @@ Set the `provider` field in `kody.config.json` — Kody auto-generates the LiteL
 
 Add the provider's API key to `.env`:
 ```
-MINIMAX_API_KEY=your-key-here
+ANTHROPIC_COMPATIBLE_API_KEY=your-key-here
 ```
 
-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)
+That's it. Kody auto-starts the LiteLLM proxy and loads API keys from `.env`. For per-tier model control, configure `modelMap` in `kody.config.json`. [Full LiteLLM guide →](docs/LITELLM.md)
 
 ## Commands
 
-### GitHub Comments
-
 | Command | What it does |
 |---------|-------------|
-| `@kody` | Run full pipeline |
+| `@kody` | Run full pipeline on an issue |
 | `@kody approve` | Resume after questions or risk gate |
-| `@kody fix` | Re-run from build stage. Write feedback in the comment body — it gets injected into the build prompt |
+| `@kody fix` | Re-run from build. Reads PR review comments as context |
+| `@kody fix-ci` | Fix failing CI checks (auto-triggered on Kody PRs) |
 | `@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 init [--force]        # Setup repo
+kody-engine-lite run --issue-number 42 --local
 kody-engine-lite fix --issue-number 42 --feedback "Use middleware pattern"
+kody-engine-lite fix-ci --pr-number 42
 kody-engine-lite rerun --issue-number 42 --from verify
-kody-engine-lite status --task-id 42-260327-102254
 ```
 
-## Key Features
-
-### Repo-Aware Step Files (`.kody/steps/`)
-
-**This is what separates Kody from every other AI coding tool.**
-
-Most AI tools send the same generic prompt regardless of whether they're working on a Next.js app, a Go microservice, or a Python ML pipeline. Kody generates **customized instruction files for every pipeline stage**, tailored to your specific repository.
+[Full CLI reference with all flags and options →](docs/CLI.md)
 
-During `kody init`, Kody analyzes your codebase — your frameworks, patterns, conventions, file structure, even your anti-patterns — and produces 6 step files in `.kody/steps/`:
-
-| Step File | What It Controls |
-|-----------|-----------------|
-| `taskify.md` | How tasks are classified and scoped for this repo |
-| `plan.md` | Planning guidelines with your repo's architecture in mind |
-| `build.md` | Coding instructions with your actual patterns as examples |
-| `autofix.md` | How to fix verification failures using your toolchain |
-| `review.md` | Review checklist calibrated to your repo's quality bar |
-| `review-fix.md` | How to address review findings in your codebase |
-
-Each step file contains three repo-specific sections:
-- **Repo Patterns** — real code examples from your codebase (file paths, function signatures, snippets) showing what "good" looks like in your project
-- **Improvement Areas** — gaps, anti-patterns, and inconsistencies the AI should fix when it touches related code (e.g., "collections missing access control", "services not using DI")
-- **Acceptance Criteria** — a concrete checklist that defines "done" for each stage in your specific repo
-
-**Why this matters:**
-- Code produced by Kody **matches your existing patterns** — same naming, same abstractions, same file organization
-- Known gaps get **incrementally fixed** — every task that touches a weak area leaves it better
-- Quality bar is **explicit and auditable** — acceptance criteria are version-controlled in your repo, not hidden in a prompt
-- **You own and customize** the instructions — edit `.kody/steps/build.md` to change how Kody writes code, no engine changes needed
-- Re-run `kody init --force` after major refactors to **regenerate** step files from current state
-
-```
-# Example: .kody/steps/build.md (auto-generated, then customizable)
----
-name: build
-...
----
-<original engine prompt preserved>
-
-## Repo Patterns
-**Collection pattern** (`src/collections/certificates.ts`):
-- Always cast `relationTo` with `as CollectionSlug`
-- Register every new collection in `src/payload.config.ts`
-
-## Improvement Areas
-- Collections missing access control — add `access` guards when touching
-- Run `pnpm payload generate:types` after any schema change
-
-## Acceptance Criteria
-- [ ] `pnpm tsc --noEmit` exits with zero errors
-- [ ] All new collections include explicit access control
-- [ ] User-supplied strings sanitized via `src/security/sanitizers.ts`
-```
-
-### Other Features
+## Key Features
 
-- **Shared Sessions** — stages in the same group share a Claude Code session, eliminating cold-start codebase re-exploration ([details](docs/FEATURES.md#shared-sessions))
-- **Risk Gate** — HIGH-risk tasks pause for human plan approval before building ([details](docs/FEATURES.md#risk-gate))
-- **AI Failure Diagnosis** — classifies errors as fixable/infrastructure/pre-existing/abort before retry ([details](docs/FEATURES.md#ai-powered-failure-diagnosis))
-- **Question Gates** — asks product/architecture questions when the task is unclear ([details](docs/FEATURES.md#question-gates))
-- **Any LLM** — route through LiteLLM to use MiniMax, GPT, Gemini, local models ([setup guide](docs/LITELLM.md))
-- **Retrospective** — analyzes each run, identifies patterns, suggests improvements ([details](docs/FEATURES.md#retrospective-system))
-- **Auto-Learning** — extracts coding conventions from each successful run ([details](docs/FEATURES.md#auto-learning-memory))
+- **[Repo-Aware Step Files](docs/FEATURES.md#repo-aware-step-files-kodysteps)** — auto-generated per-stage instructions grounded in your actual code patterns, gaps, and acceptance criteria. Edit `.kody/steps/*.md` to customize how Kody works in your repo.
+- **[Shared Sessions](docs/FEATURES.md#shared-sessions)** — stages in the same group share a Claude Code session, eliminating cold-start re-exploration
+- **[Risk Gate](docs/FEATURES.md#risk-gate)** — HIGH-risk tasks pause for human approval before building
+- **[AI Failure Diagnosis](docs/FEATURES.md#ai-powered-failure-diagnosis)** — classifies errors (fixable/infrastructure/pre-existing/abort) before retry
+- **[Question Gates](docs/FEATURES.md#question-gates)** — asks product/architecture questions when the task is unclear
+- **[Any LLM](docs/LITELLM.md)** — route through LiteLLM to use MiniMax, GPT, Gemini, local models
+- **[Retrospective](docs/FEATURES.md#retrospective-system)** — analyzes each run, identifies patterns, suggests improvements
+- **[Auto-Learning](docs/FEATURES.md#auto-learning-memory)** — extracts coding conventions from each successful run
+- **[Pattern Discovery](docs/FEATURES.md#pattern-discovery)** — plan stage searches for existing patterns before proposing new approaches
+- **[Decision Memory](docs/FEATURES.md#decision-memory)** — architectural decisions from code reviews are saved and enforced in future tasks
 
 ## Documentation
 
@@ -247,9 +186,10 @@ name: build
 |-----|-------------|
 | [Pipeline](docs/PIPELINE.md) | Stage details, shared sessions, complexity skipping, artifacts |
 | [Bootstrap](docs/BOOTSTRAP.md) | Project memory, step files, labels — what bootstrap generates and when to run it |
-| [Features](docs/FEATURES.md) | Risk gate, diagnosis, sessions, retrospective, auto-learn, labels |
+| [Features](docs/FEATURES.md) | Risk gate, diagnosis, sessions, retrospective, auto-learn, pattern discovery, decision memory, PR feedback |
 | [LiteLLM](docs/LITELLM.md) | Non-Anthropic model setup, auto-start, tested providers |
-| [Configuration](docs/CONFIGURATION.md) | Full config reference, env vars, workflow setup |
+| [CLI](docs/CLI.md) | Full command reference — all flags, env vars, and examples |
+| [Configuration](docs/CONFIGURATION.md) | Config file reference, env vars, workflow setup |
 | [Comparison](docs/COMPARISON.md) | vs Copilot, Devin, Cursor, Cline, OpenHands, SWE-agent |
 | [Architecture](docs/ARCHITECTURE.md) | Source tree, state machine diagram, development guide |
 | [FAQ](docs/FAQ.md) | Common questions about usage, models, security, cost |

package/dist/bin/cli.js

@@ -3400,6 +3400,35 @@ async function checkLitellmHealth(url) {
     return false;
   }
 }
+async function checkModelHealth(baseUrl, apiKey, model = "claude-haiku-4-5") {
+  try {
+    const res = await fetch(`${baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 4,
+        messages: [{ role: "user", content: "Reply with: ok" }]
+      }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      const body2 = await res.text().catch(() => "");
+      return { ok: false, error: `HTTP ${res.status}: ${body2.slice(0, 200)}` };
+    }
+    const body = await res.json();
+    if (!body.content?.[0]?.text) {
+      return { ok: false, error: "Empty response from model" };
+    }
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
 function generateLitellmConfig(provider, modelMap) {
   const apiKeyVar = providerApiKeyEnvVar(provider);
   const entries = ["model_list:"];
@@ -3416,17 +3445,12 @@ function generateLitellmConfig(provider, modelMap) {
   return entries.join("\n") + "\n";
 }
 async function tryStartLitellm(url, projectDir, generatedConfig) {
-  const manualConfigPath = path18.join(projectDir, "litellm-config.yaml");
-  let configPath;
-  if (fs19.existsSync(manualConfigPath)) {
-    configPath = manualConfigPath;
-  } else if (generatedConfig) {
-    configPath = path18.join(os.tmpdir(), "kody-litellm-config.yaml");
-    fs19.writeFileSync(configPath, generatedConfig);
-  } else {
-    logger.warn("litellm-config.yaml not found and no provider configured \u2014 cannot start proxy");
+  if (!generatedConfig) {
+    logger.warn("No provider configured in kody.config.json \u2014 cannot start LiteLLM proxy");
     return null;
   }
+  const configPath = path18.join(os.tmpdir(), "kody-litellm-config.yaml");
+  fs19.writeFileSync(configPath, generatedConfig);
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4000";
   let litellmFound = false;
@@ -3600,6 +3624,25 @@ async function ensureLitellmProxy(config, projectDir) {
   }
   return litellmProcess;
 }
+async function runModelHealthCheck(config) {
+  const usesProxy = needsLitellmProxy(config);
+  const baseUrl = usesProxy ? getLitellmUrl() : "https://api.anthropic.com";
+  const apiKey = usesProxy ? process.env.ANTHROPIC_COMPATIBLE_API_KEY : process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    const keyName = usesProxy ? "ANTHROPIC_COMPATIBLE_API_KEY" : "ANTHROPIC_API_KEY";
+    logger.warn(`Skipping model health check \u2014 ${keyName} not set`);
+    return;
+  }
+  const model = config.agent.modelMap.cheap;
+  logger.info(`Model health check (${model} via ${usesProxy ? "LiteLLM" : "Anthropic"})...`);
+  const result = await checkModelHealth(baseUrl, apiKey, model);
+  if (result.ok) {
+    logger.info("  \u2713 Model responded");
+  } else {
+    logger.error(`  \u2717 Model health check failed: ${result.error}`);
+    process.exit(1);
+  }
+}
 async function main() {
   const input = parseArgs();
   const projectDir = input.cwd ? path20.resolve(input.cwd) : process.cwd();
@@ -3693,6 +3736,7 @@ async function main() {
     }
     const config2 = getProjectConfig();
     const litellmProcess2 = await ensureLitellmProxy(config2, projectDir);
+    await runModelHealthCheck(config2);
     const runners2 = createRunners(config2);
     const defaultRunnerName2 = config2.agent.defaultRunner ?? Object.keys(runners2)[0] ?? "claude";
     const defaultRunner2 = runners2[defaultRunnerName2];
@@ -3825,6 +3869,7 @@ ${input.feedback}`);
   }
   const config = getProjectConfig();
   let litellmProcess = await ensureLitellmProxy(config, projectDir);
+  await runModelHealthCheck(config);
   const cleanupLitellm = () => {
     if (litellmProcess) {
       litellmProcess.kill?.();

package/package.json

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

package/dist/agent-runner.d.ts

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

package/dist/agent-runner.js

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

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

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

package/dist/ci/parse-inputs.js

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

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

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

package/dist/ci/parse-safety.js

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

package/dist/cli/args.d.ts

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

package/dist/cli/args.js

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

package/dist/cli/litellm.d.ts

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