pi-harness-runtime 0.10.13 → 0.10.15

package/packages/types/src/agent-worker-types.js

@@ -0,0 +1,41 @@
+/**
+ * Agent Worker Interface — RFC-0030
+ *
+ * Common interface for all agent workers (Codex, MiniMax, GLM, GPT, DeepAgents).
+ * Runtime remains the orchestrator; agents are pluggable workers.
+ */
+/**
+ * Registry of agent worker factories
+ */
+export class AgentWorkerRegistry {
+    factories = new Map();
+    /**
+     * Register a worker factory
+     */
+    register(provider, factory) {
+        this.factories.set(provider.toLowerCase(), factory);
+    }
+    /**
+     * Create a worker for a provider
+     */
+    create(config) {
+        const factory = this.factories.get(config.provider.toLowerCase());
+        if (!factory) {
+            return undefined;
+        }
+        return factory(config);
+    }
+    /**
+     * Check if a provider is supported
+     */
+    supports(provider) {
+        return this.factories.has(provider.toLowerCase());
+    }
+    /**
+     * List all supported providers
+     */
+    listProviders() {
+        return Array.from(this.factories.keys());
+    }
+}
+//# sourceMappingURL=agent-worker-types.js.map

package/packages/types/src/ai-providers.js

@@ -0,0 +1,66 @@
+/**
+ * AI Provider Registry
+ *
+ * Centralized, canonical list of known AI/LLM providers used as keys across
+ * mirror.json, quota tracking, TUI signal parsing, and footer display.
+ *
+ * Adding a new provider = add ONE entry here + update the places that
+ * need per-provider behaviour (scraper, TUI parser, footer, etc.).
+ *
+ * Provider ids are lowercase internal keys.
+ * Labels are human-readable display strings.
+ */
+export const KNOWN_AI_PROVIDERS = [
+    "minimax",
+    "openai",
+    "anthropic",
+    "glm",
+    "openrouter",
+    "openai-codex",
+    "deepseek",
+    "gemini",
+    "kimi",
+];
+/** Human-readable display labels (used in footer, notifications). */
+export const PROVIDER_LABELS = {
+    minimax: "MiniMax",
+    openai: "OpenAI",
+    anthropic: "Anthropic",
+    glm: "GLM",
+    openrouter: "OpenRouter",
+    "openai-codex": "OpenAI Codex",
+    deepseek: "DeepSeek",
+    gemini: "Gemini",
+    kimi: "Kimi",
+    unknown: "Unknown",
+};
+/**
+ * Providers that support continuous quota scraping via cookie/browser automation.
+ * Only MiniMax is currently supported here.
+ */
+export const SCRAPEABLE_PROVIDERS = ["minimax"];
+/**
+ * Providers that report quota via TUI signal capture (one-shot on limit hit).
+ * These do NOT have a continuous scraping path.
+ */
+export const TUI_SIGNAL_PROVIDERS = [
+    "openai",
+    "openai-codex",
+    "anthropic",
+    "glm",
+    "openrouter",
+];
+/**
+ * Check if a provider id is a known AI provider.
+ */
+export function isKnownAiProvider(id) {
+    return KNOWN_AI_PROVIDERS.includes(id);
+}
+/**
+ * Get the display label for a provider id.
+ * Falls back to the id itself if unknown.
+ */
+export function getProviderLabel(id) {
+    return PROVIDER_LABELS[id] ?? id;
+}
+//# sourceMappingURL=ai-providers.js.map

package/packages/types/src/runtime-types.js

@@ -0,0 +1,3 @@
+// Re-export AI provider registry so consumers import from one package
+export { KNOWN_AI_PROVIDERS, PROVIDER_LABELS, SCRAPEABLE_PROVIDERS, TUI_SIGNAL_PROVIDERS, isKnownAiProvider, getProviderLabel, } from "./ai-providers.js";
+//# sourceMappingURL=runtime-types.js.map

package/packages/workflow-events/src/types.js

