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

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;

package/dist/learning/auto-learn.js

@@ -0,0 +1,169 @@
+import * as fs from "fs";
+import * as path from "path";
+import { logger } from "../logger.js";
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+export function autoLearn(ctx) {
+    try {
+        const memoryDir = path.join(ctx.projectDir, ".kody", "memory");
+        if (!fs.existsSync(memoryDir)) {
+            fs.mkdirSync(memoryDir, { recursive: true });
+        }
+        const learnings = [];
+        const timestamp = new Date().toISOString().slice(0, 10);
+        // Extract from verify.md (strip ANSI codes first)
+        const verifyPath = path.join(ctx.taskDir, "verify.md");
+        if (fs.existsSync(verifyPath)) {
+            const verify = stripAnsi(fs.readFileSync(verifyPath, "utf-8"));
+            if (/vitest/i.test(verify))
+                learnings.push("- Uses vitest for testing");
+            if (/jest/i.test(verify))
+                learnings.push("- Uses jest for testing");
+            if (/eslint/i.test(verify))
+                learnings.push("- Uses eslint for linting");
+            if (/prettier/i.test(verify))
+                learnings.push("- Uses prettier for formatting");
+            if (/tsc\b/i.test(verify))
+                learnings.push("- Uses TypeScript (tsc)");
+            if (/jsdom/i.test(verify))
+                learnings.push("- Test environment: jsdom");
+            if (/node/i.test(verify) && /environment/i.test(verify))
+                learnings.push("- Test environment: node");
+        }
+        // Extract from review.md
+        const reviewPath = path.join(ctx.taskDir, "review.md");
+        if (fs.existsSync(reviewPath)) {
+            const review = fs.readFileSync(reviewPath, "utf-8");
+            if (/\.js extension/i.test(review))
+                learnings.push("- Imports use .js extensions (ESM)");
+            if (/barrel export/i.test(review))
+                learnings.push("- Uses barrel exports (index.ts)");
+            if (/timezone/i.test(review))
+                learnings.push("- Timezone handling is a concern in this codebase");
+            if (/UTC/i.test(review))
+                learnings.push("- Date operations should consider UTC vs local time");
+        }
+        // Extract from task.json
+        const taskJsonPath = path.join(ctx.taskDir, "task.json");
+        if (fs.existsSync(taskJsonPath)) {
+            try {
+                const raw = stripAnsi(fs.readFileSync(taskJsonPath, "utf-8"));
+                const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+                const task = JSON.parse(cleaned);
+                if (task.scope && Array.isArray(task.scope)) {
+                    const dirs = [...new Set(task.scope.map((s) => s.split("/").slice(0, -1).join("/")).filter(Boolean))];
+                    if (dirs.length > 0)
+                        learnings.push(`- Active directories: ${dirs.join(", ")}`);
+                }
+            }
+            catch {
+                // Ignore
+            }
+        }
+        if (learnings.length > 0) {
+            const conventionsPath = path.join(memoryDir, "conventions.md");
+            const entry = `\n## Learned ${timestamp} (task: ${ctx.taskId})\n${learnings.join("\n")}\n`;
+            fs.appendFileSync(conventionsPath, entry);
+            logger.info(`Auto-learned ${learnings.length} convention(s)`);
+        }
+        // Auto-detect architecture
+        autoLearnArchitecture(ctx.projectDir, memoryDir, timestamp);
+    }
+    catch {
+        // Auto-learn is best-effort — don't fail the pipeline
+    }
+}
+function autoLearnArchitecture(projectDir, memoryDir, timestamp) {
+    const archPath = path.join(memoryDir, "architecture.md");
+    // Only auto-detect if architecture.md doesn't exist yet
+    if (fs.existsSync(archPath))
+        return;
+    const detected = [];
+    // Detect framework from package.json
+    const pkgPath = path.join(projectDir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            // Frameworks
+            if (allDeps.next)
+                detected.push(`- Framework: Next.js ${allDeps.next}`);
+            else if (allDeps.react)
+                detected.push(`- Framework: React ${allDeps.react}`);
+            else if (allDeps.express)
+                detected.push(`- Framework: Express ${allDeps.express}`);
+            else if (allDeps.fastify)
+                detected.push(`- Framework: Fastify ${allDeps.fastify}`);
+            // Language
+            if (allDeps.typescript)
+                detected.push(`- Language: TypeScript ${allDeps.typescript}`);
+            // Testing
+            if (allDeps.vitest)
+                detected.push(`- Testing: vitest ${allDeps.vitest}`);
+            else if (allDeps.jest)
+                detected.push(`- Testing: jest ${allDeps.jest}`);
+            // Linting
+            if (allDeps.eslint)
+                detected.push(`- Linting: eslint ${allDeps.eslint}`);
+            // Database
+            if (allDeps.prisma || allDeps["@prisma/client"])
+                detected.push("- Database: Prisma ORM");
+            if (allDeps.drizzle || allDeps["drizzle-orm"])
+                detected.push("- Database: Drizzle ORM");
+            if (allDeps.pg || allDeps.postgres)
+                detected.push("- Database: PostgreSQL");
+            // CMS
+            if (allDeps.payload || allDeps["@payloadcms/next"])
+                detected.push(`- CMS: Payload CMS`);
+            // Module type
+            if (pkg.type === "module")
+                detected.push("- Module system: ESM");
+            else
+                detected.push("- Module system: CommonJS");
+            // Package manager
+            if (fs.existsSync(path.join(projectDir, "pnpm-lock.yaml")))
+                detected.push("- Package manager: pnpm");
+            else if (fs.existsSync(path.join(projectDir, "yarn.lock")))
+                detected.push("- Package manager: yarn");
+            else if (fs.existsSync(path.join(projectDir, "package-lock.json")))
+                detected.push("- Package manager: npm");
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    // Detect directory structure
+    const topDirs = [];
+    try {
+        const entries = fs.readdirSync(projectDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+                topDirs.push(entry.name);
+            }
+        }
+        if (topDirs.length > 0)
+            detected.push(`- Top-level directories: ${topDirs.join(", ")}`);
+    }
+    catch {
+        // Ignore
+    }
+    // Detect src structure
+    const srcDir = path.join(projectDir, "src");
+    if (fs.existsSync(srcDir)) {
+        try {
+            const srcEntries = fs.readdirSync(srcDir, { withFileTypes: true });
+            const srcDirs = srcEntries.filter((e) => e.isDirectory()).map((e) => e.name);
+            if (srcDirs.length > 0)
+                detected.push(`- src/ structure: ${srcDirs.join(", ")}`);
+        }
+        catch {
+            // Ignore
+        }
+    }
+    if (detected.length > 0) {
+        const content = `# Architecture (auto-detected ${timestamp})\n\n## Overview\n${detected.join("\n")}\n`;
+        fs.writeFileSync(archPath, content);
+        logger.info(`Auto-detected architecture (${detected.length} items)`);
+    }
+}

