@kody-ade/kody-engine-lite 0.1.60 → 0.1.62

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+export type StageName = "taskify" | "plan" | "build" | "verify" | "review" | "review-fix" | "ship";
+export type StageType = "agent" | "gate" | "deterministic";
+export type PipelineState = "pending" | "running" | "completed" | "failed" | "timeout";
+export interface StageDefinition {
+    name: StageName;
+    type: StageType;
+    modelTier: "cheap" | "mid" | "strong";
+    timeout: number;
+    maxRetries: number;
+    outputFile?: string;
+    retryWithAgent?: string;
+}
+export interface StageState {
+    state: PipelineState;
+    startedAt?: string;
+    completedAt?: string;
+    retries: number;
+    error?: string;
+    outputFile?: string;
+}
+export interface PipelineStatus {
+    taskId: string;
+    state: "running" | "completed" | "failed";
+    stages: Record<StageName, StageState>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface StageResult {
+    outcome: "completed" | "failed" | "timed_out";
+    outputFile?: string;
+    error?: string;
+    retries: number;
+}
+export interface AgentResult {
+    outcome: "completed" | "failed" | "timed_out";
+    output?: string;
+    error?: string;
+}
+export interface AgentRunnerOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface AgentRunner {
+    run(stageName: string, prompt: string, model: string, timeout: number, taskDir: string, options?: AgentRunnerOptions): Promise<AgentResult>;
+    healthCheck(): Promise<boolean>;
+}
+export interface PipelineContext {
+    taskId: string;
+    taskDir: string;
+    projectDir: string;
+    runners: Record<string, AgentRunner>;
+    input: {
+        mode: "full" | "rerun" | "status";
+        fromStage?: string;
+        dryRun?: boolean;
+        issueNumber?: number;
+        feedback?: string;
+        local?: boolean;
+        complexity?: "low" | "medium" | "high";
+    };
+}

package/dist/types.js

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

package/dist/validators.d.ts

@@ -0,0 +1,8 @@
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+}
+export declare function stripFences(content: string): string;
+export declare function validateTaskJson(content: string): ValidationResult;
+export declare function validatePlanMd(content: string): ValidationResult;
+export declare function validateReviewMd(content: string): ValidationResult;

package/dist/validators.js

