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

package/dist/pipeline/complexity.js

@@ -1,12 +0,0 @@
-const COMPLEXITY_SKIP = {
-    low: ["plan", "review", "review-fix"],
-    medium: ["review-fix"],
-    high: [],
-};
-export function filterByComplexity(stages, complexity) {
-    const skip = COMPLEXITY_SKIP[complexity] ?? [];
-    return stages.filter((s) => !skip.includes(s.name));
-}
-export function isValidComplexity(value) {
-    return value in COMPLEXITY_SKIP;
-}

package/dist/pipeline/executor-registry.d.ts

@@ -1,3 +0,0 @@
-import type { StageName, StageDefinition, StageResult, PipelineContext } from "../types.js";
-export type StageExecutor = (ctx: PipelineContext, def: StageDefinition) => StageResult | Promise<StageResult>;
-export declare function getExecutor(name: StageName): StageExecutor;

package/dist/pipeline/executor-registry.js

@@ -1,20 +0,0 @@
-import { executeAgentStage } from "../stages/agent.js";
-import { executeVerifyWithAutofix } from "../stages/verify.js";
-import { executeReviewWithFix } from "../stages/review.js";
-import { executeShipStage } from "../stages/ship.js";
-const EXECUTOR_REGISTRY = {
-    taskify: executeAgentStage,
-    plan: executeAgentStage,
-    build: executeAgentStage,
-    verify: executeVerifyWithAutofix,
-    review: executeReviewWithFix,
-    "review-fix": executeAgentStage,
-    ship: executeShipStage,
-};
-export function getExecutor(name) {
-    const executor = EXECUTOR_REGISTRY[name];
-    if (!executor) {
-        throw new Error(`No executor registered for stage: ${name}`);
-    }
-    return executor;
-}

package/dist/pipeline/hooks.d.ts

@@ -1,17 +0,0 @@
-import type { StageDefinition, PipelineStatus, PipelineContext } from "../types.js";
-export declare function applyPreStageLabel(ctx: PipelineContext, def: StageDefinition): void;
-/**
- * Check for clarifying questions after taskify/plan.
- * Returns the paused PipelineStatus if pipeline should stop, null to continue.
- */
-export declare function checkQuestionsAfterStage(ctx: PipelineContext, def: StageDefinition, state: PipelineStatus): PipelineStatus | null;
-/**
- * Auto-detect complexity from task.json after taskify.
- * Returns new complexity + activeStages if detected, null otherwise.
- */
-export declare function autoDetectComplexity(ctx: PipelineContext, def: StageDefinition): {
-    complexity: "low" | "medium" | "high";
-    activeStages: StageDefinition[];
-} | null;
-export declare function commitAfterStage(ctx: PipelineContext, def: StageDefinition): void;
-export declare function postSkippedStagesComment(ctx: PipelineContext, complexity: string, activeStages: StageDefinition[]): void;

package/dist/pipeline/hooks.js

