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

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

@@ -679,6 +679,45 @@ function submitPRReview(prNumber, body, event) {
     logger.warn(`  Failed to submit PR review: ${err}`);
   }
 }
+function getCIFailureLogs(runId, maxLength = 8e3) {
+  try {
+    const logsOutput = gh([
+      "run",
+      "view",
+      String(runId),
+      "--log-failed"
+    ]);
+    if (!logsOutput) return null;
+    const truncated = logsOutput.slice(-maxLength);
+    const prefix = logsOutput.length > maxLength ? "...(earlier output truncated)\n" : "";
+    return `${prefix}${truncated}`;
+  } catch (err) {
+    logger.warn(`  Failed to get CI failure logs for run ${runId}: ${err}`);
+    return null;
+  }
+}
+function getLatestFailedRunForBranch(branch) {
+  try {
+    const output = gh([
+      "run",
+      "list",
+      "--branch",
+      branch,
+      "--status",
+      "failure",
+      "--limit",
+      "1",
+      "--json",
+      "databaseId",
+      "--jq",
+      ".[0].databaseId"
+    ]);
+    return output.trim() || null;
+  } catch (err) {
+    logger.warn(`  Failed to get latest failed run for branch ${branch}: ${err}`);
+    return null;
+  }
+}
 function getLatestKodyReviewComment(prNumber) {
   try {
     const output = gh([
@@ -693,13 +732,80 @@ function getLatestKodyReviewComment(prNumber) {
     return null;
   }
 }
-var API_TIMEOUT_MS, LIFECYCLE_LABELS, _ghCwd;
+function getPRFeedbackSinceLastKodyAction(prNumber) {
+  try {
+    const issueCommentsRaw = gh([
+      "api",
+      `repos/{owner}/{repo}/issues/${prNumber}/comments`,
+      "--jq",
+      "[.[] | {body, created_at, user_login: .user.login, user_type: .user.type}]"
+    ]);
+    const issueComments = issueCommentsRaw ? JSON.parse(issueCommentsRaw) : [];
+    const reviewCommentsRaw = gh([
+      "api",
+      `repos/{owner}/{repo}/pulls/${prNumber}/comments`,
+      "--jq",
+      "[.[] | {body, created_at, user_login: .user.login, user_type: .user.type, path, line}]"
+    ]);
+    const reviewComments = reviewCommentsRaw ? JSON.parse(reviewCommentsRaw) : [];
+    const kodyTimestamp = findLastKodyActionTimestamp(issueComments);
+    const humanIssueComments = issueComments.filter(
+      (c) => !isKodyComment(c) && (!kodyTimestamp || c.created_at > kodyTimestamp)
+    );
+    const humanReviewComments = reviewComments.filter(
+      (c) => !isKodyComment(c) && (!kodyTimestamp || c.created_at > kodyTimestamp)
+    );
+    if (humanIssueComments.length === 0 && humanReviewComments.length === 0) {
+      return null;
+    }
+    const parts = [];
+    if (humanIssueComments.length > 0) {
+      parts.push("### PR Comments");
+      for (const c of humanIssueComments) {
+        parts.push(`**@${c.user_login}:**
+${c.body}`);
+      }
+    }
+    if (humanReviewComments.length > 0) {
+      parts.push("### Code Review Comments");
+      for (const c of humanReviewComments) {
+        const location = c.path ? `\`${c.path}${c.line ? `:${c.line}` : ""}\`` : "";
+        parts.push(`**@${c.user_login}** ${location}:
+${c.body}`);
+      }
+    }
+    return parts.join("\n\n");
+  } catch (err) {
+    logger.warn(`  Failed to get PR feedback for #${prNumber}: ${err}`);
+    return null;
+  }
+}
+function isKodyComment(comment) {
+  if (comment.user_type === "Bot") return true;
+  return KODY_MARKERS.some((marker) => comment.body.includes(marker));
+}
+function findLastKodyActionTimestamp(comments) {
+  const kodyComments = comments.filter(isKodyComment);
+  if (kodyComments.length === 0) return null;
+  return kodyComments[kodyComments.length - 1].created_at;
+}
+var API_TIMEOUT_MS, LIFECYCLE_LABELS, _ghCwd, KODY_MARKERS;
 var init_github_api = __esm({
   "src/github-api.ts"() {
     "use strict";
     init_logger();
     API_TIMEOUT_MS = 3e4;
     LIFECYCLE_LABELS = ["planning", "building", "review", "done", "failed", "waiting", "low", "medium", "high"];
+    KODY_MARKERS = [
+      "Kody Review",
+      "\u{1F916} Generated by Kody",
+      "Kody pipeline started",
+      "Fix pushed to PR",
+      "PR created:",
+      "Pipeline failed at",
+      "Pipeline already running",
+      "already completed"
+    ];
   }
 });
 
@@ -2496,6 +2602,7 @@ ${learnings.join("\n")}
       invalidateCache(conventionsPath, path13.join(memoryDir, ".tiers"));
       logger.info(`Auto-learned ${learnings.length} convention(s)`);
     }
+    autoLearnDecisions(ctx.taskDir, memoryDir, ctx.taskId, timestamp2);
     autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp2);
   } catch {
   }
