@kody-ade/kody-engine-lite 0.1.121 → 0.1.123

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

@@ -561,14 +561,25 @@ function getIssue(issueNumber) {
       "view",
       String(issueNumber),
       "--json",
-      "body,title"
+      "body,title,labels,comments,assignees,milestone"
     ]);
     const parsed = JSON.parse(output);
     if (!parsed || typeof parsed.title !== "string") {
       logger.warn(`  Issue #${issueNumber}: unexpected response shape`);
       return null;
     }
-    return { body: parsed.body ?? "", title: parsed.title };
+    return {
+      body: parsed.body ?? "",
+      title: parsed.title,
+      labels: (parsed.labels ?? []).map((l) => l.name),
+      comments: (parsed.comments ?? []).map((c) => ({
+        body: c.body,
+        author: c.author.login,
+        createdAt: c.createdAt
+      })),
+      assignees: (parsed.assignees ?? []).map((a) => a.login),
+      milestone: parsed.milestone?.title ?? null
+    };
   } catch (err) {
     if (isNotFoundError(err)) {
       logger.info(`  Issue #${issueNumber} not found`);
@@ -1055,7 +1066,8 @@ async function checkModelHealth(baseUrl, apiKey, model) {
     const hasAnthropicContent = Array.isArray(body.content) && body.content.some((b) => b.type === "text");
     const hasThinkingContent = Array.isArray(body.content) && body.content.some((b) => b.type === "thinking");
     const hasOpenAIContent = !!body.choices?.[0]?.message?.content;
-    if (!hasAnthropicContent && !hasThinkingContent && !hasOpenAIContent) {
+    const hasEmptyContentResponse = Array.isArray(body.content) && body.role === "assistant";
+    if (!hasAnthropicContent && !hasThinkingContent && !hasOpenAIContent && !hasEmptyContentResponse) {
       return { ok: false, error: `Unexpected response format: ${JSON.stringify(body).slice(0, 200)}` };
     }
     return { ok: true };
@@ -4163,7 +4175,7 @@ function extractSummary(output, cmdName) {
   const lines = output.split("\n").filter((l) => summaryPatterns.test(l));
   return lines.slice(-3).map((l) => `[${cmdName}] ${l.trim()}`);
 }
-function runQualityGates(taskDir, projectRoot) {
+function runQualityGates(taskDir, projectRoot, options) {
   const config = getProjectConfig();
   const cwd = projectRoot ?? process.cwd();
   const allErrors = [];
@@ -4187,10 +4199,28 @@ function runQualityGates(taskDir, projectRoot) {
       continue;
     }
     if (!result2.success) {
-      allPass = false;
       const errors = parseErrors(result2.output);
-      allErrors.push(...errors.map((e) => `[${name}] ${e}`));
-      rawOutputs.push({ name, output: result2.output.slice(-3e3) });
+      if (name === "typecheck" && options?.onlyFailOnFiles && options.onlyFailOnFiles.length > 0) {
+        const scopedFiles = new Set(options.onlyFailOnFiles);
+        const errorLines = errors.filter((e) => {
+          const fileMatch = e.match(/\b(src\/[^\s(:]+\.[a-z]+)/)?.[1];
+          if (!fileMatch) return false;
+          return scopedFiles.has(fileMatch) || options.onlyFailOnFiles.some((f) => f.endsWith(fileMatch) || fileMatch.endsWith(f));
+        });
+        if (errorLines.length === 0) {
+          logger.warn(`  [typecheck] errors found but none in scoped files \u2014 treating as pre-existing, skipping`);
+          rawOutputs.push({ name, output: result2.output.slice(-3e3) });
+          allSummary.push(...extractSummary(result2.output, name));
+          continue;
+        }
+        allPass = false;
+        allErrors.push(...errorLines.map((e) => `[${name}] ${e}`));
+        rawOutputs.push({ name, output: result2.output.slice(-3e3) });
+      } else {
+        allPass = false;
+        allErrors.push(...errors.map((e) => `[${name}] ${e}`));
+        rawOutputs.push({ name, output: result2.output.slice(-3e3) });
+      }
     }
     allSummary.push(...extractSummary(result2.output, name));
   }
@@ -5313,7 +5343,7 @@ ${previousText}
     const model = resolveModel("cheap");
     const config = getProjectConfig();
     const extraEnv = {};
-    if (needsLitellmProxy(config)) {
+    if (anyStageNeedsProxy(config)) {
       extraEnv.ANTHROPIC_BASE_URL = getLitellmUrl();
     }
     const result2 = await runner.run("retrospective", prompt, model, 3e4, "", {
@@ -6000,26 +6030,15 @@ async function runResolve(options) {
     return { outcome: "failed", error: `Agent failed: ${result2.error}` };
   }
   logger.info("  Verifying resolution...");
-  const verify = runQualityGates(projectDir, projectDir);
+  const verify = runQualityGates(projectDir, projectDir, { onlyFailOnFiles: conflictedFiles });
   if (!verify.pass) {
-    const errorText = verify.errors.join("\n");
-    const errorFilePaths = errorText.match(/src\/[^\s(:]+\.[a-z]+/g) ?? [];
-    const resolvedSet = new Set(conflictedFiles);
-    const allPreExisting = errorFilePaths.length > 0 && errorFilePaths.every(
-      (f) => !resolvedSet.has(f) && !conflictedFiles.some((c) => c.endsWith(f))
-    );
-    if (allPreExisting) {
-      logger.warn("  Verification: all errors in files not touched by resolution \u2014 treating as pre-existing, proceeding");
-    } else {
-      const errorSummary = verify.errors.slice(0, 5).join("\n");
-      logger.error(`  Verification failed:
+    const errorSummary = verify.errors.slice(0, 5).join("\n");
+    logger.error(`  Verification failed:
 ${errorSummary}`);
-      return { outcome: "failed", error: `Conflict resolution failed verification:
+    return { outcome: "failed", error: `Conflict resolution failed verification:
 ${errorSummary}` };
-    }
-  } else {
-    logger.info("  Verification passed");
   }
+  logger.info("  Verification passed");
   commitAll(`chore: resolve merge conflicts with ${defaultBranch}`, projectDir);
   if (!local) {
     pushBranch(projectDir);

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

package/dist/cli/litellm.js

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,2 @@
+export declare function findLatestTaskForIssue(issueNumber: number, projectDir: string): string | null;
+export declare function generateTaskId(): string;

package/dist/cli/task-resolution.js

@@ -0,0 +1,41 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync } from "child_process";
+export function findLatestTaskForIssue(issueNumber, projectDir) {
+    const tasksDir = path.join(projectDir, ".tasks");
+    if (!fs.existsSync(tasksDir))
+        return null;
+    // Only consider directories (not files)
+    const allDirs = fs.readdirSync(tasksDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+        .sort()
+        .reverse();
+    // Direct match: tasks starting with issue number
+    const prefix = `${issueNumber}-`;
+    const direct = allDirs.find((d) => d.startsWith(prefix));
+    if (direct)
+        return direct;
+    // Fallback for PR comments: extract issue number from current git branch
+    // Branch format: <issueNum>--<slug> (e.g., 1031--security-8x-route)
+    try {
+        const branch = execFileSync("git", ["branch", "--show-current"], {
+            encoding: "utf-8", cwd: projectDir, timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        const branchIssueMatch = branch.match(/^(\d+)-/);
+        if (branchIssueMatch) {
+            const branchIssueNum = branchIssueMatch[1];
+            const branchPrefix = `${branchIssueNum}-`;
+            const fromBranch = allDirs.find((d) => d.startsWith(branchPrefix));
+            if (fromBranch)
+                return fromBranch;
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+export function generateTaskId() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${String(now.getFullYear()).slice(2)}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}

package/dist/config.d.ts

@@ -0,0 +1,49 @@
+export interface RunnerConfig {
+    type: "claude-code";
+}
+export interface KodyConfig {
+    quality: {
+        typecheck: string;
+        lint: string;
+        lintFix: string;
+        format: string;
+        formatFix: string;
+        testUnit: string;
+    };
+    git: {
+        defaultBranch: string;
+        userEmail?: string;
+        userName?: string;
+    };
+    github: {
+        owner: string;
+        repo: string;
+    };
+    paths: {
+        taskDir: string;
+    };
+    agent: {
+        runner?: string;
+        modelMap: {
+            cheap: string;
+            mid: string;
+            strong: string;
+        };
+        litellmUrl?: string;
+        usePerStageRouting?: boolean;
+        defaultRunner?: string;
+        runners?: Record<string, RunnerConfig>;
+        stageRunners?: Record<string, string>;
+    };
+}
+export declare const SIGKILL_GRACE_MS = 5000;
+export declare const MAX_PR_TITLE_LENGTH = 72;
+export declare const STDERR_TAIL_CHARS = 500;
+export declare const API_TIMEOUT_MS = 30000;
+export declare const DEFAULT_MAX_FIX_ATTEMPTS = 2;
+export declare const AGENT_RETRY_DELAY_MS = 2000;
+export declare const VERIFY_COMMAND_TIMEOUT_MS: number;
+export declare const FIX_COMMAND_TIMEOUT_MS: number;
+export declare function setConfigDir(dir: string): void;
+export declare function getProjectConfig(): KodyConfig;
+export declare function resetProjectConfig(): void;

package/dist/config.js

@@ -0,0 +1,72 @@
+import * as fs from "fs";
+import * as path from "path";
+import { logger } from "./logger.js";
+const DEFAULT_CONFIG = {
+    quality: {
+        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",
+    },
+    git: {
+        defaultBranch: "dev",
+    },
+    github: {
+        owner: "",
+        repo: "",
+    },
+    paths: {
+        taskDir: ".tasks",
+    },
+    agent: {
+        runner: "claude-code",
+        defaultRunner: "claude",
+        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" },
+    },
+};
+// Pipeline constants
+export const SIGKILL_GRACE_MS = 5000;
+export const MAX_PR_TITLE_LENGTH = 72;
+export const STDERR_TAIL_CHARS = 500;
+export const API_TIMEOUT_MS = 30_000;
+export const DEFAULT_MAX_FIX_ATTEMPTS = 2;
+export const AGENT_RETRY_DELAY_MS = 2000;
+export const VERIFY_COMMAND_TIMEOUT_MS = 5 * 60 * 1000;
+export const FIX_COMMAND_TIMEOUT_MS = 2 * 60 * 1000;
+let _config = null;
+let _configDir = null;
+export function setConfigDir(dir) {
+    _configDir = dir;
+    _config = null;
+}
+export function getProjectConfig() {
+    if (_config)
+        return _config;
+    const configPath = path.join(_configDir ?? process.cwd(), "kody.config.json");
+    if (fs.existsSync(configPath)) {
+        try {
+            const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            _config = {
+                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 },
+            };
+        }
+        catch {
+            logger.warn("kody.config.json is invalid JSON — using defaults");
+            _config = { ...DEFAULT_CONFIG };
+        }
+    }
+    else {
+        _config = { ...DEFAULT_CONFIG };
+    }
+    return _config;
+}
+export function resetProjectConfig() {
+    _config = null;
+    _configDir = null;
+}