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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",
@@ -13,6 +13,13 @@
     "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"
   },
@@ -25,11 +32,5 @@
   },
   "engines": {
     "node": ">=22"
-  },
-  "scripts": {
-    "kody": "tsx src/entry.ts",
-    "build": "tsup",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
   }
-}
+}

package/prompts/plan.md

@@ -7,7 +7,16 @@ tools: [read, glob, grep]
 
 You are a planning agent following the Superpowers Writing Plans methodology.
 
-Before planning, examine the codebase to understand existing code structure, patterns, and conventions. Use Read, Glob, and Grep.
+## MANDATORY: Pattern Discovery Before Planning
+
+Before writing ANY plan, you MUST search for existing patterns in the codebase:
+
+1. **Find similar implementations** — Grep/Glob for how the same problem is already solved elsewhere. E.g., if the task involves localization, search for how other collections handle localization. If adding auth, find existing auth patterns.
+2. **Reuse existing patterns** — If the codebase already solves a similar problem, your plan MUST follow that pattern unless there's a strong reason not to (document the reason in Questions).
+3. **Check decisions.md** — If `.kody/memory/decisions.md` exists, read it for prior architectural decisions that may apply.
+4. **Never invent when you can reuse** — Proposing a new pattern when an existing one covers the use case is a planning failure.
+
+After pattern discovery, examine the codebase to understand existing code structure, patterns, and conventions. Use Read, Glob, and Grep.
 
 Output a markdown plan. Start with the steps, then optionally add a Questions section at the end.
 
@@ -45,4 +54,12 @@ Questions rules:
 Good questions: "Recommend middleware pattern vs wrapper — middleware is simpler but wrapper allows caching. Approve middleware?"
 Bad questions: "What should I name the function?", "Should I add tests?"
 
+## Pattern Discovery Report
+
+After the plan steps and before Questions, include a brief report of what existing patterns you found and how your plan reuses them:
+
+## Existing Patterns Found
+- <pattern found>: <how it's reused in the plan>
+- <if no existing patterns found, explain what you searched for>
+
 {{TASK_CONTEXT}}

package/templates/kody.yml

@@ -28,12 +28,16 @@ on:
   pull_request_review:
     types: [submitted]
 
+  workflow_run:
+    workflows: ["CI"]
+    types: [completed]
+
   push:
     branches: [main, dev]
     paths: ["src/**", "kody.config.json", "package.json"]
 
 concurrency:
-  group: kody-${{ github.event.inputs.task_id || github.event.issue.number || github.event.pull_request.number || github.sha }}
+  group: kody-${{ github.event.inputs.task_id || github.event.issue.number || github.event.pull_request.number || github.event.workflow_run.id || github.sha }}
   cancel-in-progress: false
 
 permissions:
@@ -56,6 +60,7 @@ jobs:
       issue_number: ${{ steps.parse.outputs.issue_number }}
       pr_number: ${{ steps.parse.outputs.pr_number }}
       feedback: ${{ steps.parse.outputs.feedback }}
+      ci_run_id: ${{ steps.parse.outputs.ci_run_id }}
       valid: ${{ steps.parse.outputs.valid }}
     steps:
       - uses: actions/setup-node@v4
@@ -109,7 +114,7 @@ jobs:
 
           # Validate mode
           case "$MODE" in
-            full|rerun|fix|status|approve|review|bootstrap) ;;
+            full|rerun|fix|fix-ci|status|approve|review|bootstrap) ;;
             *)
               # If first arg isn't a mode, it might be a task-id or nothing
               if [ -n "$MODE" ] && [ "$MODE" != "" ]; then
@@ -139,6 +144,15 @@ jobs:
             # Leave TASK_ID empty — entry.ts finds latest task for issue
           fi
 
+          # fix-ci: extract body as feedback + CI run ID
+          if [ "$MODE" = "fix-ci" ]; then
+            FIX_CI_BODY=$(echo "$BODY" | sed -n '/\(@kody\|\/kody\)\s*fix-ci/,$p' | tail -n +2)
+            if [ -n "$FIX_CI_BODY" ]; then
+              FEEDBACK="$FIX_CI_BODY"
+            fi
+            CI_RUN_ID=$(echo "$FIX_CI_BODY" | grep -oP 'Run ID:\s*\K\d+' || echo "")
+          fi
+
           # Bootstrap mode: set task-id and skip normal pipeline
           if [ "$MODE" = "bootstrap" ]; then
             TASK_ID="bootstrap-$(date +%y%m%d-%H%M%S)"