@@ -1,110 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { STAGES } from "../definitions.js";
-import { setLifecycleLabel, setLabel, postComment } from "../github-api.js";
-import { commitAll } from "../git-utils.js";
-import { checkForQuestions } from "./questions.js";
-import { filterByComplexity, isValidComplexity } from "./complexity.js";
-import { writeState } from "./state.js";
-import { logger } from "../logger.js";
-// ─── Pre-stage ──────────────────────────────────────────────────────────────
-export function applyPreStageLabel(ctx, def) {
-    if (!ctx.input.issueNumber || ctx.input.local)
-        return;
-    if (def.name === "build")
-        setLifecycleLabel(ctx.input.issueNumber, "building");
-    if (def.name === "review")
-        setLifecycleLabel(ctx.input.issueNumber, "review");
-}
-// ─── Post-stage (success) ───────────────────────────────────────────────────
-/**
- * Check for clarifying questions after taskify/plan.
- * Returns the paused PipelineStatus if pipeline should stop, null to continue.
- */
-export function checkQuestionsAfterStage(ctx, def, state) {
-    if (def.name !== "taskify" && def.name !== "plan")
-        return null;
-    if (ctx.input.dryRun)
-        return null;
-    const paused = checkForQuestions(ctx, def.name);
-    if (!paused)
-        return null;
-    state.state = "failed";
-    state.stages[def.name] = {
-        ...state.stages[def.name],
-        state: "completed",
-        error: "paused: waiting for answers",
-    };
-    writeState(state, ctx.taskDir);
-    logger.info(`  Pipeline paused — questions posted on issue`);
-    return state;
-}
-/**
- * Auto-detect complexity from task.json after taskify.
- * Returns new complexity + activeStages if detected, null otherwise.
- */
-export function autoDetectComplexity(ctx, def) {
-    if (def.name !== "taskify")
-        return null;
-    if (ctx.input.complexity)
-        return null;
-    try {
-        const taskJsonPath = path.join(ctx.taskDir, "task.json");
-        if (!fs.existsSync(taskJsonPath))
-            return null;
-        const raw = fs.readFileSync(taskJsonPath, "utf-8");
-        const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
-        const taskJson = JSON.parse(cleaned);
-        if (!taskJson.risk_level || !isValidComplexity(taskJson.risk_level))
-            return null;
-        const complexity = taskJson.risk_level;
-        const activeStages = filterByComplexity(STAGES, complexity);
-        logger.info(`  Complexity auto-detected: ${complexity} (${activeStages.map(s => s.name).join(" → ")})`);
-        if (ctx.input.issueNumber && !ctx.input.local) {
-            try {
-                setLifecycleLabel(ctx.input.issueNumber, complexity);
-            }
-            catch { /* ignore */ }
-            if (taskJson.task_type) {
-                try {
-                    setLabel(ctx.input.issueNumber, `kody:${taskJson.task_type}`);
-                }
-                catch { /* ignore */ }
-            }
-        }
-        return { complexity, activeStages };
-    }
-    catch {
-        return null;
-    }
-}
-export function commitAfterStage(ctx, def) {
-    if (ctx.input.dryRun || !ctx.input.issueNumber)
-        return;
-    if (def.name === "build") {
-        try {
-            commitAll(`feat(${ctx.taskId}): implement task`, ctx.projectDir);
-        }
-        catch { /* ignore */ }
-    }
-    if (def.name === "review-fix") {
-        try {
-            commitAll(`fix(${ctx.taskId}): address review`, ctx.projectDir);
-        }
-        catch { /* ignore */ }
-    }
-}
-// ─── Skip logic ─────────────────────────────────────────────────────────────
-export function postSkippedStagesComment(ctx, complexity, activeStages) {
-    if (!ctx.input.issueNumber || ctx.input.local || ctx.input.dryRun)
-        return;
-    const skipped = STAGES
-        .filter(s => !activeStages.find(a => a.name === s.name))
-        .map(s => s.name);
-    if (skipped.length === 0)
-        return;
-    try {
-        postComment(ctx.input.issueNumber, `⚡ **Complexity: ${complexity}** — skipping ${skipped.join(", ")} (not needed for ${complexity}-risk tasks)`);
-    }
-    catch { /* ignore */ }
-}

package/dist/pipeline/questions.d.ts

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

package/dist/pipeline/questions.js

