@zhijiewang/openharness 0.12.1 → 1.2.0

package/dist/renderer/index.js

@@ -108,6 +108,10 @@ export class TerminalRenderer {
             clearInterval(this.animationTimer);
             this.animationTimer = null;
         }
+        if (this.renderTimer) {
+            clearTimeout(this.renderTimer);
+            this.renderTimer = null;
+        }
         if (this.resizeHandler) {
             process.stdout.off('resize', this.resizeHandler);
             this.resizeHandler = null;
@@ -363,15 +367,39 @@ export class TerminalRenderer {
         return true;
     }
     // ── Rendering ──
+    renderTimer = null;
+    lastRenderTime = 0;
+    static FRAME_MS = 16; // ~60fps
+    /**
+     * Schedule a render at ~60fps. Multiple calls within a frame are batched.
+     * This prevents excessive re-renders during fast token streaming.
+     */
     scheduleRender() {
         if (this.renderPending || !this.started)
             return;
         this.renderPending = true;
-        queueMicrotask(() => {
-            this.renderPending = false;
-            if (this.started)
-                this.render();
-        });
+        const now = Date.now();
+        const elapsed = now - this.lastRenderTime;
+        if (elapsed >= TerminalRenderer.FRAME_MS) {
+            // Enough time has passed — render on next microtask (no delay)
+            queueMicrotask(() => {
+                this.renderPending = false;
+                this.lastRenderTime = Date.now();
+                if (this.started)
+                    this.render();
+            });
+        }
+        else {
+            // Too soon — debounce to next frame boundary
+            const delay = TerminalRenderer.FRAME_MS - elapsed;
+            this.renderTimer = setTimeout(() => {
+                this.renderTimer = null;
+                this.renderPending = false;
+                this.lastRenderTime = Date.now();
+                if (this.started)
+                    this.render();
+            }, delay);
+        }
     }
     /** Apply lightweight markdown styling to a line for scrollback output */
     styleMarkdownLine(line) {

package/dist/repl.js

@@ -62,6 +62,13 @@ export async function startREPL(config) {
     const { CronExecutor } = await import('./services/CronExecutor.js');
     const cronExecutor = new CronExecutor(config.provider, config.tools, config.systemPrompt, config.permissionMode, config.model);
     cronExecutor.start();
+    // A2A: publish agent card for cross-process discovery
+    const { createSessionCard, publishCard, unpublishCard } = await import('./services/a2a.js');
+    const agentCard = createSessionCard(session.id, {
+        provider: config.provider.name,
+        model: config.model,
+    });
+    publishCard(agentCard);
     const cost = new CostTracker();
     let cachedConfig = readOhConfig();
     // Centralized state store — all REPL state lives here
@@ -923,6 +930,7 @@ export async function startREPL(config) {
         if (cleanedUp)
             return;
         cleanedUp = true;
+        unpublishCard(agentCard.id);
         cronExecutor.stop();
         renderer.stop();
         session.messages = messages;

package/dist/services/PipelineExecutor.d.ts

@@ -0,0 +1,48 @@
+/**
+ * PipelineExecutor — declarative multi-step tool workflows.
+ *
+ * Executes a sequence of tool calls with dependency resolution and
+ * variable substitution. Steps can reference prior step outputs via $stepId.
+ *
+ * Unlike the LLM-mediated agent loop, pipelines are deterministic —
+ * faster, cheaper, and repeatable for known workflows.
+ *
+ * Reuses the dependency resolution pattern from AgentDispatcher.
+ */
+import type { Tools, ToolContext } from '../Tool.js';
+export type PipelineStep = {
+    id: string;
+    tool: string;
+    args: Record<string, unknown>;
+    dependsOn?: string[];
+};
+export type PipelineStepResult = {
+    stepId: string;
+    output: string;
+    isError: boolean;
+    durationMs: number;
+};
+export declare class PipelineExecutor {
+    private tools;
+    private context;
+    constructor(tools: Tools, context: ToolContext);
+    /**
+     * Execute a pipeline. Returns results for all steps.
+     * Steps with unmet dependencies (failed/skipped blockers) are skipped.
+     */
+    execute(steps: PipelineStep[]): Promise<PipelineStepResult[]>;
+    private isReady;
+    private hasFailedBlocker;
+    private executeStep;
+    /**
+     * Resolve $stepId references in args.
+     * If a string value starts with $, replace it with the output of that step.
+     * Supports nested objects and arrays.
+     */
+    private resolveArgs;
+}
+/**
+ * Format pipeline results as a readable summary.
+ */
+export declare function formatPipelineResults(results: PipelineStepResult[]): string;
+//# sourceMappingURL=PipelineExecutor.d.ts.map

package/dist/services/PipelineExecutor.js

@@ -0,0 +1,179 @@
+/**
+ * PipelineExecutor — declarative multi-step tool workflows.
+ *
+ * Executes a sequence of tool calls with dependency resolution and
+ * variable substitution. Steps can reference prior step outputs via $stepId.
+ *
+ * Unlike the LLM-mediated agent loop, pipelines are deterministic —
+ * faster, cheaper, and repeatable for known workflows.
+ *
+ * Reuses the dependency resolution pattern from AgentDispatcher.
+ */
+import { findToolByName } from '../Tool.js';
+// ── Executor ──
+export class PipelineExecutor {
+    tools;
+    context;
+    constructor(tools, context) {
+        this.tools = tools;
+        this.context = context;
+    }
+    /**
+     * Execute a pipeline. Returns results for all steps.
+     * Steps with unmet dependencies (failed/skipped blockers) are skipped.
+     */
+    async execute(steps) {
+        // Validate step IDs are unique
+        const ids = new Set(steps.map(s => s.id));
+        if (ids.size !== steps.length) {
+            return [{ stepId: 'pipeline', output: 'Error: duplicate step IDs', isError: true, durationMs: 0 }];
+        }
+        const internal = new Map();
+        for (const step of steps) {
+            internal.set(step.id, { ...step, status: 'pending' });
+        }
+        const results = [];
+        // Process steps in dependency order
+        while (true) {
+            const ready = [...internal.values()].filter(s => s.status === 'pending' && this.isReady(s, internal));
+            const running = [...internal.values()].filter(s => s.status === 'running');
+            if (ready.length === 0 && running.length === 0)
+                break;
+            // Execute ready steps (sequentially for safety — tools may have side effects)
+            for (const step of ready) {
+                step.status = 'running';
+                // Check if any blocker failed — skip this step
+                if (this.hasFailedBlocker(step, internal)) {
+                    step.status = 'skipped';
+                    const result = {
+                        stepId: step.id,
+                        output: 'Skipped: dependency failed',
+                        isError: true,
+                        durationMs: 0,
+                    };
+                    step.result = result;
+                    results.push(result);
+                    continue;
+                }
+                const result = await this.executeStep(step, internal);
+                step.result = result;
+                step.status = result.isError ? 'failed' : 'completed';
+                results.push(result);
+            }
+        }
+        return results;
+    }
+    isReady(step, all) {
+        if (!step.dependsOn || step.dependsOn.length === 0)
+            return true;
+        return step.dependsOn.every(id => {
+            const dep = all.get(id);
+            return dep && (dep.status === 'completed' || dep.status === 'failed' || dep.status === 'skipped');
+        });
+    }
+    hasFailedBlocker(step, all) {
+        if (!step.dependsOn)
+            return false;
+        return step.dependsOn.some(id => {
+            const dep = all.get(id);
+            return dep && (dep.status === 'failed' || dep.status === 'skipped');
+        });
+    }
+    async executeStep(step, all) {
+        const start = Date.now();
+        // Find the tool
+        const tool = findToolByName(this.tools, step.tool);
+        if (!tool) {
+            return {
+                stepId: step.id,
+                output: `Error: unknown tool '${step.tool}'`,
+                isError: true,
+                durationMs: Date.now() - start,
+            };
+        }
+        // Substitute $refs in args
+        const resolvedArgs = this.resolveArgs(step.args, all);
+        // Validate and execute
+        const parsed = tool.inputSchema.safeParse(resolvedArgs);
+        if (!parsed.success) {
+            return {
+                stepId: step.id,
+                output: `Validation error: ${parsed.error.message}`,
+                isError: true,
+                durationMs: Date.now() - start,
+            };
+        }
+        try {
+            const result = await tool.call(parsed.data, this.context);
+            return {
+                stepId: step.id,
+                output: result.output,
+                isError: result.isError,
+                durationMs: Date.now() - start,
+            };
+        }
+        catch (err) {
+            return {
+                stepId: step.id,
+                output: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                isError: true,
+                durationMs: Date.now() - start,
+            };
+        }
+    }
+    /**
+     * Resolve $stepId references in args.
+     * If a string value starts with $, replace it with the output of that step.
+     * Supports nested objects and arrays.
+     */
+    resolveArgs(args, all) {
+        const resolve = (value) => {
+            if (typeof value === 'string' && value.startsWith('$')) {
+                const refId = value.slice(1);
+                const refStep = all.get(refId);
+                if (refStep?.result && !refStep.result.isError) {
+                    return refStep.result.output;
+                }
+                return value; // Keep as-is if ref not found
+            }
+            if (Array.isArray(value))
+                return value.map(resolve);
+            if (value && typeof value === 'object') {
+                const resolved = {};
+                for (const [k, v] of Object.entries(value)) {
+                    resolved[k] = resolve(v);
+                }
+                return resolved;
+            }
+            return value;
+        };
+        return resolve(args);
+    }
+}
+/**
+ * Format pipeline results as a readable summary.
+ */
+export function formatPipelineResults(results) {
+    const lines = [];
+    let totalMs = 0;
+    for (const r of results) {
+        const status = r.isError ? '✗' : '✓';
+        const duration = r.durationMs > 0 ? ` (${r.durationMs}ms)` : '';
+        lines.push(`${status} Step "${r.stepId}"${duration}`);
+        // Show truncated output
+        const output = r.output.length > 200
+            ? r.output.slice(0, 200) + '...'
+            : r.output;
+        if (output) {
+            for (const line of output.split('\n').slice(0, 5)) {
+                lines.push(`  ${line}`);
+            }
+        }
+        lines.push('');
+        totalMs += r.durationMs;
+    }
+    const passed = results.filter(r => !r.isError).length;
+    lines.push(`Pipeline: ${passed}/${results.length} steps passed (${totalMs}ms total)`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=PipelineExecutor.js.map

package/dist/services/a2a.d.ts

@@ -0,0 +1,119 @@
+/**
+ * A2A Protocol — Agent-to-Agent discovery and routing.
+ *
+ * Enables agents running in separate processes (or machines) to:
+ * - Advertise their capabilities via Agent Cards
+ * - Discover other agents via a shared registry
+ * - Route messages to agents by name or capability
+ * - Delegate tasks with typed request/response
+ *
+ * Registry is file-based (~/.oh/agents/) for same-machine agents.
+ * Each running agent writes a card file on startup and removes it on exit.
+ *
+ * Based on the emerging A2A (Agent-to-Agent) protocol standard.
+ */
+export type AgentCard = {
+    /** Unique agent instance ID */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Agent version */
+    version: string;
+    /** What this agent can do */
+    capabilities: AgentCapability[];
+    /** How to reach this agent */
+    endpoint: AgentEndpoint;
+    /** When this card was published */
+    registeredAt: number;
+    /** PID of the agent process */
+    pid: number;
+    /** Provider and model info */
+    provider?: string;
+    model?: string;
+    /** Working directory */
+    workingDir?: string;
+};
+export type AgentCapability = {
+    /** Capability identifier (e.g., 'code-review', 'test-generation') */
+    name: string;
+    /** Human description */
+    description: string;
+    /** Input schema (JSON Schema format) */
+    inputSchema?: Record<string, unknown>;
+    /** Output schema */
+    outputSchema?: Record<string, unknown>;
+};
+export type AgentEndpoint = {
+    /** Transport type */
+    type: 'http' | 'ipc' | 'stdio';
+    /** Address (URL for http, socket path for ipc, pid for stdio) */
+    address: string;
+    /** Port for HTTP transport */
+    port?: number;
+};
+export type A2AMessage = {
+    /** Message ID */
+    id: string;
+    /** Source agent ID */
+    from: string;
+    /** Target agent ID or capability name */
+    to: string;
+    /** Message type */
+    type: 'task' | 'result' | 'status' | 'cancel' | 'discover';
+    /** Payload */
+    payload: A2APayload;
+    /** Timestamp */
+    timestamp: number;
+};
+export type A2APayload = {
+    kind: 'task';
+    capability: string;
+    input: unknown;
+    timeout?: number;
+} | {
+    kind: 'result';
+    taskId: string;
+    output: unknown;
+    error?: string;
+} | {
+    kind: 'status';
+    state: 'idle' | 'working' | 'done' | 'error';
+    progress?: string;
+} | {
+    kind: 'cancel';
+    taskId: string;
+    reason?: string;
+} | {
+    kind: 'discover';
+    filter?: {
+        capability?: string;
+        name?: string;
+    };
+};
+/** Publish an agent card to the shared registry */
+export declare function publishCard(card: AgentCard): void;
+/** Remove an agent card from the registry */
+export declare function unpublishCard(agentId: string): void;
+/** Discover all registered agents */
+export declare function discoverAgents(): AgentCard[];
+/** Find agents by capability name */
+export declare function findAgentsByCapability(capabilityName: string): AgentCard[];
+/** Find an agent by name */
+export declare function findAgentByName(name: string): AgentCard | null;
+/**
+ * Route a message to an agent.
+ * For HTTP endpoints: sends via fetch.
+ * For IPC/stdio: writes to the agent's inbox file.
+ */
+export declare function routeMessage(message: A2AMessage): Promise<A2AMessage | null>;
+/** Read pending messages from an agent's inbox */
+export declare function readInbox(agentId: string): A2AMessage[];
+/** Generate a unique message ID */
+export declare function generateMessageId(): string;
+/** Create a standard agent card for the current openHarness session */
+export declare function createSessionCard(sessionId: string, opts?: {
+    provider?: string;
+    model?: string;
+    port?: number;
+}): AgentCard;
+//# sourceMappingURL=a2a.d.ts.map

package/dist/services/a2a.js

@@ -0,0 +1,176 @@
+/**
+ * A2A Protocol — Agent-to-Agent discovery and routing.
+ *
+ * Enables agents running in separate processes (or machines) to:
+ * - Advertise their capabilities via Agent Cards
+ * - Discover other agents via a shared registry
+ * - Route messages to agents by name or capability
+ * - Delegate tasks with typed request/response
+ *
+ * Registry is file-based (~/.oh/agents/) for same-machine agents.
+ * Each running agent writes a card file on startup and removes it on exit.
+ *
+ * Based on the emerging A2A (Agent-to-Agent) protocol standard.
+ */
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const AGENT_REGISTRY_DIR = join(homedir(), '.oh', 'agents');
+// ── Registry Operations ──
+/** Publish an agent card to the shared registry */
+export function publishCard(card) {
+    mkdirSync(AGENT_REGISTRY_DIR, { recursive: true });
+    const filePath = join(AGENT_REGISTRY_DIR, `${card.id}.json`);
+    writeFileSync(filePath, JSON.stringify(card, null, 2));
+}
+/** Remove an agent card from the registry */
+export function unpublishCard(agentId) {
+    const filePath = join(AGENT_REGISTRY_DIR, `${agentId}.json`);
+    try {
+        unlinkSync(filePath);
+    }
+    catch { /* ignore */ }
+}
+/** Discover all registered agents */
+export function discoverAgents() {
+    if (!existsSync(AGENT_REGISTRY_DIR))
+        return [];
+    const cards = [];
+    for (const file of readdirSync(AGENT_REGISTRY_DIR).filter(f => f.endsWith('.json'))) {
+        try {
+            const raw = readFileSync(join(AGENT_REGISTRY_DIR, file), 'utf-8');
+            const card = JSON.parse(raw);
+            // Check if the agent process is still alive
+            if (isProcessAlive(card.pid)) {
+                cards.push(card);
+            }
+            else {
+                // Stale card — clean up
+                try {
+                    unlinkSync(join(AGENT_REGISTRY_DIR, file));
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* skip malformed cards */ }
+    }
+    return cards;
+}
+/** Find agents by capability name */
+export function findAgentsByCapability(capabilityName) {
+    return discoverAgents().filter(card => card.capabilities.some(c => c.name.toLowerCase() === capabilityName.toLowerCase()));
+}
+/** Find an agent by name */
+export function findAgentByName(name) {
+    return discoverAgents().find(c => c.name.toLowerCase() === name.toLowerCase()) ?? null;
+}
+// ── Message Routing ──
+/**
+ * Route a message to an agent.
+ * For HTTP endpoints: sends via fetch.
+ * For IPC/stdio: writes to the agent's inbox file.
+ */
+export async function routeMessage(message) {
+    // Find the target agent
+    let targetCard = null;
+    // Try by agent ID first
+    const agents = discoverAgents();
+    targetCard = agents.find(a => a.id === message.to) ?? null;
+    // Try by name
+    if (!targetCard) {
+        targetCard = agents.find(a => a.name.toLowerCase() === message.to.toLowerCase()) ?? null;
+    }
+    // Try by capability
+    if (!targetCard && message.type === 'task' && message.payload.kind === 'task') {
+        const capable = findAgentsByCapability(message.payload.capability);
+        if (capable.length > 0)
+            targetCard = capable[0];
+    }
+    if (!targetCard)
+        return null;
+    // Route based on endpoint type
+    switch (targetCard.endpoint.type) {
+        case 'http': {
+            try {
+                const url = `${targetCard.endpoint.address}${targetCard.endpoint.port ? ':' + targetCard.endpoint.port : ''}/a2a`;
+                const res = await fetch(url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(message),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                if (res.ok) {
+                    return await res.json();
+                }
+            }
+            catch { /* delivery failed */ }
+            return null;
+        }
+        case 'ipc': {
+            // File-based inbox for local IPC
+            const inboxDir = join(AGENT_REGISTRY_DIR, 'inboxes', targetCard.id);
+            mkdirSync(inboxDir, { recursive: true });
+            const msgFile = join(inboxDir, `${message.id}.json`);
+            writeFileSync(msgFile, JSON.stringify(message, null, 2));
+            return null; // Async — no immediate response
+        }
+        default:
+            return null;
+    }
+}
+/** Read pending messages from an agent's inbox */
+export function readInbox(agentId) {
+    const inboxDir = join(AGENT_REGISTRY_DIR, 'inboxes', agentId);
+    if (!existsSync(inboxDir))
+        return [];
+    const messages = [];
+    for (const file of readdirSync(inboxDir).filter(f => f.endsWith('.json'))) {
+        try {
+            const raw = readFileSync(join(inboxDir, file), 'utf-8');
+            messages.push(JSON.parse(raw));
+            // Remove after reading
+            unlinkSync(join(inboxDir, file));
+        }
+        catch { /* skip */ }
+    }
+    return messages.sort((a, b) => a.timestamp - b.timestamp);
+}
+// ── Helpers ──
+/** Check if a process is still alive */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0); // Signal 0 = check existence only
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Generate a unique message ID */
+export function generateMessageId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+/** Create a standard agent card for the current openHarness session */
+export function createSessionCard(sessionId, opts = {}) {
+    return {
+        id: `oh-${sessionId}`,
+        name: `openharness-${sessionId.slice(0, 6)}`,
+        version: '1.0.0',
+        capabilities: [
+            { name: 'code-generation', description: 'Generate, edit, and review code' },
+            { name: 'code-review', description: 'Review code for bugs and quality' },
+            { name: 'test-generation', description: 'Write tests for existing code' },
+            { name: 'file-operations', description: 'Read, write, search files' },
+            { name: 'bash-execution', description: 'Run shell commands' },
+        ],
+        endpoint: opts.port
+            ? { type: 'http', address: 'http://localhost', port: opts.port }
+            : { type: 'ipc', address: join(AGENT_REGISTRY_DIR, 'inboxes', `oh-${sessionId}`) },
+        registeredAt: Date.now(),
+        pid: process.pid,
+        provider: opts.provider,
+        model: opts.model,
+        workingDir: process.cwd(),
+    };
+}
+//# sourceMappingURL=a2a.js.map

package/dist/tools/PipelineTool/index.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const inputSchema: z.ZodObject<{
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tool: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        tool: string;
+        args: Record<string, unknown>;
+        id: string;
+        dependsOn?: string[] | undefined;
+    }, {
+        tool: string;
+        args: Record<string, unknown>;
+        id: string;
+        dependsOn?: string[] | undefined;
+    }>, "many">;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    steps: {
+        tool: string;
+        args: Record<string, unknown>;
+        id: string;
+        dependsOn?: string[] | undefined;
+    }[];
+    description?: string | undefined;
+}, {
+    steps: {
+        tool: string;
+        args: Record<string, unknown>;
+        id: string;
+        dependsOn?: string[] | undefined;
+    }[];
+    description?: string | undefined;
+}>;
+export declare const PipelineTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map