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

package/dist/types.d.ts

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

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

package/dist/validators.d.ts

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

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

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

@@ -1,110 +0,0 @@
-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 };
-}