package/dist/logger.d.ts

@@ -0,0 +1,14 @@
+export declare const logger: {
+    debug: (msg: string) => void;
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+};
+export declare function createStageLogger(stage: string, taskId?: string): {
+    debug: (msg: string) => void;
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+};
+export declare function ciGroup(title: string): void;
+export declare function ciGroupEnd(): void;

package/dist/logger.js

@@ -0,0 +1,51 @@
+const isCI = !!process.env.GITHUB_ACTIONS;
+const LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+function getLevel() {
+    const env = process.env.LOG_LEVEL;
+    return LEVELS[env ?? "info"] ?? LEVELS.info;
+}
+function timestamp() {
+    return new Date().toISOString().slice(11, 19);
+}
+function log(level, msg) {
+    if (LEVELS[level] < getLevel())
+        return;
+    const prefix = `[${timestamp()}] ${level.toUpperCase().padEnd(5)}`;
+    if (level === "error") {
+        console.error(`${prefix} ${msg}`);
+    }
+    else if (level === "warn") {
+        console.warn(`${prefix} ${msg}`);
+    }
+    else {
+        console.log(`${prefix} ${msg}`);
+    }
+}
+export const logger = {
+    debug: (msg) => log("debug", msg),
+    info: (msg) => log("info", msg),
+    warn: (msg) => log("warn", msg),
+    error: (msg) => log("error", msg),
+};
+export function createStageLogger(stage, taskId) {
+    const prefix = taskId ? `[${stage}:${taskId}]` : `[${stage}]`;
+    return {
+        debug: (msg) => logger.debug(`${prefix} ${msg}`),
+        info: (msg) => logger.info(`${prefix} ${msg}`),
+        warn: (msg) => logger.warn(`${prefix} ${msg}`),
+        error: (msg) => logger.error(`${prefix} ${msg}`),
+    };
+}
+export function ciGroup(title) {
+    if (isCI)
+        process.stdout.write(`::group::${title}\n`);
+}
+export function ciGroupEnd() {
+    if (isCI)
+        process.stdout.write(`::endgroup::\n`);
+}

package/dist/memory.d.ts

@@ -0,0 +1 @@
+export declare function readProjectMemory(projectDir: string): string;

package/dist/memory.js