@@ -0,0 +1,5 @@
+/**
+ * Workflow Events — Semantic Event Types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/packages/write-review/src/blackboard.js

@@ -0,0 +1,228 @@
+/**
+ * Write-Review Blackboard
+ *
+ * File-based coordination between writer and reviewer agents.
+ * Location: {project}/.write-review/status.json
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+const DEFAULT_DIR = ".write-review";
+const STATUS_FILE = "status.json";
+export class WriteReviewBlackboard {
+    projectPath;
+    dir;
+    status = null;
+    constructor(projectPath, dir = DEFAULT_DIR) {
+        this.projectPath = projectPath;
+        this.dir = join(projectPath, dir);
+    }
+    /**
+     * Initialize a new write-review session
+     */
+    init() {
+        mkdirSync(this.dir, { recursive: true });
+        this.status = {
+            projectPath: this.projectPath,
+            phase: "idle",
+            writerDone: false,
+            iteration: 0,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        this.save();
+    }
+    /**
+     * Load status from disk
+     */
+    load() {
+        const path = join(this.dir, STATUS_FILE);
+        if (!existsSync(path)) {
+            return null;
+        }
+        try {
+            this.status = JSON.parse(readFileSync(path, "utf-8"));
+            return this.status;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Save status to disk
+     */
+    save() {
+        if (!this.status)
+            return;
+        this.status.updatedAt = new Date().toISOString();
+        mkdirSync(this.dir, { recursive: true });
+        const path = join(this.dir, STATUS_FILE);
+        writeFileSync(path, JSON.stringify(this.status, null, 2));
+    }
+    /**
+     * Get current status
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Start a new write session
+     */
+    startWriting() {
+        if (!this.status)
+            this.init();
+        this.status.phase = "writing";
+        this.status.writerDone = false;
+        this.status.iteration++;
+        this.save();
+    }
+    /**
+     * Mark writer as done
+     */
+    writerDone(message) {
+        if (!this.status)
+            return;
+        this.status.writerDone = true;
+        this.status.writerMessage = message;
+        this.status.phase = "pending_review";
+        this.save();
+    }
+    /**
+     * Start reviewing
+     */
+    startReview() {
+        if (!this.status)
+            return;
+        this.status.phase = "reviewing";
+        this.status.reviewerStarted = new Date().toISOString();
+        this.save();
+    }
+    /**
+     * Record verdict
+     */
+    setVerdict(verdict, message) {
+        if (!this.status)
+            return;
+        this.status.verdict = verdict;
+        this.status.verdictMessage = message;
+        switch (verdict) {
+            case "approved":
+                this.status.phase = "approved";
+                this.status.approvedAt = new Date().toISOString();
+                break;
+            case "blocked":
+                this.status.phase = "blocked";
+                this.status.blockedAt = new Date().toISOString();
+                break;
+            case "changes_requested":
+                this.status.phase = "changes_requested";
+                break;
+        }
+        this.save();
+    }
+    /**
+     * Record code files written
+     */
+    setCodeFiles(files) {
+        if (!this.status)
+            return;
+        this.status.codeFiles = files;
+        this.save();
+    }
+    /**
+     * Record requested changes
+     */
+    setChangesRequested(changes) {
+        if (!this.status)
+            return;
+        this.status.changesRequested = changes;
+        this.save();
+    }
+    /**
+     * Get current phase
+     */
+    getPhase() {
+        return this.status?.phase ?? "idle";
+    }
+    /**
+     * Get iteration number
+     */
+    getIteration() {
+        return this.status?.iteration ?? 0;
+    }
+    /**
+     * Check if build is allowed
+     */
+    canBuild() {
+        return this.status?.phase === "approved";
+    }
+    /**
+     * Get blackboard directory path
+     */
+    getPath() {
+        return this.dir;
+    }
+    /**
+     * Reset to idle
+     */
+    reset() {
+        if (!this.status)
+            return;
+        this.status.phase = "idle";
+        this.status.writerDone = false;
+        this.status.verdict = undefined;
+        this.status.verdictMessage = undefined;
+        this.status.reviewerStarted = undefined;
+        this.status.approvedAt = undefined;
+        this.status.blockedAt = undefined;
+        this.status.codeFiles = undefined;
+        this.status.changesRequested = undefined;
+        this.save();
+    }
+    /**
+     * Check if a review session exists for this project
+     */
+    exists() {
+        const path = join(this.dir, STATUS_FILE);
+        return existsSync(path);
+    }
+    /**
+     * Export status as markdown for display
+     */
+    toMarkdown() {
+        if (!this.status)
+            return "No active write-review session.";
+        const { phase, iteration, verdict, verdictMessage, codeFiles } = this.status;
+        const lines = [
+            `## Write-Review Status`,
+            ``,
+            `| Field | Value |`,
+            `|-------|-------|`,
+            `| Phase | ${phase} |`,
+            `| Iteration | ${iteration} |`,
+            `| Verdict | ${verdict ?? "pending"} |`,
+        ];
+        if (verdictMessage) {
+            lines.push(`| Message | ${verdictMessage} |`);
+        }
+        if (codeFiles && codeFiles.length > 0) {
+            lines.push(``, `### Code Files`);
+            for (const file of codeFiles) {
+                lines.push(`- ${file}`);
+            }
+        }
+        return lines.join("\n");
+    }
+}
+/**
+ * Create or get blackboard for project
+ */
+export function createBlackboard(projectPath, dir) {
+    const bb = new WriteReviewBlackboard(projectPath, dir);
+    if (!bb.exists()) {
+        bb.init();
+    }
+    else {
+        bb.load();
+    }
+    return bb;
+}

package/packages/write-review/src/gate.js

@@ -0,0 +1,137 @@
+/**
+ * No-Build Gate
+ *
+ * Blocks build commands until review is approved.
+ */
+/**
+ * Commands that trigger build gate
+ */
+const BUILD_COMMANDS = [
+    "bench build",
+    "npm run build",
+    "yarn build",
+    "pnpm build",
+    "bun run build",
+    "npm run dev",
+    "yarn dev",
+    "pnpm dev",
+    "./build",
+    "make build",
+    "gradle build",
+    "mvn package",
+    "dotnet build",
+    "cargo build",
+    "go build",
+    "python manage.py migrate",
+    "bench migrate",
+    "bench --site",
+];
+/**
+ * Check if a command is a build command
+ */
+export function isBuildCommand(command) {
+    const lower = command.toLowerCase().trim();
+    return BUILD_COMMANDS.some((cmd) => lower.includes(cmd.toLowerCase()));
+}
+/**
+ * Check if build is allowed
+ */
+export function checkBuildGate(command, blackboard) {
+    if (!isBuildCommand(command)) {
+        return { allowed: true };
+    }
+    const status = blackboard.load();
+    if (!status) {
+        // No review session - allow build
+        return { allowed: true };
+    }
+    if (status.phase === "approved") {
+        return {
+            allowed: true,
+            currentPhase: status.phase,
+            message: "Build allowed - review approved.",
+        };
+    }
+    return {
+        allowed: false,
+        reason: "REVIEW_NOT_APPROVED",
+        currentPhase: status.phase,
+        message: `Build blocked. Current review phase: ${status.phase}. Wait for "APPROVED" verdict.`,
+    };
+}
+/**
+ * Format gate rejection message
+ */
+export function formatGateRejection(result) {
+    if (result.allowed) {
+        return "";
+    }
+    const lines = [
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "⚠️  BUILD BLOCKED",
+        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
+        "",
+        `Current Phase: ${result.currentPhase}`,
+        "",
+        "The code is under review. Build is only allowed after APPROVED verdict.",
+        "",
+        "To check status:",
+        `  cat {project}/.write-review/status.json`,
+        "",
+        "To wait for approval, do nothing. The reviewer will post the verdict.",
+        "",
+    ];
+    if (result.currentPhase === "changes_requested") {
+        lines.push("Reviewer requested changes. Writer agent should update the code.");
+    }
+    else if (result.currentPhase === "reviewing") {
+        lines.push("Review is in progress. Please wait...");
+    }
+    else if (result.currentPhase === "pending_review") {
+        lines.push("Review not started yet. Waiting for reviewer...");
+    }
+    return lines.join("\n");
+}
+/**
+ * Get phase emoji
+ */
+export function getPhaseEmoji(phase) {
+    const emojis = {
+        idle: "💤",
+        writing: "✍️",
+        pending_review: "⏳",
+        reviewing: "🔍",
+        approved: "✅",
+        blocked: "🚫",
+        changes_requested: "🔄",
+    };
+    return emojis[phase] ?? "❓";
+}
+/**
+ * Format status for display
+ */
+export function formatStatusDisplay(status) {
+    const emoji = getPhaseEmoji(status.phase);
+    const lines = [
+        `${emoji} Write-Review Status`,
+        "",
+        `Phase: ${status.phase}`,
+        `Iteration: ${status.iteration}`,
+    ];
+    if (status.verdict) {
+        lines.push(`Verdict: ${status.verdict}`);
+    }
+    if (status.verdictMessage) {
+        lines.push("");
+        lines.push("Message:");
+        lines.push(status.verdictMessage);
+    }
+    if (status.codeFiles && status.codeFiles.length > 0) {
+        lines.push("");
+        lines.push("Code Files:");
+        for (const file of status.codeFiles) {
+            lines.push(`  - ${file}`);
+        }
+    }
+    return lines.join("\n");
+}

package/packages/write-review/src/index.js

@@ -0,0 +1,17 @@
+/**
+ * write-review - Two-agent code writing with review loop
+ *
+ * Integrates with pi-harness-runtime via:
+ * - Smart trigger detection (prompt files in wiki/)
+ * - System prompt injection for writer agent
+ * - Subagent integration for reviewer agent
+ *
+ * Directory structure: {project}/.write-review/
+ */
+// Re-export all public APIs
+export * from "./types.js";
+export * from "./blackboard.js";
+export * from "./trigger.js";
+export * from "./injection.js";
+export * from "./gate.js";
+export * from "./review.js";

package/packages/write-review/src/injection.js

@@ -0,0 +1,141 @@
+/**
+ * System Prompt Injection
+ *
+ * Adds write-review hints to the agent's system prompt.
+ */
+/**
+ * Write-review hint for system prompt
+ */
+export const WRITE_REVIEW_HINT = `
+
+## Write-Review Loop
+
+When reading a prompt from {project}/wiki/*:
+
+1. You are the **WRITER** agent (Minimax). Read the wiki prompt and write code.
+2. After writing code, write "## WRITER_DONE" to signal completion.
+3. Do NOT build or commit until you receive "APPROVED" verdict.
+4. If you receive "CHANGES_REQUESTED", update the code accordingly.
+5. Acknowledge each verdict in your response.
+
+### Blackboard Path
+{p}/.write-review/status.json
+
+### Verdict Types
+- **APPROVED**: Code is ready. You may build/commit.
+- **CHANGES_REQUESTED**: Reviewer found issues. Update code.
+- **BLOCKED**: Critical issues. Human intervention needed.
+`;
+/**
+ * Helper agent hint (for worker agent)
+ */
+export const HELPER_HINT = `
+
+## Helper Agent Task
+
+The writer agent is busy or needs assistance. Your task:
+
+1. Note any pending tasks to the Todos list using the todo tool.
+2. Review the changes requested and prepare notes for the writer.
+3. Do NOT write code directly - that's the writer's job.
+4. Write a summary of pending tasks to the blackboard.
+`;
+/**
+ * Review reminder hint
+ */
+export const REVIEW_REMINDER_HINT = `
+
+## Review Reminder
+
+Before committing or building, ALWAYS check the write-review status:
+
+\`\`\`bash
+cat {project}/.write-review/status.json
+\`\`\`
+
+Only build/commit if the status shows "approved" or "phase": "approved".
+`;
+/**
+ * Format hint with project path
+ */
+export function formatWriteReviewHint(projectPath) {
+    return WRITE_REVIEW_HINT.replace("{project}", projectPath).replace("{p}", projectPath);
+}
+/**
+ * Format review reminder with project path
+ */
+export function formatReviewReminder(projectPath) {
+    return REVIEW_REMINDER_HINT.replace("{project}", projectPath);
+}
+/**
+ * Get all hints to inject
+ */
+export function getWriteReviewHints(projectPath) {
+    return {
+        writeHint: formatWriteReviewHint(projectPath),
+        reminderHint: formatReviewReminder(projectPath),
+    };
+}
+import { createBlackboard } from "./blackboard.js";
+export function injectWriterInstructions(pi, config) {
+    let currentProject = null;
+    let blackboard = null;
+    let hintsInjected = false;
+    // System prompt injection
+    pi.on("before_agent_start", async (event) => {
+        const cwd = process.cwd?.() ?? "/";
+        if (cwd !== currentProject) {
+            currentProject = cwd;
+            blackboard = createBlackboard(cwd);
+            hintsInjected = false;
+        }
+        if (!hintsInjected && blackboard) {
+            const status = blackboard.load();
+            if (status && status.phase !== "idle") {
+                event.systemPrompt += formatWriteReviewHint(cwd);
+                if (status.phase !== "approved") {
+                    event.systemPrompt += formatReviewReminder(cwd);
+                }
+                hintsInjected = true;
+                if (config?.debug) {
+                    console.log(`[write-review] Hints injected for ${cwd}, phase: ${status.phase}`);
+                }
+            }
+        }
+    });
+    // Build gate
+    pi.on("tool_execution_end", async (event) => {
+        const toolName = event.tool?.name ?? "";
+        if (toolName !== "bash")
+            return;
+        const result = event;
+        const content = result.result?.content ?? "";
+        // Check for build commands
+        const buildCommands = [
+            "bench build",
+            "npm run build",
+            "yarn build",
+            "pnpm build",
+            "bun run build",
+            "make build",
+            "gradle build",
+            "dotnet build",
+            "cargo build",
+        ];
+        const isBuild = buildCommands.some((cmd) => content.includes(cmd));
+        if (isBuild && blackboard) {
+            const status = blackboard.load();
+            if (status && status.phase !== "approved") {
+                result.result.content =
+                    content +
+                        "\n\n" +
+                        "⚠️ BUILD BLOCKED - Review not approved yet.\n" +
+                        `Current phase: ${status.phase}\n` +
+                        "Wait for APPROVED verdict before building.";
+            }
+        }
+    });
+    if (config?.debug) {
+        console.log("[write-review] Extension registered");
+    }
+}