@kody-ade/kody-engine-lite 0.1.104 → 0.1.106

package/dist/git-utils.js

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

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

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

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

package/dist/kody-utils.js

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

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

package/dist/learning/auto-learn.js

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

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

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

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

package/dist/memory.js

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

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

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

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