@@ -170,6 +184,7 @@ jobs:
             echo "$FEEDBACK"
             echo "KODY_EOF"
           } >> $GITHUB_OUTPUT
+          echo "ci_run_id=${CI_RUN_ID:-}" >> $GITHUB_OUTPUT
           echo "valid=true" >> $GITHUB_OUTPUT
 
   # ─── Orchestrate ─────────────────────────────────────────────────────────────
@@ -198,7 +213,7 @@ jobs:
           token: ${{ steps.app-token.outputs.token || secrets.GITHUB_TOKEN }}
 
       - name: Checkout PR branch (for fix/rerun/review on PRs)
-        if: github.event.issue.pull_request && (needs.parse.outputs.mode == 'fix' || needs.parse.outputs.mode == 'rerun' || needs.parse.outputs.mode == 'review')
+        if: github.event.issue.pull_request && (needs.parse.outputs.mode == 'fix' || needs.parse.outputs.mode == 'fix-ci' || needs.parse.outputs.mode == 'rerun' || needs.parse.outputs.mode == 'review')
         env:
           GH_TOKEN: ${{ steps.app-token.outputs.token || secrets.GITHUB_TOKEN }}
         run: |
@@ -243,6 +258,7 @@ jobs:
           ISSUE_NUMBER: ${{ github.event.inputs.issue_number || needs.parse.outputs.issue_number }}
           PR_NUMBER: ${{ needs.parse.outputs.pr_number }}
           FEEDBACK: ${{ github.event.inputs.feedback || needs.parse.outputs.feedback }}
+          CI_RUN_ID: ${{ needs.parse.outputs.ci_run_id }}
           DRY_RUN: ${{ github.event.inputs.dry_run || 'false' }}
           RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
         run: |
@@ -253,6 +269,7 @@ jobs:
             CMD="run"
             [ "$MODE" = "rerun" ] && CMD="rerun"
             [ "$MODE" = "fix" ] && CMD="fix"
+            [ "$MODE" = "fix-ci" ] && CMD="fix-ci"
             [ "$MODE" = "review" ] && CMD="review"
             ARGS="--issue-number $ISSUE_NUMBER"
             [ -n "$TASK_ID" ] && ARGS="$ARGS --task-id $TASK_ID"
@@ -338,6 +355,68 @@ jobs:
               });
             }
 
+  # ─── Fix-CI Auto-trigger (workflow_run trigger) ─────────────────────────────
+  fix-ci-trigger:
+    if: >-
+      github.event_name == 'workflow_run' &&
+      github.event.workflow_run.conclusion == 'failure' &&
+      github.event.workflow_run.event == 'pull_request' &&
+      github.event.workflow_run.pull_requests[0]
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      - name: Check loop guard and post fix-ci comment
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const pr = context.payload.workflow_run.pull_requests[0];
+            const prNumber = pr.number;
+
+            // Check recent comments for existing fix-ci attempt (last 24h)
+            const comments = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: prNumber,
+              per_page: 30,
+            });
+
+            const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
+            const recentFixCi = comments.data.filter(
+              (c) => c.body.includes('@kody fix-ci') && new Date(c.created_at) > oneDayAgo
+            );
+
+            if (recentFixCi.length >= 1) {
+              core.info('Loop guard: @kody fix-ci already commented in last 24h, skipping');
+              return;
+            }
+
+            // Check if last commit was from a bot (kody's previous fix attempt)
+            const commits = await github.rest.pulls.listCommits({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: prNumber,
+              per_page: 1,
+            });
+            const lastAuthor = commits.data[commits.data.length - 1]?.commit?.author?.name;
+            if (lastAuthor === 'github-actions[bot]' || lastAuthor === 'kody[bot]') {
+              core.info('Loop guard: last commit from bot, skipping');
+              return;
+            }
+
+            // Post fix-ci comment
+            const runId = context.payload.workflow_run.id;
+            const runUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${runId}`;
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: prNumber,
+              body: `@kody fix-ci\nCI failed: [View logs](${runUrl})\nRun ID: ${runId}`,
+            });
+            core.info(`Posted @kody fix-ci on PR #${prNumber} for run ${runId}`);
+
   # ─── Smoke Test (push trigger) ──────────────────────────────────────────────
   smoke-test:
     if: github.event_name == 'push'