pi-harness-runtime 0.10.13 → 0.10.14

package/harness/repair-engine.js

@@ -0,0 +1,256 @@
+/**
+ * Repair Engine — RFC-0018
+ *
+ * Converts failures into repair tasks with retry policy and escalation.
+ */
+import { appendJsonl } from "../cli.ts";
+// @ts-expect-error - Bun has built-in Node.js types
+import { join, dirname } from "node:path";
+// @ts-expect-error - Bun has built-in Node.js types
+import { mkdirSync } from "node:fs";
+const DEFAULT_RETRY_POLICY = {
+    maxRetries: 3,
+    backoffMs: 5000,
+    backoffMultiplier: 2,
+    escalationAfter: 2,
+};
+const FAILURE_PATTERNS = {
+    "test failed": "test_failure",
+    "assertion failed": "test_failure",
+    TypeError: "type_error",
+    SyntaxError: "build_error",
+    ESLint: "lint_error",
+    "build failed": "build_error",
+    "compilation error": "build_error",
+    quota: "quota_exhausted",
+    "rate limit": "quota_exhausted",
+    "429": "quota_exhausted",
+    "500": "provider_error",
+    "502": "provider_error",
+    "503": "provider_error",
+    connection: "provider_error",
+    timeout: "provider_error",
+};
+export class RepairEngine {
+    repairTasks = new Map();
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    /**
+     * Classify a failure type from error message
+     */
+    classifyFailure(errorMessage) {
+        const lower = errorMessage.toLowerCase();
+        for (const [pattern, type] of Object.entries(FAILURE_PATTERNS)) {
+            if (lower.includes(pattern.toLowerCase())) {
+                return type;
+            }
+        }
+        return "unknown";
+    }
+    /**
+     * Create a repair task from a failed task
+     */
+    createRepairTask(originalTaskId, failureType, errorMessage, options) {
+        const id = `repair-${originalTaskId}-${Date.now()}`;
+        const retryPolicy = {
+            ...DEFAULT_RETRY_POLICY,
+            ...options?.retryPolicy,
+        };
+        const task = {
+            id,
+            originalTaskId,
+            failureType,
+            description: `Fix failure in task ${originalTaskId}: ${errorMessage}`,
+            attemptedFixes: [],
+            status: "pending",
+            retryPolicy,
+            createdAt: new Date().toISOString(),
+        };
+        this.repairTasks.set(id, task);
+        return task;
+    }
+    /**
+     * Record an attempted fix
+     */
+    recordAttempt(repairTaskId, description, success, output) {
+        const task = this.repairTasks.get(repairTaskId);
+        if (!task)
+            return;
+        const attempt = {
+            attempt: task.attemptedFixes.length + 1,
+            description,
+            success,
+            output,
+            timestamp: new Date().toISOString(),
+        };
+        task.attemptedFixes.push(attempt);
+        if (success) {
+            task.status = "resolved";
+            task.resolvedAt = new Date().toISOString();
+        }
+        else if (attempt.attempt >= task.retryPolicy.maxRetries) {
+            // Check if should escalate
+            if (task.retryPolicy.escalationAfter &&
+                attempt.attempt >= task.retryPolicy.escalationAfter) {
+                task.status = "escalated";
+            }
+        }
+        this.repairTasks.set(repairTaskId, task);
+        this.saveRepairTask(task);
+    }
+    /**
+     * Get the next retry delay in milliseconds
+     */
+    getNextRetryDelay(repairTaskId) {
+        const task = this.repairTasks.get(repairTaskId);
+        if (!task)
+            return null;
+        const attempt = task.attemptedFixes.length;
+        if (attempt >= task.retryPolicy.maxRetries)
+            return null;
+        const { backoffMs, backoffMultiplier } = task.retryPolicy;
+        return backoffMs * backoffMultiplier ** attempt;
+    }
+    /**
+     * Check if repair task should escalate to human
+     */
+    shouldEscalate(repairTaskId) {
+        const task = this.repairTasks.get(repairTaskId);
+        if (!task)
+            return false;
+        return task.status === "escalated";
+    }
+    /**
+     * Get all repair tasks for a job
+     */
+    getRepairTasks(jobId) {
+        // const path = join(this.rootDir, "jobs", jobId, "repair-tasks.jsonl");
+        // In practice, this would read from file. For now, return in-memory.
+        return Array.from(this.repairTasks.values()).filter((t) => t.originalTaskId.startsWith(`task-${jobId}`));
+    }
+    /**
+     * Get repair summary
+     */
+    getSummary(jobId) {
+        const tasks = this.getRepairTasks(jobId);
+        return {
+            total: tasks.length,
+            pending: tasks.filter((t) => t.status === "pending" || t.status === "in_progress").length,
+            resolved: tasks.filter((t) => t.status === "resolved").length,
+            escalated: tasks.filter((t) => t.status === "escalated").length,
+        };
+    }
+    /**
+     * Analyze a failure and create repair task with guidance
+     */
+    analyzeAndRepair(originalTaskId, errorMessage, options) {
+        const failureType = this.classifyFailure(errorMessage);
+        const repairTask = this.createRepairTask(originalTaskId, failureType, errorMessage, options);
+        const guidance = this.generateGuidance(repairTask);
+        return { repairTask, guidance };
+    }
+    /**
+     * Generate repair guidance based on failure type
+     */
+    generateGuidance(repairTask) {
+        switch (repairTask.failureType) {
+            case "test_failure":
+                return `Analyze the failing test. Check:
+1. Is the test correct? (Does it test what it claims?)
+2. Is the implementation correct? (Does it match the expected behavior?)
+3. Are there any recent changes that broke the test?
+4. Are there any environment-specific issues?`;
+            case "build_error":
+                return `Check the build error details:
+1. Look at the exact error message and line number
+2. Check for missing imports or type mismatches
+3. Verify all dependencies are installed
+4. Check for circular dependencies`;
+            case "type_error":
+                return `Fix TypeScript/JavaScript type errors:
+1. Check the type of each variable
+2. Ensure type assertions are correct
+3. Verify interface/type definitions match usage
+4. Consider adding type guards if needed`;
+            case "lint_error":
+                return `Fix linting errors:
+1. Review the linting rules being violated
+2. Check if code style matches project conventions
+3. Run linter with --fix if available
+4. Update eslint/prettier config if needed`;
+            case "quota_exhausted":
+                return `Quota exhausted. Options:
+1. Wait for quota reset
+2. Switch to an alternative provider
+3. Optimize prompts to use fewer tokens
+4. Reduce task scope to fit within quota`;
+            case "provider_error":
+                return `Provider error. Actions:
+1. Retry with exponential backoff
+2. Check provider status page
+3. Switch to fallback provider if available
+4. Log error details for debugging`;
+            case "e2e_failure":
+                return `E2E test failed. Check:
+1. Is the page/app in the expected state?
+2. Are selectors still valid?
+3. Is there a timing issue (need to wait longer)?
+4. Is the test assertion correct?`;
+            default:
+                return `Unknown failure. Gather more information:
+1. Collect full error stack trace
+2. Check system logs
+3. Reproduce the issue locally
+4. Consider asking for human assistance`;
+        }
+    }
+    /**
+     * Save repair task to file
+     */
+    saveRepairTask(task) {
+        const path = join(this.rootDir, "jobs", task.originalTaskId.split("-")[1] ?? "unknown", "repair-tasks.jsonl");
+        mkdirSync(dirname(path), { recursive: true });
+        appendJsonl(path, task);
+    }
+    /**
+     * Load repair tasks from file
+     */
+    loadRepairTasks(_jobId) {
+        // const path = join(this.rootDir, "jobs", _jobId, "repair-tasks.jsonl");
+        // In practice, this would read from file and populate the map
+    }
+    /**
+     * Export repair report
+     */
+    exportReport(jobId) {
+        const tasks = this.getRepairTasks(jobId);
+        const summary = this.getSummary(jobId);
+        const lines = [
+            `Repair Report for Job ${jobId}`,
+            "=".repeat(50),
+            `Total: ${summary.total}`,
+            `Pending: ${summary.pending}`,
+            `Resolved: ${summary.resolved}`,
+            `Escalated: ${summary.escalated}`,
+            "",
+            "Details:",
+            "-".repeat(50),
+        ];
+        for (const task of tasks) {
+            lines.push(`\n[${task.status.toUpperCase()}] ${task.id}`);
+            lines.push(`  Original: ${task.originalTaskId}`);
+            lines.push(`  Type: ${task.failureType}`);
+            lines.push(`  Description: ${task.description}`);
+            lines.push(`  Attempts: ${task.attemptedFixes.length}/${task.retryPolicy.maxRetries}`);
+            if (task.attemptedFixes.length > 0) {
+                lines.push("  Attempt History:");
+                for (const fix of task.attemptedFixes) {
+                    lines.push(`    - [${fix.success ? "✓" : "✗"}] ${fix.description}`);
+                }
+            }
+        }
+        return lines.join("\n");
+    }
+}

