@kody-ade/kody-engine-lite 0.1.63 → 0.1.65

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

package/dist/context.d.ts

@@ -0,0 +1,4 @@
+export declare function readPromptFile(stageName: string): string;
+export declare function injectTaskContext(prompt: string, taskId: string, taskDir: string, feedback?: string): string;
+export declare function buildFullPrompt(stageName: string, taskId: string, taskDir: string, projectDir: string, feedback?: string): string;
+export declare function resolveModel(modelTier: string, stageName?: string): string;

package/dist/context.js

@@ -0,0 +1,83 @@
+import * as fs from "fs";
+import * as path from "path";
+import { readProjectMemory } from "./memory.js";
+import { getProjectConfig } from "./config.js";
+const DEFAULT_MODEL_MAP = {
+    cheap: "haiku",
+    mid: "sonnet",
+    strong: "opus",
+};
+const MAX_TASK_CONTEXT_PLAN = 1500;
+const MAX_TASK_CONTEXT_SPEC = 2000;
+export function readPromptFile(stageName) {
+    const scriptDir = new URL(".", import.meta.url).pathname;
+    // Try multiple resolution paths (dev: src/../prompts, prod: dist/bin/../../prompts)
+    const candidates = [
+        path.resolve(scriptDir, "..", "prompts", `${stageName}.md`),
+        path.resolve(scriptDir, "..", "..", "prompts", `${stageName}.md`),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return fs.readFileSync(candidate, "utf-8");
+        }
+    }
+    throw new Error(`Prompt file not found: tried ${candidates.join(", ")}`);
+}
+export function injectTaskContext(prompt, taskId, taskDir, feedback) {
+    let context = `## Task Context\n`;
+    context += `Task ID: ${taskId}\n`;
+    context += `Task Directory: ${taskDir}\n`;
+    const taskMdPath = path.join(taskDir, "task.md");
+    if (fs.existsSync(taskMdPath)) {
+        const taskMd = fs.readFileSync(taskMdPath, "utf-8");
+        context += `\n## Task Description\n${taskMd}\n`;
+    }
+    const taskJsonPath = path.join(taskDir, "task.json");
+    if (fs.existsSync(taskJsonPath)) {
+        try {
+            const taskDef = JSON.parse(fs.readFileSync(taskJsonPath, "utf-8"));
+            context += `\n## Task Classification\n`;
+            context += `Type: ${taskDef.task_type ?? "unknown"}\n`;
+            context += `Title: ${taskDef.title ?? "unknown"}\n`;
+            context += `Risk: ${taskDef.risk_level ?? "unknown"}\n`;
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    const specPath = path.join(taskDir, "spec.md");
+    if (fs.existsSync(specPath)) {
+        const spec = fs.readFileSync(specPath, "utf-8");
+        const truncated = spec.slice(0, MAX_TASK_CONTEXT_SPEC);
+        context += `\n## Spec Summary\n${truncated}${spec.length > MAX_TASK_CONTEXT_SPEC ? "\n..." : ""}\n`;
+    }
+    const planPath = path.join(taskDir, "plan.md");
+    if (fs.existsSync(planPath)) {
+        const plan = fs.readFileSync(planPath, "utf-8");
+        const truncated = plan.slice(0, MAX_TASK_CONTEXT_PLAN);
+        context += `\n## Plan Summary\n${truncated}${plan.length > MAX_TASK_CONTEXT_PLAN ? "\n..." : ""}\n`;
+    }
+    if (feedback) {
+        context += `\n## Human Feedback\n${feedback}\n`;
+    }
+    return prompt.replace("{{TASK_CONTEXT}}", context);
+}
+export function buildFullPrompt(stageName, taskId, taskDir, projectDir, feedback) {
+    const memory = readProjectMemory(projectDir);
+    const promptTemplate = readPromptFile(stageName);
+    const prompt = injectTaskContext(promptTemplate, taskId, taskDir, feedback);
+    return memory ? `${memory}\n---\n\n${prompt}` : prompt;
+}
+export function resolveModel(modelTier, stageName) {
+    const config = getProjectConfig();
+    // Per-stage routing: use stage name as LiteLLM alias
+    if (config.agent.usePerStageRouting && stageName) {
+        return stageName;
+    }
+    // Config model map (may be LiteLLM aliases or direct model names)
+    const mapped = config.agent.modelMap[modelTier];
+    if (mapped)
+        return mapped;
+    // Fallback to defaults
+    return DEFAULT_MODEL_MAP[modelTier] ?? "sonnet";
+}

package/dist/definitions.d.ts

@@ -0,0 +1,3 @@
+import type { StageDefinition } from "./types.js";
+export declare const STAGES: StageDefinition[];
+export declare function getStage(name: string): StageDefinition | undefined;

package/dist/definitions.js

@@ -0,0 +1,59 @@
+export const STAGES = [
+    {
+        name: "taskify",
+        type: "agent",
+        modelTier: "cheap",
+        timeout: 300_000,
+        maxRetries: 1,
+        outputFile: "task.json",
+    },
+    {
+        name: "plan",
+        type: "agent",
+        modelTier: "strong",
+        timeout: 600_000,
+        maxRetries: 1,
+        outputFile: "plan.md",
+    },
+    {
+        name: "build",
+        type: "agent",
+        modelTier: "mid",
+        timeout: 1_200_000,
+        maxRetries: 1,
+    },
+    {
+        name: "verify",
+        type: "gate",
+        modelTier: "cheap",
+        timeout: 300_000,
+        maxRetries: 2,
+        retryWithAgent: "autofix",
+    },
+    {
+        name: "review",
+        type: "agent",
+        modelTier: "strong",
+        timeout: 600_000,
+        maxRetries: 1,
+        outputFile: "review.md",
+    },
+    {
+        name: "review-fix",
+        type: "agent",
+        modelTier: "mid",
+        timeout: 600_000,
+        maxRetries: 1,
+    },
+    {
+        name: "ship",
+        type: "deterministic",
+        modelTier: "cheap",
+        timeout: 120_000,
+        maxRetries: 1,
+        outputFile: "ship.md",
+    },
+];
+export function getStage(name) {
+    return STAGES.find((s) => s.name === name);
+}

package/dist/entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entry.js

@@ -0,0 +1,236 @@
+import * as fs from "fs";
+import * as path from "path";
+import { createRunners } from "./agent-runner.js";
+import { runPipeline, printStatus } from "./pipeline.js";
+import { runPreflight } from "./preflight.js";
+import { setConfigDir, getProjectConfig } from "./config.js";
+import { setGhCwd, getIssue, postComment } from "./github-api.js";
+import { logger } from "./logger.js";
+// Extracted modules
+import { parseArgs } from "./cli/args.js";
+import { checkLitellmHealth, tryStartLitellm } from "./cli/litellm.js";
+import { findLatestTaskForIssue, generateTaskId } from "./cli/task-resolution.js";
+async function main() {
+    const input = parseArgs();
+    // Resolve working directory first (needed for task lookup)
+    const projectDir = input.cwd ? path.resolve(input.cwd) : process.cwd();
+    if (input.cwd) {
+        if (!fs.existsSync(projectDir)) {
+            console.error(`--cwd path does not exist: ${projectDir}`);
+            process.exit(1);
+        }
+        setConfigDir(projectDir);
+        setGhCwd(projectDir);
+        logger.info(`Working directory: ${projectDir}`);
+    }
+    // Resolve taskId
+    let taskId = input.taskId;
+    if (!taskId) {
+        if ((input.command === "rerun" || input.command === "fix") && input.issueNumber) {
+            const found = findLatestTaskForIssue(input.issueNumber, projectDir);
+            if (!found) {
+                console.error(`No previous task found for issue #${input.issueNumber}`);
+                process.exit(1);
+            }
+            taskId = found;
+            logger.info(`Found latest task for issue #${input.issueNumber}: ${taskId}`);
+        }
+        else if (input.issueNumber) {
+            taskId = `${input.issueNumber}-${generateTaskId()}`;
+        }
+        else if (input.command === "run" && input.task) {
+            taskId = generateTaskId();
+        }
+        else {
+            console.error("--task-id is required (or provide --issue-number to auto-generate)");
+            process.exit(1);
+        }
+    }
+    const taskDir = path.join(projectDir, ".tasks", taskId);
+    fs.mkdirSync(taskDir, { recursive: true });
+    // Status command — no preflight needed
+    if (input.command === "status") {
+        printStatus(taskId, taskDir);
+        return;
+    }
+    // Preflight
+    logger.info("Preflight checks:");
+    runPreflight();
+    // Write task.md if --task provided
+    if (input.task) {
+        fs.writeFileSync(path.join(taskDir, "task.md"), input.task);
+    }
+    // Auto-fetch issue body as task if no task.md and issue-number provided
+    const taskMdPath = path.join(taskDir, "task.md");
+    if (!fs.existsSync(taskMdPath) && input.issueNumber) {
+        logger.info(`Fetching issue #${input.issueNumber} body as task...`);
+        const issue = getIssue(input.issueNumber);
+        if (issue) {
+            const taskContent = `# ${issue.title}\n\n${issue.body ?? ""}`;
+            fs.writeFileSync(taskMdPath, taskContent);
+            logger.info(`  Task loaded from issue #${input.issueNumber}: ${issue.title}`);
+        }
+    }
+    // Verify task.md exists for run
+    if (input.command === "run") {
+        if (!fs.existsSync(taskMdPath)) {
+            console.error("No task.md found. Provide --task, --issue-number, or ensure .tasks/<id>/task.md exists.");
+            process.exit(1);
+        }
+    }
+    // Fix command defaults to --from build
+    if (input.command === "fix" && !input.fromStage) {
+        input.fromStage = "build";
+    }
+    // Auto-detect --from for rerun if not provided (find paused stage)
+    if (input.command === "rerun" && !input.fromStage) {
+        const statusPath = path.join(taskDir, "status.json");
+        if (fs.existsSync(statusPath)) {
+            try {
+                const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+                const stageNames = ["taskify", "plan", "build", "verify", "review", "review-fix", "ship"];
+                let foundPaused = false;
+                for (const name of stageNames) {
+                    const s = status.stages[name];
+                    if (s?.error?.includes("paused")) {
+                        const idx = stageNames.indexOf(name);
+                        if (idx < stageNames.length - 1) {
+                            input.fromStage = stageNames[idx + 1];
+                            foundPaused = true;
+                            logger.info(`Auto-detected resume from: ${input.fromStage} (after paused ${name})`);
+                            break;
+                        }
+                    }
+                    if (s?.state === "failed" || s?.state === "pending") {
+                        input.fromStage = name;
+                        foundPaused = true;
+                        logger.info(`Auto-detected resume from: ${input.fromStage}`);
+                        break;
+                    }
+                }
+                if (!foundPaused) {
+                    input.fromStage = "taskify";
+                    logger.info("No paused/failed stage found, resuming from taskify");
+                }
+            }
+            catch {
+                console.error("--from <stage> is required (could not read status.json)");
+                process.exit(1);
+            }
+        }
+        else {
+            // No status.json — fall back to full run with feedback preserved
+            logger.info("No status.json found — running full pipeline with feedback");
+            input.command = "run";
+        }
+    }
+    // Start LiteLLM proxy if configured and not running
+    const config = getProjectConfig();
+    let litellmProcess = null;
+    const cleanupLitellm = () => { if (litellmProcess) {
+        litellmProcess.kill();
+        litellmProcess = null;
+    } };
+    process.on("exit", cleanupLitellm);
+    process.on("SIGINT", () => { cleanupLitellm(); process.exit(130); });
+    process.on("SIGTERM", () => { cleanupLitellm(); process.exit(143); });
+    if (config.agent.litellmUrl) {
+        const proxyRunning = await checkLitellmHealth(config.agent.litellmUrl);
+        if (!proxyRunning) {
+            litellmProcess = await tryStartLitellm(config.agent.litellmUrl, projectDir);
+            if (!litellmProcess) {
+                logger.warn("LiteLLM not available — falling back to Anthropic models");
+                config.agent.litellmUrl = undefined;
+            }
+        }
+        else {
+            logger.info(`LiteLLM proxy already running at ${config.agent.litellmUrl}`);
+        }
+    }
+    // Create runners
+    const runners = createRunners(config);
+    const defaultRunnerName = config.agent.defaultRunner ?? Object.keys(runners)[0] ?? "claude";
+    const defaultRunner = runners[defaultRunnerName];
+    if (!defaultRunner) {
+        console.error(`Default runner "${defaultRunnerName}" not configured`);
+        process.exit(1);
+    }
+    const healthy = await defaultRunner.healthCheck();
+    if (!healthy) {
+        console.error(`Runner "${defaultRunnerName}" health check failed`);
+        process.exit(1);
+    }
+    // Build context
+    const ctx = {
+        taskId,
+        taskDir,
+        projectDir,
+        runners,
+        input: {
+            mode: (input.command === "rerun" || input.command === "fix") ? "rerun" : "full",
+            fromStage: input.fromStage,
+            dryRun: input.dryRun,
+            issueNumber: input.issueNumber,
+            feedback: input.feedback,
+            local: input.local,
+            complexity: input.complexity,
+        },
+    };
+    logger.info(`Task: ${taskId}`);
+    logger.info(`Mode: ${ctx.input.mode}${ctx.input.local ? " (local)" : " (CI)"}`);
+    if (ctx.input.issueNumber)
+        logger.info(`Issue: #${ctx.input.issueNumber}`);
+    // Post task-id comment so user knows the ID for rerun
+    if (ctx.input.issueNumber && !ctx.input.local && ctx.input.mode === "full") {
+        const runUrl = process.env.RUN_URL ?? "";
+        const runLink = runUrl ? ` ([logs](${runUrl}))` : "";
+        try {
+            postComment(ctx.input.issueNumber, `🚀 Kody pipeline started: \`${taskId}\`${runLink}\n\nTo rerun: \`@kody rerun ${taskId} --from <stage>\``);
+        }
+        catch { /* best effort */ }
+    }
+    // Run pipeline
+    const state = await runPipeline(ctx);
+    // Report
+    const files = fs.readdirSync(taskDir);
+    console.log(`\nArtifacts in ${taskDir}:`);
+    for (const f of files) {
+        console.log(`  ${f}`);
+    }
+    if (state.state === "failed") {
+        // Check if this is a "paused" state (questions posted) — not a real failure
+        const isPaused = Object.values(state.stages).some((s) => s.error?.includes("paused") ?? false);
+        if (isPaused) {
+            process.exit(0);
+        }
+        // Post failure comment on issue
+        if (ctx.input.issueNumber && !ctx.input.local) {
+            const failedStage = Object.entries(state.stages).find(([, s]) => s.state === "failed" || s.state === "timeout");
+            const stageName = failedStage ? failedStage[0] : "unknown";
+            const error = failedStage ? failedStage[1].error ?? "" : "";
+            try {
+                postComment(ctx.input.issueNumber, `❌ Pipeline failed at **${stageName}**${error ? `: ${error.slice(0, 200)}` : ""}`);
+            }
+            catch {
+                // Best effort
+            }
+        }
+        process.exit(1);
+    }
+}
+main().catch(async (err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(msg);
+    // Post crash comment if we have issue context
+    const issueStr = process.argv.find((_, i, a) => a[i - 1] === "--issue-number") ?? process.env.ISSUE_NUMBER;
+    const isLocal = process.argv.includes("--local") || !process.env.GITHUB_ACTIONS;
+    if (issueStr && !isLocal) {
+        try {
+            postComment(parseInt(issueStr, 10), `❌ Pipeline crashed: ${msg.slice(0, 200)}`);
+        }
+        catch {
+            // Best effort
+        }
+    }
+    process.exit(1);
+});

package/dist/git-utils.d.ts

@@ -0,0 +1,13 @@
+export declare function deriveBranchName(issueNumber: number, title: string): string;
+export declare function getDefaultBranch(cwd?: string): string;
+export declare function getCurrentBranch(cwd?: string): string;
+export declare function ensureFeatureBranch(issueNumber: number, title: string, cwd?: string): string;
+export declare function syncWithDefault(cwd?: string): void;
+export declare function commitAll(message: string, cwd?: string): {
+    success: boolean;
+    hash: string;
+    message: string;
+};
+export declare function pushBranch(cwd?: string): void;
+export declare function getChangedFiles(baseBranch: string, cwd?: string): string[];
+export declare function getDiff(baseBranch: string, cwd?: string): string;