@@ -0,0 +1,42 @@
+const REQUIRED_TASK_FIELDS = [
+    "task_type",
+    "title",
+    "description",
+    "scope",
+    "risk_level",
+];
+export function stripFences(content) {
+    return content.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+}
+export function validateTaskJson(content) {
+    try {
+        const parsed = JSON.parse(stripFences(content));
+        for (const field of REQUIRED_TASK_FIELDS) {
+            if (!(field in parsed)) {
+                return { valid: false, error: `Missing field: ${field}` };
+            }
+        }
+        return { valid: true };
+    }
+    catch (err) {
+        return {
+            valid: false,
+            error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+export function validatePlanMd(content) {
+    if (content.length < 10) {
+        return { valid: false, error: "Plan is too short (< 10 chars)" };
+    }
+    if (!/^##\s+\w+/m.test(content)) {
+        return { valid: false, error: "Plan has no markdown h2 sections" };
+    }
+    return { valid: true };
+}
+export function validateReviewMd(content) {
+    if (/pass/i.test(content) || /fail/i.test(content)) {
+        return { valid: true };
+    }
+    return { valid: false, error: "Review must contain 'pass' or 'fail'" };
+}

package/dist/verify-runner.d.ts

@@ -0,0 +1,11 @@
+export interface VerifyResult {
+    pass: boolean;
+    errors: string[];
+    summary: string[];
+}
+/**
+ * Parse a command string into [executable, ...args], respecting quoted arguments.
+ * e.g., 'pnpm -s "test:unit"' → ["pnpm", "-s", "test:unit"]
+ */
+export declare function parseCommand(cmd: string): string[];
+export declare function runQualityGates(taskDir: string, projectRoot?: string): VerifyResult;

package/dist/verify-runner.js

@@ -0,0 +1,110 @@
+import { execFileSync } from "child_process";
+import { getProjectConfig, VERIFY_COMMAND_TIMEOUT_MS } from "./config.js";
+import { logger } from "./logger.js";
+function isExecError(err) {
+    return typeof err === "object" && err !== null;
+}
+/**
+ * Parse a command string into [executable, ...args], respecting quoted arguments.
+ * e.g., 'pnpm -s "test:unit"' → ["pnpm", "-s", "test:unit"]
+ */
+export function parseCommand(cmd) {
+    const parts = [];
+    let current = "";
+    let inQuote = null;
+    for (const ch of cmd) {
+        if (inQuote) {
+            if (ch === inQuote) {
+                inQuote = null;
+            }
+            else {
+                current += ch;
+            }
+        }
+        else if (ch === '"' || ch === "'") {
+            inQuote = ch;
+        }
+        else if (/\s/.test(ch)) {
+            if (current) {
+                parts.push(current);
+                current = "";
+            }
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current)
+        parts.push(current);
+    if (inQuote)
+        logger.warn(`Unclosed quote in command: ${cmd}`);
+    return parts;
+}
+function runCommand(cmd, cwd, timeout) {
+    const parts = parseCommand(cmd);
+    if (parts.length === 0) {
+        return { success: true, output: "", timedOut: false };
+    }
+    try {
+        const output = execFileSync(parts[0], parts.slice(1), {
+            cwd,
+            timeout,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, FORCE_COLOR: "0" },
+        });
+        return { success: true, output: output ?? "", timedOut: false };
+    }
+    catch (err) {
+        const stdout = isExecError(err) ? err.stdout ?? "" : "";
+        const stderr = isExecError(err) ? err.stderr ?? "" : "";
+        const killed = isExecError(err) ? !!err.killed : false;
+        return { success: false, output: `${stdout}${stderr}`, timedOut: killed };
+    }
+}
+function parseErrors(output) {
+    const errors = [];
+    for (const line of output.split("\n")) {
+        if (/error|Error|ERROR|failed|Failed|FAIL|warning:|Warning:|WARN/i.test(line)) {
+            errors.push(line.slice(0, 500));
+        }
+    }
+    return errors;
+}
+function extractSummary(output, cmdName) {
+    const summaryPatterns = /Test Suites|Tests|Coverage|ERRORS|FAILURES|success|completed/i;
+    const lines = output.split("\n").filter((l) => summaryPatterns.test(l));
+    return lines.slice(-3).map((l) => `[${cmdName}] ${l.trim()}`);
+}
+export function runQualityGates(taskDir, projectRoot) {
+    const config = getProjectConfig();
+    const cwd = projectRoot ?? process.cwd();
+    const allErrors = [];
+    const allSummary = [];
+    let allPass = true;
+    const commands = [
+        { name: "typecheck", cmd: config.quality.typecheck },
+        { name: "test", cmd: config.quality.testUnit },
+    ];
+    if (config.quality.lint) {
+        commands.push({ name: "lint", cmd: config.quality.lint });
+    }
+    for (const { name, cmd } of commands) {
+        if (!cmd)
+            continue;
+        logger.info(`  Running ${name}: ${cmd}`);
+        const result = runCommand(cmd, cwd, VERIFY_COMMAND_TIMEOUT_MS);
+        if (result.timedOut) {
+            allErrors.push(`${name}: timed out after ${VERIFY_COMMAND_TIMEOUT_MS / 1000}s`);
+            allPass = false;
+            continue;
+        }
+        if (!result.success) {
+            allPass = false;
+            const errors = parseErrors(result.output);
+            allErrors.push(...errors.map((e) => `[${name}] ${e}`));
+        }
+        allSummary.push(...extractSummary(result.output, name));
+    }
+    return { pass: allPass, errors: allErrors, summary: allSummary };
+}

package/kody.config.schema.json

@@ -23,11 +23,6 @@
           "description": "Auto-fix lint command, run when verify fails (e.g., 'pnpm lint:fix')",
           "default": ""
         },
-        "format": {
-          "type": "string",
-          "description": "Format check command (e.g., 'pnpm format:check'). Empty to skip.",
-          "default": ""
-        },
         "formatFix": {
           "type": "string",
           "description": "Auto-fix format command, run when verify fails (e.g., 'pnpm format')",
@@ -49,14 +44,6 @@
           "type": "string",
           "description": "Default branch for PR base and branch syncing (e.g., 'main', 'dev')",
           "default": "dev"
-        },
-        "userEmail": {
-          "type": "string",
-          "description": "Git user email for CI commits (optional, defaults to github-actions bot)"
-        },
-        "userName": {
-          "type": "string",
-          "description": "Git user name for CI commits (optional, defaults to github-actions bot)"
         }
       },
       "additionalProperties": false
@@ -76,50 +63,27 @@
       },
       "additionalProperties": false
     },