@@ -1,44 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { postComment, setLifecycleLabel } from "../github-api.js";
-export function checkForQuestions(ctx, stageName) {
-    if (ctx.input.local || !ctx.input.issueNumber)
-        return false;
-    try {
-        if (stageName === "taskify") {
-            const taskJsonPath = path.join(ctx.taskDir, "task.json");
-            if (!fs.existsSync(taskJsonPath))
-                return false;
-            const raw = fs.readFileSync(taskJsonPath, "utf-8");
-            const cleaned = raw.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
-            const taskJson = JSON.parse(cleaned);
-            if (taskJson.questions && Array.isArray(taskJson.questions) && taskJson.questions.length > 0) {
-                const body = `🤔 **Kody has questions before proceeding:**\n\n${taskJson.questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}\n\nReply with \`@kody approve\` and your answers in the comment body.`;
-                postComment(ctx.input.issueNumber, body);
-                setLifecycleLabel(ctx.input.issueNumber, "waiting");
-                return true;
-            }
-        }
-        if (stageName === "plan") {
-            const planPath = path.join(ctx.taskDir, "plan.md");
-            if (!fs.existsSync(planPath))
-                return false;
-            const plan = fs.readFileSync(planPath, "utf-8");
-            const questionsMatch = plan.match(/## Questions\s*\n([\s\S]*?)(?=\n## |\n*$)/);
-            if (questionsMatch) {
-                const questionsText = questionsMatch[1].trim();
-                const questions = questionsText.split("\n").filter((l) => l.startsWith("- ")).map((l) => l.slice(2));
-                if (questions.length > 0) {
-                    const body = `🏗️ **Kody has architecture questions:**\n\n${questions.map((q, i) => `${i + 1}. ${q}`).join("\n")}\n\nReply with \`@kody approve\` and your answers in the comment body.`;
-                    postComment(ctx.input.issueNumber, body);
-                    setLifecycleLabel(ctx.input.issueNumber, "waiting");
-                    return true;
-                }
-            }
-        }
-    }
-    catch {
-        // Don't fail pipeline on question parsing errors
-    }
-    return false;
-}

package/dist/pipeline/runner-selection.d.ts

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

package/dist/pipeline/runner-selection.js

@@ -1,13 +0,0 @@
-import { getProjectConfig } from "../config.js";
-export function getRunnerForStage(ctx, stageName) {
-    const config = getProjectConfig();
-    const runnerName = config.agent.stageRunners?.[stageName] ??
-        config.agent.defaultRunner ??
-        Object.keys(ctx.runners)[0] ??
-        "claude";
-    const runner = ctx.runners[runnerName];
-    if (!runner) {
-        throw new Error(`Runner "${runnerName}" not found for stage ${stageName}. Available: ${Object.keys(ctx.runners).join(", ")}`);
-    }
-    return runner;
-}

package/dist/pipeline/state.d.ts

@@ -1,4 +0,0 @@
-import type { PipelineStatus } from "../types.js";
-export declare function loadState(taskId: string, taskDir: string): PipelineStatus | null;
-export declare function writeState(state: PipelineStatus, taskDir: string): void;
-export declare function initState(taskId: string): PipelineStatus;

package/dist/pipeline/state.js

@@ -1,37 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { STAGES } from "../definitions.js";
-export function loadState(taskId, taskDir) {
-    const p = path.join(taskDir, "status.json");
-    if (!fs.existsSync(p))
-        return null;
-    try {
-        const raw = JSON.parse(fs.readFileSync(p, "utf-8"));
-        if (raw.taskId === taskId)
-            return raw;
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-export function writeState(state, taskDir) {
-    const updated = {
-        ...state,
-        updatedAt: new Date().toISOString(),
-    };
-    const target = path.join(taskDir, "status.json");
-    const tmp = target + ".tmp";
-    fs.writeFileSync(tmp, JSON.stringify(updated, null, 2));
-    fs.renameSync(tmp, target);
-    // Sync the caller's reference
-    state.updatedAt = updated.updatedAt;
-}
-export function initState(taskId) {
-    const stages = {};
-    for (const stage of STAGES) {
-        stages[stage.name] = { state: "pending", retries: 0 };
-    }
-    const now = new Date().toISOString();
-    return { taskId, state: "running", stages, createdAt: now, updatedAt: now };
-}

package/dist/pipeline.d.ts

@@ -1,3 +0,0 @@
-import type { PipelineStatus, PipelineContext } from "./types.js";
-export declare function runPipeline(ctx: PipelineContext): Promise<PipelineStatus>;
-export declare function printStatus(taskId: string, taskDir: string): void;

package/dist/pipeline.js

@@ -1,213 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { STAGES } from "./definitions.js";
-import { ensureFeatureBranch, syncWithDefault } from "./git-utils.js";
-import { setLifecycleLabel } from "./github-api.js";
-import { logger, ciGroup, ciGroupEnd } from "./logger.js";
-import { loadState, writeState, initState } from "./pipeline/state.js";
-import { filterByComplexity } from "./pipeline/complexity.js";
-import { getExecutor } from "./pipeline/executor-registry.js";
-import { applyPreStageLabel, checkQuestionsAfterStage, autoDetectComplexity, commitAfterStage, postSkippedStagesComment, } from "./pipeline/hooks.js";
-import { autoLearn } from "./learning/auto-learn.js";
-import { runRetrospective } from "./retrospective.js";
-// ─── Helpers ────────────────────────────────────────────────────────────────
-function ensureFeatureBranchIfNeeded(ctx) {
-    if (!ctx.input.issueNumber || ctx.input.dryRun)
-        return;
-    try {
-        const taskMdPath = path.join(ctx.taskDir, "task.md");
-        const title = fs.existsSync(taskMdPath)
-            ? fs.readFileSync(taskMdPath, "utf-8").split("\n")[0].slice(0, 50)
-            : ctx.taskId;
-        ensureFeatureBranch(ctx.input.issueNumber, title, ctx.projectDir);
-        syncWithDefault(ctx.projectDir);
-    }
-    catch (err) {
-        logger.warn(`  Failed to create/sync feature branch: ${err}`);
-    }
-}
-// ─── Lock ───────────────────────────────────────────────────────────────────
-function acquireLock(taskDir) {
-    const lockPath = path.join(taskDir, ".lock");
-    if (fs.existsSync(lockPath)) {
-        try {
-            const pid = parseInt(fs.readFileSync(lockPath, "utf-8").trim(), 10);
-            try {
-                process.kill(pid, 0);
-                throw new Error(`Pipeline already running (PID ${pid})`);
-            }
-            catch (e) {
-                if (e.code !== "ESRCH")
-                    throw e;
-                // PID not alive — stale lock, safe to overwrite
-            }
-        }
-        catch (e) {
-            if (e instanceof Error && e.message.startsWith("Pipeline already"))
-                throw e;
-            // Corrupt lock file — overwrite
-        }
-    }
-    fs.writeFileSync(lockPath, String(process.pid));
-}
-function releaseLock(taskDir) {
-    try {
-        fs.unlinkSync(path.join(taskDir, ".lock"));
-    }
-    catch { /* ignore */ }
-}
-// ─── Pipeline Loop ──────────────────────────────────────────────────────────
-export async function runPipeline(ctx) {
-    acquireLock(ctx.taskDir);
-    try {
-        return await runPipelineInner(ctx);
-    }
-    finally {
-        releaseLock(ctx.taskDir);
-    }
-}
-async function runPipelineInner(ctx) {
-    const pipelineStartTime = Date.now();
-    let state = loadState(ctx.taskId, ctx.taskDir);
-    if (!state) {
-        state = initState(ctx.taskId);
-        writeState(state, ctx.taskDir);
-    }
-    // Reset for rerun
-    if (state.state !== "running") {
-        state.state = "running";
-        for (const stage of STAGES) {
-            const s = state.stages[stage.name];
-            if (s.state === "running" || s.state === "failed" || s.state === "timeout") {
-                state.stages[stage.name] = { ...s, state: "pending" };
-            }
-        }
-        writeState(state, ctx.taskDir);
-    }
-    const fromStage = ctx.input.fromStage;
-    let startExecution = !fromStage;
-    logger.info(`Pipeline started: ${ctx.taskId}`);
-    logger.info(`Stages: ${STAGES.map((s) => s.name).join(" → ")}`);
-    if (fromStage)
-        logger.info(`Resuming from: ${fromStage}`);
-    if (ctx.input.issueNumber && !ctx.input.local) {
-        const initialPhase = ctx.input.mode === "rerun" ? "building" : "planning";
-        setLifecycleLabel(ctx.input.issueNumber, initialPhase);
-    }
-    ensureFeatureBranchIfNeeded(ctx);
-    let complexity = ctx.input.complexity ?? "high";
-    let activeStages = filterByComplexity(STAGES, complexity);
-    let skippedStagesCommentPosted = false;
-    for (const def of STAGES) {
-        // fromStage skip
-        if (!startExecution) {
-            if (def.name === fromStage) {
-                startExecution = true;
-            }
-            else {
-                continue;
-            }
-        }
-        if (state.stages[def.name].state === "completed") {
-            logger.info(`[${def.name}] already completed, skipping`);
-            continue;
-        }
-        // Complexity skip
-        if (!activeStages.find((s) => s.name === def.name)) {
-            logger.info(`[${def.name}] skipped (complexity: ${complexity})`);
-            state.stages[def.name] = { state: "completed", retries: 0, outputFile: undefined };
-            writeState(state, ctx.taskDir);
-            if (!skippedStagesCommentPosted) {
-                postSkippedStagesComment(ctx, complexity, activeStages);
-                skippedStagesCommentPosted = true;
-            }
-            continue;
-        }
-        ciGroup(`Stage: ${def.name}`);
-        state.stages[def.name] = { state: "running", startedAt: new Date().toISOString(), retries: 0 };
-        writeState(state, ctx.taskDir);
-        logger.info(`[${def.name}] starting...`);
-        applyPreStageLabel(ctx, def);
-        // Execute stage via registry
-        let result;
-        try {
-            result = await getExecutor(def.name)(ctx, def);
-        }
-        catch (error) {
-            result = {
-                outcome: "failed",
-                retries: 0,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-        ciGroupEnd();
-        if (result.outcome === "completed") {
-            state.stages[def.name] = {
-                state: "completed",
-                completedAt: new Date().toISOString(),
-                retries: result.retries,
-                outputFile: result.outputFile,
-            };
-            logger.info(`[${def.name}] ✓ completed`);
-            const paused = checkQuestionsAfterStage(ctx, def, state);
-            if (paused)
-                return paused;
-            const detected = autoDetectComplexity(ctx, def);
-            if (detected) {
-                complexity = detected.complexity;
-                activeStages = detected.activeStages;
-            }
-            commitAfterStage(ctx, def);
-        }
-        else {
-            // Failed or timed out
-            const isTimeout = result.outcome === "timed_out";
-            state.stages[def.name] = {
-                state: isTimeout ? "timeout" : "failed",
-                retries: result.retries,
-                error: isTimeout ? "Stage timed out" : (result.error ?? "Stage failed"),
-            };
-            state.state = "failed";
-            writeState(state, ctx.taskDir);
-            logger.error(`[${def.name}] ${isTimeout ? "⏱ timed out" : `✗ failed: ${result.error}`}`);
-            if (ctx.input.issueNumber && !ctx.input.local) {
-                setLifecycleLabel(ctx.input.issueNumber, "failed");
-            }
-            break;
-        }
-        writeState(state, ctx.taskDir);
-    }
-    const allCompleted = STAGES.every((s) => state.stages[s.name].state === "completed");
-    if (allCompleted) {
-        state.state = "completed";
-        writeState(state, ctx.taskDir);
-        logger.info(`Pipeline completed: ${ctx.taskId}`);
-        if (ctx.input.issueNumber && !ctx.input.local) {
-            setLifecycleLabel(ctx.input.issueNumber, "done");
-        }
-        autoLearn(ctx);
-    }
-    await runRetrospective(ctx, state, pipelineStartTime).catch(() => { });
-    return state;
-}
-// ─── Status Display ─────────────────────────────────────────────────────────
-export function printStatus(taskId, taskDir) {
-    const state = loadState(taskId, taskDir);
-    if (!state) {
-        console.log(`No status found for task ${taskId}`);
-        return;
-    }
-    console.log(`\nTask: ${state.taskId}`);
-    console.log(`State: ${state.state}`);
-    console.log(`Created: ${state.createdAt}`);
-    console.log(`Updated: ${state.updatedAt}\n`);
-    for (const stage of STAGES) {
-        const s = state.stages[stage.name];
-        const icon = s.state === "completed" ? "✓" :
-            s.state === "failed" ? "✗" :
-                s.state === "running" ? "▶" :
-                    s.state === "timeout" ? "⏱" : "○";
-        const extra = s.error ? ` — ${s.error}` : "";
-        console.log(`  ${icon} ${stage.name}: ${s.state}${extra}`);
-    }
-}

package/dist/preflight.d.ts

@@ -1 +0,0 @@
-export declare function runPreflight(): void;

package/dist/preflight.js

@@ -1,69 +0,0 @@
-import { execFileSync } from "child_process";
-import * as fs from "fs";
-import { logger } from "./logger.js";
-function check(name, fn) {
-    try {
-        const detail = fn() ?? undefined;
-        return { name, ok: true, detail };
-    }
-    catch {
-        return { name, ok: false };
-    }
-}
-export function runPreflight() {
-    const checks = [
-        check("claude CLI", () => {
-            const v = execFileSync("claude", ["--version"], {
-                encoding: "utf-8",
-                timeout: 10_000,
-                stdio: ["pipe", "pipe", "pipe"],
-            }).trim();
-            return v;
-        }),
-        check("git repo", () => {
-            execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
-                encoding: "utf-8",
-                timeout: 5_000,
-                stdio: ["pipe", "pipe", "pipe"],
-            });
-        }),
-        check("pnpm", () => {
-            const v = execFileSync("pnpm", ["--version"], {
-                encoding: "utf-8",
-                timeout: 5_000,
-                stdio: ["pipe", "pipe", "pipe"],
-            }).trim();
-            return v;
-        }),
-        check("node >= 18", () => {
-            const v = execFileSync("node", ["--version"], {
-                encoding: "utf-8",
-                timeout: 5_000,
-                stdio: ["pipe", "pipe", "pipe"],
-            }).trim();
-            const major = parseInt(v.replace("v", "").split(".")[0], 10);
-            if (major < 18)
-                throw new Error(`Node ${v} < 18`);
-            return v;
-        }),
-        check("gh CLI", () => {
-            const v = execFileSync("gh", ["--version"], {
-                encoding: "utf-8",
-                timeout: 5_000,
-                stdio: ["pipe", "pipe", "pipe"],
-            }).trim().split("\n")[0];
-            return v;
-        }),
-        check("package.json", () => {
-            if (!fs.existsSync("package.json"))
-                throw new Error("not found");
-        }),
-    ];
-    const failed = checks.filter((c) => !c.ok);
-    for (const c of checks) {
-        logger.info(`  ${c.ok ? "✓" : "✗"} ${c.name}${c.detail ? ` (${c.detail})` : ""}`);
-    }
-    if (failed.length > 0) {
-        throw new Error(`Preflight failed: ${failed.map((c) => c.name).join(", ")}`);
-    }
-}

package/dist/retrospective.d.ts

@@ -1,26 +0,0 @@
-import type { StageName, PipelineStatus, PipelineContext } from "./types.js";
-export interface RetrospectiveEntry {
-    timestamp: string;
-    taskId: string;
-    outcome: "completed" | "failed";
-    durationMs: number;
-    stageResults: Record<string, {
-        state: string;
-        retries: number;
-        durationMs?: number;
-        error?: string;
-    }>;
-    failedStage?: StageName;
-    observation: string;
-    patternMatch: string | null;
-    suggestion: string;
-    pipelineFlaw: {
-        component: string;
-        issue: string;
-        evidence: string;
-    } | null;
-}
-export declare function collectRunContext(ctx: PipelineContext, state: PipelineStatus, pipelineStartTime: number): string;
-export declare function readPreviousRetrospectives(projectDir: string, limit?: number): RetrospectiveEntry[];
-export declare function appendRetrospectiveEntry(projectDir: string, entry: RetrospectiveEntry): void;
-export declare function runRetrospective(ctx: PipelineContext, state: PipelineStatus, pipelineStartTime: number): Promise<void>;