@@ -2560,6 +2667,45 @@ ${detected.join("\n")}
     logger.info(`Auto-detected architecture (${detected.length} items)`);
   }
 }
+function autoLearnDecisions(taskDir, memoryDir, taskId, timestamp2) {
+  const reviewPath = path13.join(taskDir, "review.md");
+  if (!fs13.existsSync(reviewPath)) return;
+  const review = fs13.readFileSync(reviewPath, "utf-8");
+  const decisions = [];
+  const existingPatternRe = /(?:use|follow|reuse|match|adopt)\s+(?:the\s+)?existing\s+(.+?)(?:\.|$)/gim;
+  for (const match of review.matchAll(existingPatternRe)) {
+    decisions.push(`- Use existing ${match[1].trim()}`);
+  }
+  const insteadOfRe = /instead\s+of\s+(.+?),?\s+(?:use|prefer|adopt)\s+(.+?)(?:\.|$)/gim;
+  for (const match of review.matchAll(insteadOfRe)) {
+    decisions.push(`- Prefer ${match[2].trim()} over ${match[1].trim()}`);
+  }
+  const consistentRe = /(?:consistent\s+with|same\s+pattern\s+as|follow\s+the\s+pattern\s+(?:in|from))\s+(.+?)(?:\.|$)/gim;
+  for (const match of review.matchAll(consistentRe)) {
+    decisions.push(`- Follow pattern from ${match[1].trim()}`);
+  }
+  const avoidRe = /(?:don't|do\s+not|never|avoid)\s+(?:use\s+)?(.+?)\s+(?:for|when|in)\s+(.+?)(?:\.|$)/gim;
+  for (const match of review.matchAll(avoidRe)) {
+    decisions.push(`- Avoid ${match[1].trim()} for ${match[2].trim()}`);
+  }
+  if (decisions.length === 0) return;
+  const decisionsPath = path13.join(memoryDir, "decisions.md");
+  let existing = "";
+  if (fs13.existsSync(decisionsPath)) {
+    existing = fs13.readFileSync(decisionsPath, "utf-8");
+  } else {
+    existing = "# Architectural Decisions\n\nDecisions extracted from code reviews. The planning agent MUST follow these.\n";
+  }
+  const newDecisions = decisions.filter((d) => !existing.includes(d));
+  if (newDecisions.length === 0) return;
+  const entry = `
+## From task ${taskId} (${timestamp2})
+${newDecisions.join("\n")}
+`;
+  fs13.appendFileSync(decisionsPath, existing ? entry : existing + entry);
+  invalidateCache(decisionsPath, path13.join(memoryDir, ".tiers"));
+  logger.info(`Auto-learned ${newDecisions.length} architectural decision(s)`);
+}
 var init_auto_learn = __esm({
   "src/learning/auto-learn.ts"() {
     "use strict";
@@ -3203,13 +3349,14 @@ function parseArgs() {
   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 fix-ci [--pr-number <n>] [--ci-run-id <id>] [--cwd <path>] [--issue-number <n>] [--feedback "<text>"]
   kody review [--pr-number <n>] [--issue-number <n>] [--cwd <path>] [--local]
   kody status --task-id <id> [--cwd <path>]
   kody --help`);
     process.exit(0);
   }
   const command2 = args2[0];
-  if (!["run", "rerun", "fix", "status", "review"].includes(command2)) {
+  if (!["run", "rerun", "fix", "fix-ci", "status", "review"].includes(command2)) {
     console.error(`Unknown command: ${command2}`);
     process.exit(1);
   }
@@ -3227,7 +3374,8 @@ function parseArgs() {
     prNumber: prStr ? parseInt(prStr, 10) : void 0,
     feedback: getArg(args2, "--feedback") ?? process.env.FEEDBACK,
     local: localFlag || !isCI2 && !hasFlag(args2, "--no-local"),
-    complexity: getArg(args2, "--complexity") ?? process.env.COMPLEXITY
+    complexity: getArg(args2, "--complexity") ?? process.env.COMPLEXITY,
+    ciRunId: getArg(args2, "--ci-run-id") ?? process.env.CI_RUN_ID
   };
 }
 var isCI2;
@@ -3463,7 +3611,7 @@ async function main() {
     setGhCwd(projectDir);
     logger.info(`Working directory: ${projectDir}`);
   }
-  const isPRFix = input.command === "fix" && !!input.prNumber;
+  const isPRFix = (input.command === "fix" || input.command === "fix-ci") && !!input.prNumber;
   if (input.issueNumber && input.command !== "review" && !isPRFix) {
     const taskAction = resolveForIssue(input.issueNumber, projectDir);
     logger.info(`Task action: ${taskAction.action}`);
@@ -3497,7 +3645,7 @@ async function main() {
   let taskId = input.taskId;
   if (!taskId) {
     if (isPRFix) {
-      taskId = `fix-pr-${input.prNumber}-${generateTaskId()}`;
+      taskId = `${input.command === "fix-ci" ? "fixci" : "fix"}-pr-${input.prNumber}-${generateTaskId()}`;
     } else if (input.issueNumber) {
       taskId = `${input.issueNumber}-${generateTaskId()}`;
     } else if (input.command === "run" && input.task) {
@@ -3615,21 +3763,63 @@ ${issue.body ?? ""}`;
     console.error("No task.md found. Provide --task, --issue-number, or ensure .kody/tasks/<id>/task.md exists.");
     process.exit(1);
   }
-  if (input.command === "fix" && !input.fromStage) {
+  if ((input.command === "fix" || input.command === "fix-ci") && !input.fromStage) {
     input.fromStage = "build";
   }
+  if (input.command === "fix-ci" && input.prNumber) {
+    let ciRunId = input.ciRunId;
+    if (!ciRunId && input.feedback) {
+      const match = input.feedback.match(/Run ID:\s*(\d+)/);
+      ciRunId = match?.[1];
+    }
+    if (!ciRunId) {
+      const prDetails = getPRDetails(input.prNumber);
+      if (prDetails) {
+        ciRunId = getLatestFailedRunForBranch(prDetails.headBranch) ?? void 0;
+      }
+    }
+    if (ciRunId) {
+      const ciLogs = getCIFailureLogs(ciRunId);
+      if (ciLogs) {
+        logger.info(`  Found CI failure logs for run ${ciRunId}, injecting as feedback`);
+        const ciContext = `## CI Failure Logs (run ${ciRunId})
+
+The CI pipeline failed. Fix the code to make CI pass.
+
+\`\`\`
+${ciLogs}
+\`\`\``;
+        input.feedback = input.feedback ? `${ciContext}
+
+## Additional context
+
+${input.feedback}` : ciContext;
+      }
+    }
+  }
   if (input.command === "fix" && input.prNumber) {
+    const feedbackParts = [];
     const reviewComment = getLatestKodyReviewComment(input.prNumber);
     if (reviewComment) {
-      logger.info(`  Found Kody review comment on PR #${input.prNumber}, injecting as feedback`);
-      const reviewContext = `## Review findings from PR #${input.prNumber}
+      logger.info(`  Found Kody review comment on PR #${input.prNumber}`);
+      feedbackParts.push(`## Review findings from PR #${input.prNumber}
 
-${reviewComment}`;
-      input.feedback = input.feedback ? `${reviewContext}
+${reviewComment}`);
+    }
+    const humanFeedback = getPRFeedbackSinceLastKodyAction(input.prNumber);
+    if (humanFeedback) {
+      logger.info(`  Found human feedback on PR #${input.prNumber}`);
+      feedbackParts.push(`## Human review feedback from PR #${input.prNumber}
 
-## Additional feedback
+${humanFeedback}`);
+    }
+    if (input.feedback) {
+      feedbackParts.push(`## Additional feedback
 
-${input.feedback}` : reviewContext;
+${input.feedback}`);
+    }
+    if (feedbackParts.length > 0) {
+      input.feedback = feedbackParts.join("\n\n");
     }
   }
   const config = getProjectConfig();
@@ -3667,7 +3857,7 @@ ${input.feedback}` : reviewContext;
     projectDir,
     runners,
     input: {
-      mode: input.command === "rerun" || input.command === "fix" ? "rerun" : "full",
+      mode: input.command === "rerun" || input.command === "fix" || input.command === "fix-ci" ? "rerun" : "full",
       fromStage: input.fromStage,
       dryRun: input.dryRun,
       issueNumber: input.issueNumber,

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