@kody-ade/engine 0.1.0

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;

package/dist/git-utils.js

@@ -0,0 +1,174 @@
+import { execFileSync } from "child_process";
+import { logger } from "./logger.js";
+const BASE_BRANCHES = ["dev", "main", "master"];
+let _hookSafeEnv = null;
+function getHookSafeEnv() {
+    if (!_hookSafeEnv) {
+        _hookSafeEnv = { ...process.env, HUSKY: "0", SKIP_HOOKS: "1" };
+    }
+    return _hookSafeEnv;
+}
+function git(args, options) {
+    return execFileSync("git", args, {
+        encoding: "utf-8",
+        timeout: options?.timeout ?? 30_000,
+        cwd: options?.cwd,
+        env: options?.env ?? getHookSafeEnv(),
+        stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+}
+export function deriveBranchName(issueNumber, title) {
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, "")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .slice(0, 50)
+        .replace(/-$/, "");
+    return `${issueNumber}-${slug}`;
+}
+export function getDefaultBranch(cwd) {
+    // Method 1: symbolic-ref (fast, no network)
+    try {
+        const ref = git(["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd });
+        return ref.replace("refs/remotes/origin/", "");
+    }
+    catch {
+        // Fall through
+    }
+    // Method 2: remote show (needs network, 10s timeout)
+    try {
+        const output = git(["remote", "show", "origin"], { cwd, timeout: 10_000 });
+        const match = output.match(/HEAD branch:\s*(\S+)/);
+        if (match)
+            return match[1];
+    }
+    catch {
+        // Fall through
+    }
+    // Method 3: hardcoded fallback
+    return "dev";
+}
+export function getCurrentBranch(cwd) {
+    return git(["branch", "--show-current"], { cwd });
+}
+export function ensureFeatureBranch(issueNumber, title, cwd) {
+    const current = getCurrentBranch(cwd);
+    const branchName = deriveBranchName(issueNumber, title);
+    // Already on the correct feature branch for this issue
+    if (current === branchName || current.startsWith(`${issueNumber}-`)) {
+        logger.info(`  Already on feature branch: ${current}`);
+        return current;
+    }
+    // On a different feature branch — switch to default first
+    if (!BASE_BRANCHES.includes(current) && current !== "") {
+        const defaultBranch = getDefaultBranch(cwd);
+        logger.info(`  Switching from ${current} to ${defaultBranch} before creating ${branchName}`);
+        try {
+            git(["checkout", defaultBranch], { cwd });
+        }
+        catch {
+            logger.warn(`  Failed to checkout ${defaultBranch}, aborting branch creation`);
+            return current;
+        }
+    }
+    // Fetch origin
+    try {
+        git(["fetch", "origin"], { cwd, timeout: 30_000 });
+    }
+    catch {
+        logger.warn("  Failed to fetch origin");
+    }
+    // Check if branch exists on remote
+    try {
+        git(["rev-parse", "--verify", `origin/${branchName}`], { cwd });
+        git(["checkout", branchName], { cwd });
+        git(["pull", "origin", branchName], { cwd, timeout: 30_000 });
+        logger.info(`  Checked out existing remote branch: ${branchName}`);
+        return branchName;
+    }
+    catch {
+        // Branch doesn't exist on remote
+    }
+    // Check if branch exists locally
+    try {
+        git(["rev-parse", "--verify", branchName], { cwd });
+        git(["checkout", branchName], { cwd });
+        logger.info(`  Checked out existing local branch: ${branchName}`);
+        return branchName;
+    }
+    catch {
+        // Branch doesn't exist locally either
+    }
+    // Create new branch tracking default branch
+    const defaultBranch = getDefaultBranch(cwd);
+    try {
+        git(["checkout", "-b", branchName, `origin/${defaultBranch}`], { cwd });
+    }
+    catch {
+        // If origin/default doesn't exist, create from current HEAD
+        git(["checkout", "-b", branchName], { cwd });
+    }
+    logger.info(`  Created new branch: ${branchName}`);
+    return branchName;
+}
+export function syncWithDefault(cwd) {
+    const defaultBranch = getDefaultBranch(cwd);
+    const current = getCurrentBranch(cwd);
+    if (current === defaultBranch)
+        return; // already on default, no merge needed
+    // Fetch latest
+    try {
+        git(["fetch", "origin", defaultBranch], { cwd, timeout: 30_000 });
+    }
+    catch {
+        logger.warn("  Failed to fetch latest from origin");
+        return;
+    }
+    // Merge default into feature branch
+    try {
+        git(["merge", `origin/${defaultBranch}`, "--no-edit"], { cwd, timeout: 30_000 });
+        logger.info(`  Synced with origin/${defaultBranch}`);
+    }
+    catch {
+        // Merge conflict — abort and warn
+        try {
+            git(["merge", "--abort"], { cwd });
+        }
+        catch { /* ignore */ }
+        logger.warn(`  Merge conflict with origin/${defaultBranch} — skipping sync`);
+    }
+}
+export function commitAll(message, cwd) {
+    // Check for changes
+    const status = git(["status", "--porcelain"], { cwd });
+    if (!status) {
+        return { success: false, hash: "", message: "No changes to commit" };
+    }
+    git(["add", "."], { cwd });
+    git(["commit", "--no-gpg-sign", "-m", message], { cwd });
+    const hash = git(["rev-parse", "HEAD"], { cwd }).slice(0, 7);
+    logger.info(`  Committed: ${hash} ${message}`);
+    return { success: true, hash, message };
+}
+export function pushBranch(cwd) {
+    git(["push", "-u", "origin", "HEAD"], { cwd, timeout: 120_000 });
+    logger.info("  Pushed to origin");
+}
+export function getChangedFiles(baseBranch, cwd) {
+    try {
+        const output = git(["diff", "--name-only", `origin/${baseBranch}...HEAD`], { cwd });
+        return output ? output.split("\n").filter(Boolean) : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function getDiff(baseBranch, cwd) {
+    try {
+        return git(["diff", `origin/${baseBranch}...HEAD`], { cwd });
+    }
+    catch {
+        return "";
+    }
+}

package/dist/github-api.d.ts

@@ -0,0 +1,14 @@
+export declare function setGhCwd(cwd: string): void;
+export declare function getIssue(issueNumber: number): {
+    body: string;
+    title: string;
+} | null;
+export declare function setLabel(issueNumber: number, label: string): void;
+export declare function removeLabel(issueNumber: number, label: string): void;
+export declare function postComment(issueNumber: number, body: string): void;
+export declare function createPR(head: string, base: string, title: string, body: string): {
+    number: number;
+    url: string;
+} | null;
+export declare function setLifecycleLabel(issueNumber: number, phase: string): void;
+export declare function closeIssue(issueNumber: number, reason?: "completed" | "not planned"): void;

package/dist/github-api.js

@@ -0,0 +1,114 @@
+import { execFileSync } from "child_process";
+import { logger } from "./logger.js";
+const API_TIMEOUT_MS = 30_000;
+const LIFECYCLE_LABELS = ["planning", "building", "review", "done", "failed", "waiting", "low", "medium", "high"];
+let _ghCwd;
+export function setGhCwd(cwd) {
+    _ghCwd = cwd;
+}
+function ghToken() {
+    return process.env.GH_PAT?.trim() || process.env.GH_TOKEN;
+}
+function gh(args, options) {
+    const token = ghToken();
+    const env = token
+        ? { ...process.env, GH_TOKEN: token }
+        : { ...process.env };
+    return execFileSync("gh", args, {
+        encoding: "utf-8",
+        timeout: API_TIMEOUT_MS,
+        cwd: _ghCwd,
+        env,
+        input: options?.input,
+        stdio: options?.input ? ["pipe", "pipe", "pipe"] : ["inherit", "pipe", "pipe"],
+    }).trim();
+}
+export function getIssue(issueNumber) {
+    try {
+        const output = gh([
+            "issue", "view", String(issueNumber),
+            "--json", "body,title",
+        ]);
+        return JSON.parse(output);
+    }
+    catch (err) {
+        logger.error(`  Failed to get issue #${issueNumber}: ${err}`);
+        return null;
+    }
+}
+export function setLabel(issueNumber, label) {
+    try {
+        gh(["issue", "edit", String(issueNumber), "--add-label", label]);
+        logger.info(`  Label added: ${label}`);
+    }
+    catch (err) {
+        logger.warn(`  Failed to set label ${label}: ${err}`);
+    }
+}
+export function removeLabel(issueNumber, label) {
+    try {
+        gh(["issue", "edit", String(issueNumber), "--remove-label", label]);
+    }
+    catch {
+        // Label may not exist — ignore
+    }
+}
+export function postComment(issueNumber, body) {
+    try {
+        gh(["issue", "comment", String(issueNumber), "--body-file", "-"], { input: body });
+        logger.info(`  Comment posted on #${issueNumber}`);
+    }
+    catch (err) {
+        logger.warn(`  Failed to post comment: ${err}`);
+    }
+}
+export function createPR(head, base, title, body) {
+    try {
+        const output = gh([
+            "pr", "create",
+            "--head", head,
+            "--base", base,
+            "--title", title,
+            "--body-file", "-",
+        ], { input: body });
+        const url = output.trim();
+        const match = url.match(/\/pull\/(\d+)$/);
+        const number = match ? parseInt(match[1], 10) : 0;
+        logger.info(`  PR created: ${url}`);
+        return { number, url };
+    }
+    catch (err) {
+        logger.error(`  Failed to create PR: ${err}`);
+        return null;
+    }
+}
+export function setLifecycleLabel(issueNumber, phase) {
+    if (!LIFECYCLE_LABELS.includes(phase)) {
+        logger.warn(`  Invalid lifecycle phase: ${phase}`);
+        return;
+    }
+    // Remove all other lifecycle labels
+    const othersToRemove = LIFECYCLE_LABELS
+        .filter((l) => l !== phase)
+        .map((l) => `kody:${l}`)
+        .join(",");
+    if (othersToRemove) {
+        try {
+            gh(["issue", "edit", String(issueNumber), "--remove-label", othersToRemove]);
+        }
+        catch {
+            // Labels may not exist — ignore
+        }
+    }
+    // Add new label
+    setLabel(issueNumber, `kody:${phase}`);
+}
+export function closeIssue(issueNumber, reason = "completed") {
+    try {
+        gh(["issue", "close", String(issueNumber), "--reason", reason]);
+        logger.info(`  Issue #${issueNumber} closed: ${reason}`);
+    }
+    catch (err) {
+        logger.warn(`  Failed to close issue: ${err}`);
+    }
+}

package/dist/kody-utils.d.ts

@@ -0,0 +1 @@
+export declare function ensureTaskDir(taskId: string): string;

package/dist/kody-utils.js

@@ -0,0 +1,9 @@
+import * as fs from "fs";
+import * as path from "path";
+export function ensureTaskDir(taskId) {
+    const taskDir = path.join(process.cwd(), ".tasks", taskId);
+    if (!fs.existsSync(taskDir)) {
+        fs.mkdirSync(taskDir, { recursive: true });
+    }
+    return taskDir;
+}

package/dist/learning/auto-learn.d.ts

@@ -0,0 +1,2 @@
+import type { PipelineContext } from "../types.js";
+export declare function autoLearn(ctx: PipelineContext): void;