-    "paths": {
-      "type": "object",
-      "description": "File path configuration",
-      "properties": {
-        "taskDir": {
-          "type": "string",
-          "description": "Directory for pipeline artifacts and state (committed to branch)",
-          "default": ".kody/tasks"
-        }
-      },
-      "additionalProperties": false
-    },
     "agent": {
       "type": "object",
       "description": "Agent execution configuration",
       "properties": {
-        "runner": {
-          "type": "string",
-          "description": "Agent runner type",
-          "enum": ["claude-code"],
-          "default": "claude-code"
-        },
-        "defaultRunner": {
-          "type": "string",
-          "description": "Name of the default runner to use",
-          "default": "claude"
-        },
         "modelMap": {
           "type": "object",
-          "description": "Maps model tiers to actual model names. Use LiteLLM aliases when litellmUrl is set.",
+          "description": "Maps model tiers to actual model names. When provider is set, values should be the provider's model names.",
           "properties": {
             "cheap": {
               "type": "string",
-              "description": "Fast/cheap model for taskify stage (e.g., 'haiku' or LiteLLM alias)",
+              "description": "Fast/cheap model for taskify stage (e.g., 'haiku' or provider model name)",
               "default": "haiku"
             },
             "mid": {
               "type": "string",
-              "description": "Mid-tier model for build, review-fix, autofix (e.g., 'sonnet' or LiteLLM alias)",
+              "description": "Mid-tier model for build, review-fix, autofix (e.g., 'sonnet' or provider model name)",
               "default": "sonnet"
             },
             "strong": {
               "type": "string",
-              "description": "Strongest model for plan, review — deep reasoning (e.g., 'opus' or LiteLLM alias)",
+              "description": "Strongest model for plan, review — deep reasoning (e.g., 'opus' or provider model name)",
               "default": "opus"
             }
           },
@@ -130,15 +94,10 @@
           "description": "LLM provider name. When set (and not 'anthropic'), engine auto-starts LiteLLM proxy and routes model calls to this provider. modelMap values should be the provider's model names.",
           "examples": ["anthropic", "minimax", "openai", "google"]
         },
-        "litellmUrl": {
+        "defaultRunner": {
           "type": "string",
-          "description": "(Deprecated) Use 'provider' instead. LiteLLM proxy URL for manual setup.",
-          "examples": ["http://localhost:4000"]
-        },
-        "usePerStageRouting": {
-          "type": "boolean",
-          "description": "When true, uses stage name as the LiteLLM model alias instead of modelMap tier",
-          "default": false
+          "description": "Name of the default runner when multiple runners are configured (advanced)",
+          "default": "claude"
         },
         "runners": {
           "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.60",
+  "version": "0.1.62",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",