@@ -0,0 +1,20 @@
+import * as fs from "fs";
+import * as path from "path";
+export function readProjectMemory(projectDir) {
+    const memoryDir = path.join(projectDir, ".kody", "memory");
+    if (!fs.existsSync(memoryDir))
+        return "";
+    const files = fs.readdirSync(memoryDir).filter((f) => f.endsWith(".md")).sort();
+    if (files.length === 0)
+        return "";
+    const sections = [];
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(memoryDir, file), "utf-8").trim();
+        if (content) {
+            sections.push(`## ${file.replace(".md", "")}\n${content}`);
+        }
+    }
+    if (sections.length === 0)
+        return "";
+    return `# Project Memory\n\n${sections.join("\n\n")}\n`;
+}

package/dist/observer.d.ts

@@ -0,0 +1,9 @@
+import type { AgentRunner } from "./types.js";
+export type FailureClassification = "fixable" | "infrastructure" | "pre-existing" | "retry" | "abort";
+export interface DiagnosisResult {
+    classification: FailureClassification;
+    reason: string;
+    resolution: string;
+}
+export declare function diagnoseFailure(stageName: string, errorOutput: string, modifiedFiles: string[], runner: AgentRunner, model: string): Promise<DiagnosisResult>;
+export declare function getModifiedFiles(projectDir: string): string[];

package/dist/observer.js

@@ -0,0 +1,80 @@
+import { execFileSync } from "child_process";
+import { logger } from "./logger.js";
+const DIAGNOSIS_PROMPT = `You are a pipeline failure diagnosis agent. Analyze the error and classify it.
+
+Output ONLY valid JSON. No markdown fences. No explanation.
+
+{
+  "classification": "fixable | infrastructure | pre-existing | retry | abort",
+  "reason": "One sentence explaining what went wrong",
+  "resolution": "Specific instructions for fixing (if fixable) or what the user needs to do (if infrastructure)"
+}
+
+Classification rules:
+- fixable: Error is in code that was just written/modified. The resolution should describe exactly what to change.
+- infrastructure: External dependency not available (database, API, service). The resolution should say what the user needs to set up.
+- pre-existing: Error exists in code that was NOT modified. Safe to skip. The resolution should note which files.
+- retry: Transient error (network timeout, rate limit, flaky test). Worth retrying once.
+- abort: Unrecoverable error (permission denied, corrupted state, out of disk). Pipeline should stop.
+
+Error context:
+`;
+export async function diagnoseFailure(stageName, errorOutput, modifiedFiles, runner, model) {
+    const context = [
+        `Stage: ${stageName}`,
+        ``,
+        `Error output:`,
+        errorOutput.slice(-2000), // Last 2000 chars of error
+        ``,
+        modifiedFiles.length > 0
+            ? `Files modified by build stage:\n${modifiedFiles.map((f) => `- ${f}`).join("\n")}`
+            : "No files were modified (build may not have run yet).",
+    ].join("\n");
+    const prompt = DIAGNOSIS_PROMPT + context;
+    try {
+        const result = await runner.run("diagnosis", prompt, model, 30_000, // 30s timeout — this should be fast
+        "");
+        if (result.outcome === "completed" && result.output) {
+            const cleaned = result.output
+                .replace(/^```json\s*\n?/m, "")
+                .replace(/\n?```\s*$/m, "")
+                .trim();
+            const parsed = JSON.parse(cleaned);
+            const validClassifications = [
+                "fixable", "infrastructure", "pre-existing", "retry", "abort",
+            ];
+            if (validClassifications.includes(parsed.classification)) {
+                logger.info(`  Diagnosis: ${parsed.classification} — ${parsed.reason}`);
+                return {
+                    classification: parsed.classification,
+                    reason: parsed.reason ?? "Unknown reason",
+                    resolution: parsed.resolution ?? "",
+                };
+            }
+        }
+    }
+    catch (err) {
+        logger.warn(`  Diagnosis error: ${err instanceof Error ? err.message : err}`);
+    }
+    // Default: assume fixable (safest — will attempt autofix)
+    logger.warn("  Diagnosis failed — defaulting to fixable");
+    return {
+        classification: "fixable",
+        reason: "Could not diagnose failure",
+        resolution: errorOutput.slice(-500),
+    };
+}
+export function getModifiedFiles(projectDir) {
+    try {
+        const output = execFileSync("git", ["diff", "--name-only", "HEAD~1"], {
+            encoding: "utf-8",
+            cwd: projectDir,
+            timeout: 5000,
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        return output ? output.split("\n").filter(Boolean) : [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/pipeline/complexity.d.ts

@@ -0,0 +1,3 @@
+import type { StageDefinition } from "../types.js";
+export declare function filterByComplexity(stages: StageDefinition[], complexity: string): StageDefinition[];
+export declare function isValidComplexity(value: string): boolean;