package/harness/session-memory.js

@@ -0,0 +1,293 @@
+/**
+ * Session Memory — Persistent Knowledge Extraction
+ *
+ * Extracts key facts and decisions to persistent storage.
+ * On resume, re-injects memory as context without re-sending full history.
+ *
+ * Based on the reference implementation's sessionMemoryCompact pattern.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+// --- Session Memory Manager -------------------------------------------------
+export class SessionMemoryManager {
+    memory;
+    memoryPath;
+    maxFacts = 50;
+    maxDecisions = 20;
+    constructor(jobId, rootDir) {
+        this.memoryPath = join(rootDir ?? join(process.env.HOME ?? ".", ".pi", "harness", jobId), "session-memory.json");
+        this.memory = this.load() ?? {
+            jobId,
+            extractedFacts: [],
+            decisions: [],
+            filesModified: [],
+            testsStatus: [],
+            artifacts: {},
+            lastUpdated: new Date().toISOString(),
+        };
+    }
+    // --- Public API -----------------------------------------------------------
+    /**
+     * Extract key facts from recent messages
+     */
+    extractFacts(messages) {
+        for (const msg of messages) {
+            const content = msg.content;
+            // File creation patterns
+            for (const match of content.matchAll(/(?:created|created file|created module):?\s*([^\n.]+)/gi)) {
+                if (match[1]) {
+                    this.addFileReference(match[1].trim(), "created");
+                }
+            }
+            // File modification patterns
+            for (const match of content.matchAll(/(?:modified|updated|changed):?\s*([^\n.]+)/gi)) {
+                if (match[1] && !/(?:file|module|code)/i.test(match[0])) {
+                    this.addFileReference(match[1].trim(), "modified");
+                }
+            }
+            // Test result patterns
+            for (const match of content.matchAll(/(?:test|spec):?\s*([^\n.]+)\s*(passed|failed|pass|fail)/gi)) {
+                if (match[1] && match[2]) {
+                    this.addTestResult(match[1].trim(), /^pass$/i.test(match[2]));
+                }
+            }
+            // Decision patterns
+            for (const match of content.matchAll(/(?:decided|choosing|chose|decision|approach|using):?\s*([^\n.]+)/gi)) {
+                if (match[1] && match[1].length > 10) {
+                    this.recordDecision(match[1].trim());
+                }
+            }
+            // Key facts patterns
+            for (const match of content.matchAll(/(?:important|key|note|facts?:)\s*([^\n]+)/gi)) {
+                if (match[1] && match[1].length > 20) {
+                    this.recordFact(match[1].trim());
+                }
+            }
+        }
+        this.memory.lastUpdated = new Date().toISOString();
+        this.save();
+    }
+    /**
+     * Add a decision to memory
+     */
+    recordDecision(text, rationale) {
+        // Avoid exact duplicates
+        if (this.memory.decisions.some((d) => d.text === text)) {
+            return;
+        }
+        this.memory.decisions.push({
+            text,
+            rationale,
+            timestamp: new Date().toISOString(),
+        });
+        // Trim to max
+        if (this.memory.decisions.length > this.maxDecisions) {
+            this.memory.decisions = this.memory.decisions.slice(-this.maxDecisions);
+        }
+        this.save();
+    }
+    /**
+     * Add a fact to memory
+     */
+    recordFact(fact) {
+        // Avoid duplicates
+        if (this.memory.extractedFacts.includes(fact)) {
+            return;
+        }
+        this.memory.extractedFacts.push(fact);
+        // Trim to max
+        if (this.memory.extractedFacts.length > this.maxFacts) {
+            this.memory.extractedFacts = this.memory.extractedFacts.slice(-this.maxFacts);
+        }
+        this.save();
+    }
+    /**
+     * Add a file reference
+     */
+    addFileReference(path, action) {
+        // Avoid exact duplicates
+        if (this.memory.filesModified.some((f) => f.path === path)) {
+            return;
+        }
+        this.memory.filesModified.push({
+            path,
+            action,
+            timestamp: new Date().toISOString(),
+        });
+        this.save();
+    }
+    /**
+     * Add a test result
+     */
+    addTestResult(name, passed) {
+        this.memory.testsStatus.push({
+            name,
+            passed,
+            timestamp: new Date().toISOString(),
+        });
+        this.save();
+    }
+    /**
+     * Store an artifact (e.g., generated code snippet)
+     */
+    storeArtifact(key, content) {
+        this.memory.artifacts[key] = content;
+        this.save();
+    }
+    /**
+     * Get memory for re-injection as context
+     */
+    getMemoryForContext() {
+        const parts = [];
+        // Files modified
+        if (this.memory.filesModified.length > 0) {
+            parts.push("## Files Modified");
+            for (const file of this.memory.filesModified.slice(-10)) {
+                parts.push(`- [${file.action}] ${file.path}`);
+            }
+            parts.push("");
+        }
+        // Key decisions
+        if (this.memory.decisions.length > 0) {
+            parts.push("## Key Decisions");
+            for (const decision of this.memory.decisions.slice(-5)) {
+                parts.push(`- ${decision.text}`);
+                if (decision.rationale) {
+                    parts.push(`  Reason: ${decision.rationale}`);
+                }
+            }
+            parts.push("");
+        }
+        // Extracted facts
+        if (this.memory.extractedFacts.length > 0) {
+            parts.push("## Key Facts");
+            for (const fact of this.memory.extractedFacts.slice(-10)) {
+                parts.push(`- ${fact}`);
+            }
+            parts.push("");
+        }
+        // Test status
+        if (this.memory.testsStatus.length > 0) {
+            const passed = this.memory.testsStatus.filter((t) => t.passed).length;
+            const total = this.memory.testsStatus.length;
+            parts.push(`## Tests: ${passed}/${total} passed`);
+            parts.push("");
+        }
+        if (parts.length === 0) {
+            return "";
+        }
+        return ["## Session Memory", "", ...parts.slice(0, -1)].join("\n");
+    }
+    /**
+     * Get compact-worthy content (for session memory compaction)
+     */
+    getCompactContent() {
+        const lines = [];
+        if (this.memory.filesModified.length > 0) {
+            lines.push("Files modified:");
+            for (const file of this.memory.filesModified) {
+                lines.push(`  ${file.action}: ${file.path}`);
+            }
+        }
+        if (this.memory.decisions.length > 0) {
+            lines.push("Decisions:");
+            for (const d of this.memory.decisions) {
+                lines.push(`  - ${d.text}`);
+            }
+        }
+        if (this.memory.extractedFacts.length > 0) {
+            lines.push("Facts:");
+            for (const f of this.memory.extractedFacts) {
+                lines.push(`  - ${f}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Get test summary
+     */
+    getTestSummary() {
+        const passed = this.memory.testsStatus.filter((t) => t.passed).length;
+        const total = this.memory.testsStatus.length;
+        return `${passed}/${total}`;
+    }
+    /**
+     * Check if all tests passed
+     */
+    allTestsPassed() {
+        return (this.memory.testsStatus.length > 0 &&
+            this.memory.testsStatus.every((t) => t.passed));
+    }
+    /**
+     * Clear memory (e.g., after successful task completion)
+     */
+    clear() {
+        this.memory.extractedFacts = [];
+        this.memory.decisions = [];
+        this.memory.filesModified = [];
+        this.memory.testsStatus = [];
+        this.memory.artifacts = {};
+        this.memory.lastUpdated = new Date().toISOString();
+        this.save();
+    }
+    /**
+     * Get raw memory object
+     */
+    getMemory() {
+        return { ...this.memory };
+    }
+    /**
+     * Update from another memory object (for merge on resume)
+     */
+    merge(other) {
+        if (other.extractedFacts) {
+            for (const fact of other.extractedFacts) {
+                if (!this.memory.extractedFacts.includes(fact)) {
+                    this.memory.extractedFacts.push(fact);
+                }
+            }
+        }
+        if (other.decisions) {
+            for (const decision of other.decisions) {
+                if (!this.memory.decisions.some((d) => d.text === decision.text)) {
+                    this.memory.decisions.push(decision);
+                }
+            }
+        }
+        if (other.filesModified) {
+            for (const file of other.filesModified) {
+                if (!this.memory.filesModified.some((f) => f.path === file.path)) {
+                    this.memory.filesModified.push(file);
+                }
+            }
+        }
+        this.memory.lastUpdated = new Date().toISOString();
+        this.save();
+    }
+    // --- Private Methods --------------------------------------------------
+    load() {
+        if (!existsSync(this.memoryPath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(readFileSync(this.memoryPath, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    save() {
+        const dir = this.memoryPath.substring(0, this.memoryPath.lastIndexOf("/"));
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        writeFileSync(this.memoryPath, JSON.stringify(this.memory, null, 2), "utf-8");
+    }
+}
+// --- Factory ----------------------------------------------------------------
+/**
+ * Create a SessionMemoryManager for a job
+ */
+export function createSessionMemoryManager(jobId, rootDir) {
+    return new SessionMemoryManager(jobId, rootDir);
+}

package/harness/task-graph.js

@@ -0,0 +1,87 @@
+/**
+ * Task Graph Manager — RFC-0028 Phase 3
+ *
+ * Manages task dependency graph for compact-aware scheduling.
+ * Currently a stub — integrates with CompactOrchestrator for
+ * dependency-aware compaction prioritization.
+ *
+ * Future work:
+ * - Track task dependencies (blocking/ready tasks)
+ * - Prioritize compaction to keep blocking path messages
+ * - Track which tasks depend on which checkpoint artifacts
+ */
+/**
+ * Creates a new TaskGraphManager instance.
+ * Stub implementation — returns minimal working graph.
+ */
+export function createTaskGraphManager() {
+    const nodes = new Map();
+    return {
+        addTask(task) {
+            if (!nodes.has(task.id)) {
+                nodes.set(task.id, {
+                    task,
+                    dependencies: new Set(),
+                    dependents: new Set(),
+                    status: "pending",
+                });
+            }
+        },
+        completeTask(taskId) {
+            const node = nodes.get(taskId);
+            if (!node)
+                return;
+            node.status = "done";
+            // Update dependents to ready
+            for (const depId of node.dependents) {
+                const depNode = nodes.get(depId);
+                if (!depNode)
+                    continue;
+                // Check if all dependencies are met
+                const allDepsMet = [...depNode.dependencies].every((depId) => nodes.get(depId)?.status === "done");
+                if (allDepsMet) {
+                    depNode.status = "ready";
+                }
+            }
+        },
+        getReadyTasks() {
+            return [...nodes.values()]
+                .filter((n) => n.status === "ready")
+                .map((n) => n.task);
+        },
+        getBlockedTasks(_taskId) {
+            // Stub: return empty array
+            return [];
+        },
+        getPendingTasks() {
+            return [...nodes.values()]
+                .filter((n) => n.status === "pending")
+                .map((n) => n.task);
+        },
+        getAllTasks() {
+            return [...nodes.values()].map((n) => n.task);
+        },
+        getProgressSummary() {
+            const allNodes = [...nodes.values()];
+            return {
+                total: allNodes.length,
+                done: allNodes.filter((n) => n.status === "done").length,
+                running: allNodes.filter((n) => n.status === "running").length,
+                failed: allNodes.filter((n) => n.status === "blocked").length,
+            };
+        },
+        getCompactPriority() {
+            // Stub: keep done tasks, prune pending ones
+            const done = [...nodes.values()]
+                .filter((n) => n.status === "done")
+                .map((n) => n.task.id);
+            const pending = [...nodes.values()]
+                .filter((n) => n.status === "pending")
+                .map((n) => n.task.id);
+            return {
+                keep: done, // Keep done task context (they're relevant)
+                prune: pending, // Prune pending task messages first
+            };
+        },
+    };
+}