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

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

@@ -128,6 +128,72 @@
         }
       },
       "additionalProperties": false
+    },
+    "mcp": {
+      "type": "object",
+      "description": "MCP (Model Context Protocol) server configuration. Enables external tools like browser automation.",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "Enable MCP server integration",
+          "default": false
+        },
+        "servers": {
+          "type": "object",
+          "description": "Named MCP server definitions. Each key is a server name.",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "command": {
+                "type": "string",
+                "description": "Command to start the MCP server (e.g., 'npx')"
+              },
+              "args": {
+                "type": "array",
+                "items": { "type": "string" },
+                "description": "Command arguments"
+              },
+              "env": {
+                "type": "object",
+                "additionalProperties": { "type": "string" },
+                "description": "Environment variables for the server process"
+              }
+            },
+            "required": ["command"]
+          }
+        },
+        "stages": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Stages that can use MCP tools. Defaults to [\"build\", \"verify\", \"review\", \"review-fix\"]",
+          "default": ["build", "verify", "review", "review-fix"]
+        },
+        "devServer": {
+          "type": "object",
+          "description": "Dev server configuration for browser tool verification",
+          "properties": {
+            "command": {
+              "type": "string",
+              "description": "Command to start the dev server (e.g., 'pnpm dev')"
+            },
+            "url": {
+              "type": "string",
+              "description": "URL where the dev server will be accessible (e.g., 'http://localhost:3000')"
+            },
+            "readyPattern": {
+              "type": "string",
+              "description": "Regex pattern to match in stdout when server is ready. Default: 'Ready in|compiled|started server|Local:'"
+            },
+            "readyTimeout": {
+              "type": "number",
+              "description": "Seconds to wait for the server to be ready. Default: 30"
+            }
+          },
+          "required": ["command", "url"]
+        }
+      },
+      "required": ["enabled", "servers"],
+      "additionalProperties": false
     }
   },
   "additionalProperties": false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",
@@ -13,13 +13,6 @@
     "templates",
     "kody.config.schema.json"
   ],
-  "scripts": {
-    "kody": "tsx src/entry.ts",
-    "build": "tsup",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "pnpm build"
-  },
   "dependencies": {
     "dotenv": "^16.4.7"
   },
@@ -32,5 +25,11 @@
   },
   "engines": {
     "node": ">=22"
+  },
+  "scripts": {
+    "kody": "tsx src/entry.ts",
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/prompts/taskify.md

@@ -18,9 +18,14 @@ Required JSON format:
   "description": "Clear description of what the task requires",
   "scope": ["list", "of", "exact/file/paths", "affected"],
   "risk_level": "low | medium | high",
+  "hasUI": true,
   "questions": []
 }
 
+hasUI heuristics:
+- true: task touches frontend files (.tsx, .jsx, .vue, .svelte, .css, .scss, .html), UI components, pages, layouts, or styles
+- false: task is purely backend, CLI, API, database, config, docs, or infrastructure
+
 Risk level heuristics:
 - low: single file change, no breaking changes, docs, config, isolated scripts, test additions, style changes
 - medium: multiple files, possible side effects, API changes, new dependencies, refactoring existing logic

package/templates/kody.yml

@@ -224,6 +224,9 @@ jobs:
       - name: Install Claude Code CLI
         run: npm install -g @anthropic-ai/claude-code
 
+      - name: Install LiteLLM proxy
+        run: pip install 'litellm[proxy]'
+
       - name: Configure git
         run: |
           git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
@@ -232,6 +235,7 @@ jobs:
       - name: Run Kody pipeline
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          MINIMAX_API_KEY: ${{ secrets.MINIMAX_API_KEY }}
           GH_TOKEN: ${{ steps.app-token.outputs.token || secrets.GITHUB_TOKEN }}
           TASK_ID: ${{ github.event.inputs.task_id || needs.parse.outputs.task_id }}
           MODE: ${{ github.event.inputs.mode || needs.parse.outputs.mode || 'full' }}
@@ -254,7 +258,8 @@ jobs:
             [ -n "$TASK_ID" ] && ARGS="$ARGS --task-id $TASK_ID"
             [ -n "$PR_NUMBER" ] && ARGS="$ARGS --pr-number $PR_NUMBER"
             [ -n "$FROM_STAGE" ] && ARGS="$ARGS --from $FROM_STAGE"
-            # FEEDBACK is passed via env var, not CLI arg (avoids shell escaping issues)
+            # FEEDBACK is also passed via env var (avoids shell escaping issues)
+            [ -n "$FEEDBACK" ] && ARGS="$ARGS --feedback \"$FEEDBACK\""
             [ "$DRY_RUN" = "true" ] && ARGS="$ARGS --dry-run"
             kody-engine-lite $CMD $ARGS
           fi