@zhijiewang/openharness 2.0.0 → 2.3.0

package/dist/sdk/index.d.ts

@@ -13,8 +13,8 @@
  *   const result = await agent.run('Fix the failing tests');
  *   console.log(result.text);
  */
-import type { StreamEvent } from '../types/events.js';
-import type { PermissionMode } from '../types/permissions.js';
+import type { StreamEvent } from "../types/events.js";
+import type { PermissionMode } from "../types/permissions.js";
 export type AgentConfig = {
     /** Provider name: 'anthropic', 'openai', 'ollama', 'openrouter', etc. */
     provider: string;
@@ -25,7 +25,7 @@ export type AgentConfig = {
     /** Custom base URL */
     baseUrl?: string;
     /** Tools to include: 'all', 'read-only', or array of tool names */
-    tools?: 'all' | 'read-only' | string[];
+    tools?: "all" | "read-only" | string[];
     /** Permission mode (default: 'trust') */
     permissionMode?: PermissionMode;
     /** Custom system prompt */
@@ -57,10 +57,11 @@ export declare class Agent {
     private provider;
     private tools;
     private config;
-    private initialized;
+    private initPromise;
     constructor(config: AgentConfig);
-    /** Initialize provider and tools (lazy, on first use) */
+    /** Initialize provider and tools (lazy, on first use). Race-safe via promise guard. */
     private init;
+    private _doInit;
     /** Run a single prompt and return the result */
     run(prompt: string): Promise<AgentResult>;
     /** Stream events from a prompt */
@@ -70,6 +71,6 @@ export declare class Agent {
 }
 /** Create a new agent instance */
 export declare function createAgent(config: AgentConfig): Agent;
-export type { StreamEvent } from '../types/events.js';
-export type { PermissionMode } from '../types/permissions.js';
+export type { StreamEvent } from "../types/events.js";
+export type { PermissionMode } from "../types/permissions.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/sdk/index.js

@@ -18,20 +18,21 @@ export class Agent {
     provider = null;
     tools = null;
     config;
-    initialized = false;
+    initPromise = null;
     constructor(config) {
         this.config = {
-            permissionMode: 'trust',
+            permissionMode: "trust",
             maxTurns: 20,
             ...config,
         };
     }
-    /** Initialize provider and tools (lazy, on first use) */
-    async init() {
-        if (this.initialized)
-            return;
-        const { createProvider } = await import('../providers/index.js');
-        const { getAllTools } = await import('../tools.js');
+    /** Initialize provider and tools (lazy, on first use). Race-safe via promise guard. */
+    init() {
+        return (this.initPromise ??= this._doInit());
+    }
+    async _doInit() {
+        const { createProvider } = await import("../providers/index.js");
+        const { getAllTools } = await import("../tools.js");
         const overrides = {};
         if (this.config.apiKey)
             overrides.apiKey = this.config.apiKey;
@@ -41,61 +42,75 @@ export class Agent {
         this.provider = provider;
         // Filter tools
         let tools = getAllTools();
-        if (this.config.tools === 'read-only') {
-            const readOnlyNames = new Set(['Read', 'Glob', 'Grep', 'LS', 'ImageRead', 'WebSearch', 'WebFetch']);
-            tools = tools.filter(t => readOnlyNames.has(t.name));
+        if (this.config.tools === "read-only") {
+            const readOnlyNames = new Set(["Read", "Glob", "Grep", "LS", "ImageRead", "WebSearch", "WebFetch"]);
+            tools = tools.filter((t) => readOnlyNames.has(t.name));
         }
         else if (Array.isArray(this.config.tools)) {
-            const allowed = new Set(this.config.tools.map(n => n.toLowerCase()));
-            tools = tools.filter(t => allowed.has(t.name.toLowerCase()));
+            const allowed = new Set(this.config.tools.map((n) => n.toLowerCase()));
+            tools = tools.filter((t) => allowed.has(t.name.toLowerCase()));
         }
         this.tools = tools;
-        this.initialized = true;
     }
     /** Run a single prompt and return the result */
     async run(prompt) {
         await this.init();
-        const { query } = await import('../query.js');
+        const { query } = await import("../query.js");
+        const originalCwd = process.cwd();
         if (this.config.cwd) {
             try {
                 process.chdir(this.config.cwd);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         }
         const config = {
             provider: this.provider,
             tools: this.tools,
-            systemPrompt: this.config.systemPrompt ?? 'You are a helpful coding agent.',
+            systemPrompt: this.config.systemPrompt ?? "You are a helpful coding agent.",
             permissionMode: this.config.permissionMode,
             model: this.config.model,
             maxTurns: this.config.maxTurns,
         };
-        let text = '';
+        let text = "";
         const toolCalls = [];
         let cost = 0;
         let inputTokens = 0;
         let outputTokens = 0;
         let turns = 0;
-        for await (const event of query(prompt, config)) {
-            switch (event.type) {
-                case 'text_delta':
-                    text += event.content;
-                    break;
-                case 'tool_call_end':
-                    toolCalls.push({
-                        toolName: event.toolName ?? 'unknown',
-                        output: event.output ?? '',
-                        isError: event.isError ?? false,
-                    });
-                    break;
-                case 'cost_update':
-                    cost += event.cost ?? 0;
-                    inputTokens += event.inputTokens ?? 0;
-                    outputTokens += event.outputTokens ?? 0;
-                    break;
-                case 'turn_complete':
-                    turns++;
-                    break;
+        try {
+            for await (const event of query(prompt, config)) {
+                switch (event.type) {
+                    case "text_delta":
+                        text += event.content;
+                        break;
+                    case "tool_call_end":
+                        toolCalls.push({
+                            toolName: event.callId,
+                            output: event.output,
+                            isError: event.isError,
+                        });
+                        break;
+                    case "cost_update":
+                        cost += event.cost;
+                        inputTokens += event.inputTokens;
+                        outputTokens += event.outputTokens;
+                        break;
+                    case "turn_complete":
+                        turns++;
+                        break;
+                }
+            }
+        }
+        finally {
+            if (this.config.cwd) {
+                try {
+                    process.chdir(originalCwd);
+                }
+                catch {
+                    /* ignore */
+                }
             }
         }
         return { text, toolCalls, cost, inputTokens, outputTokens, turns };
@@ -103,17 +118,19 @@ export class Agent {
     /** Stream events from a prompt */
     async *stream(prompt) {
         await this.init();
-        const { query } = await import('../query.js');
+        const { query } = await import("../query.js");
         if (this.config.cwd) {
             try {
                 process.chdir(this.config.cwd);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         }
         const config = {
             provider: this.provider,
             tools: this.tools,
-            systemPrompt: this.config.systemPrompt ?? 'You are a helpful coding agent.',
+            systemPrompt: this.config.systemPrompt ?? "You are a helpful coding agent.",
             permissionMode: this.config.permissionMode,
             model: this.config.model,
             maxTurns: this.config.maxTurns,
@@ -124,7 +141,7 @@ export class Agent {
     stop() {
         this.provider = null;
         this.tools = null;
-        this.initialized = false;
+        this.initPromise = null;
     }
 }
 // ── Factory ──

package/dist/services/AgentDispatcher.d.ts

@@ -5,9 +5,9 @@
  * dispatches independent tasks to parallel worktrees, collects results,
  * and triggers dependent tasks when their blockers complete.
  */
-import type { Provider } from '../providers/base.js';
-import type { Tools } from '../Tool.js';
-import type { PermissionMode } from '../types/permissions.js';
+import type { Provider } from "../providers/base.js";
+import type { Tools } from "../Tool.js";
+import type { PermissionMode } from "../types/permissions.js";
 export type AgentTask = {
     id: string;
     prompt: string;

package/dist/services/AgentDispatcher.js

@@ -5,7 +5,7 @@
  * dispatches independent tasks to parallel worktrees, collects results,
  * and triggers dependent tasks when their blockers complete.
  */
-import { createWorktree, removeWorktree, isGitRepo } from '../git/index.js';
+import { createWorktree, isGitRepo, removeWorktree } from "../git/index.js";
 export class AgentDispatcher {
     provider;
     tools;
@@ -29,7 +29,7 @@ export class AgentDispatcher {
         this.maxConcurrency = maxConcurrency;
     }
     addTask(task) {
-        this.tasks.set(task.id, { ...task, status: 'pending' });
+        this.tasks.set(task.id, { ...task, status: "pending" });
     }
     addTasks(tasks) {
         for (const t of tasks)
@@ -42,8 +42,8 @@ export class AgentDispatcher {
             if (this.abortSignal?.aborted)
                 break;
             // Find tasks ready to run (all blockers completed)
-            const ready = [...this.tasks.values()].filter(t => t.status === 'pending' && this.isReady(t));
-            const running = [...this.tasks.values()].filter(t => t.status === 'running');
+            const ready = [...this.tasks.values()].filter((t) => t.status === "pending" && this.isReady(t));
+            const running = [...this.tasks.values()].filter((t) => t.status === "running");
             // All done?
             if (ready.length === 0 && running.length === 0)
                 break;
@@ -52,11 +52,11 @@ export class AgentDispatcher {
             if (toStart.length === 0 && running.length === 0) {
                 // Deadlock — blocked tasks with no way to unblock
                 for (const t of this.tasks.values()) {
-                    if (t.status === 'pending') {
-                        t.status = 'failed';
+                    if (t.status === "pending") {
+                        t.status = "failed";
                         const result = {
                             id: t.id,
-                            output: 'Deadlock: blocked dependencies never completed.',
+                            output: "Deadlock: blocked dependencies never completed.",
                             isError: true,
                             durationMs: 0,
                         };
@@ -67,10 +67,10 @@ export class AgentDispatcher {
                 break;
             }
             // Run tasks in parallel
-            const promises = toStart.map(t => {
-                t.status = 'running';
-                return this.runTask(t).then(result => {
-                    t.status = 'completed';
+            const promises = toStart.map((t) => {
+                t.status = "running";
+                return this.runTask(t).then((result) => {
+                    t.status = "completed";
                     t.result = result;
                     this.results.set(t.id, result);
                     results.push(result);
@@ -85,11 +85,11 @@ export class AgentDispatcher {
             else {
                 // Running tasks exist but we can't start more — wait for all running
                 const runningPromises = [...this.tasks.values()]
-                    .filter(t => t.status === 'running' && t.result)
-                    .map(t => Promise.resolve());
+                    .filter((t) => t.status === "running" && t.result)
+                    .map((_t) => Promise.resolve());
                 if (runningPromises.length === 0) {
                     // Need to poll — running tasks haven't resolved yet
-                    await new Promise(r => setTimeout(r, 100));
+                    await new Promise((r) => setTimeout(r, 100));
                 }
             }
         }
@@ -98,9 +98,9 @@ export class AgentDispatcher {
     isReady(task) {
         if (!task.blockedBy || task.blockedBy.length === 0)
             return true;
-        return task.blockedBy.every(id => {
+        return task.blockedBy.every((id) => {
             const blocker = this.tasks.get(id);
-            return blocker && (blocker.status === 'completed' || blocker.status === 'failed');
+            return blocker && (blocker.status === "completed" || blocker.status === "failed");
         });
     }
     async runTask(task) {
@@ -112,13 +112,13 @@ export class AgentDispatcher {
             worktreePath = createWorktree(cwd);
         }
         try {
-            const { query } = await import('../query.js');
+            const { query } = await import("../query.js");
             // Filter tools if task specifies allowed tools
             let taskTools = this.tools;
             if (task.allowedTools && task.allowedTools.length > 0) {
-                const allowSet = new Set(task.allowedTools.map(n => n.toLowerCase()));
-                allowSet.add('askuser');
-                const filtered = this.tools.filter(t => allowSet.has(t.name.toLowerCase()));
+                const allowSet = new Set(task.allowedTools.map((n) => n.toLowerCase()));
+                allowSet.add("askuser");
+                const filtered = this.tools.filter((t) => allowSet.has(t.name.toLowerCase()));
                 if (filtered.length > 0)
                     taskTools = filtered;
             }
@@ -135,12 +135,12 @@ export class AgentDispatcher {
             let promptWithContext = task.prompt;
             if (task.blockedBy && task.blockedBy.length > 0) {
                 const blockerContext = task.blockedBy
-                    .map(id => {
+                    .map((id) => {
                     const r = this.results.get(id);
-                    return r ? `## Result from task "${id}":\n${r.output.slice(0, 1000)}` : '';
+                    return r ? `## Result from task "${id}":\n${r.output.slice(0, 1000)}` : "";
                 })
                     .filter(Boolean)
-                    .join('\n\n');
+                    .join("\n\n");
                 if (blockerContext) {
                     promptWithContext = `${blockerContext}\n\n---\n\n${task.prompt}`;
                 }
@@ -150,14 +150,16 @@ export class AgentDispatcher {
                 try {
                     process.chdir(worktreePath);
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
-            let output = '';
+            let output = "";
             try {
                 for await (const event of query(promptWithContext, config)) {
-                    if (event.type === 'text_delta')
+                    if (event.type === "text_delta")
                         output += event.content;
-                    if (event.type === 'error') {
+                    if (event.type === "error") {
                         return { id: task.id, output: `Error: ${event.message}`, isError: true, durationMs: Date.now() - start };
                     }
                 }
@@ -167,10 +169,12 @@ export class AgentDispatcher {
                     try {
                         process.chdir(originalCwd);
                     }
-                    catch { /* ignore */ }
+                    catch {
+                        /* ignore */
+                    }
                 }
             }
-            return { id: task.id, output: output || '(no output)', isError: false, durationMs: Date.now() - start };
+            return { id: task.id, output: output || "(no output)", isError: false, durationMs: Date.now() - start };
         }
         catch (err) {
             return {

package/dist/services/CronExecutor.d.ts

@@ -8,10 +8,10 @@
  * Execution is non-blocking and failure-isolated — one failing cron
  * does not affect others or the main REPL session.
  */
-import type { Provider } from '../providers/base.js';
-import type { Tools } from '../Tool.js';
-import type { PermissionMode } from '../types/permissions.js';
-import { type CronResult } from './cron.js';
+import type { Provider } from "../providers/base.js";
+import type { Tools } from "../Tool.js";
+import type { PermissionMode } from "../types/permissions.js";
+import { type CronResult } from "./cron.js";
 export declare class CronExecutor {
     private provider;
     private tools;

package/dist/services/CronExecutor.js

@@ -8,7 +8,7 @@
  * Execution is non-blocking and failure-isolated — one failing cron
  * does not affect others or the main REPL session.
  */
-import { listCrons, getDueCrons, updateCron, saveCronResult, } from './cron.js';
+import { getDueCrons, listCrons, saveCronResult, updateCron } from "./cron.js";
 const CHECK_INTERVAL_MS = 60_000; // Check every 60 seconds
 const MAX_CRON_TURNS = 10; // Limit sub-query turns for cron tasks
 export class CronExecutor {
@@ -35,12 +35,16 @@ export class CronExecutor {
         // Run first tick after a short delay (don't block startup)
         setTimeout(() => {
             if (!this._stopped)
-                this.tick().catch(() => { });
+                this.tick().catch(() => {
+                    /* fire-and-forget: cron tick errors are non-fatal */
+                });
         }, 5_000);
         // Then check every 60 seconds
         this.intervalId = setInterval(() => {
             if (!this._stopped)
-                this.tick().catch(() => { });
+                this.tick().catch(() => {
+                    /* fire-and-forget: cron tick errors are non-fatal */
+                });
         }, CHECK_INTERVAL_MS);
     }
     /** Stop the scheduler */
@@ -69,7 +73,7 @@ export class CronExecutor {
                 const result = {
                     cronId: cron.id,
                     timestamp: Date.now(),
-                    output: '',
+                    output: "",
                     error: err instanceof Error ? err.message : String(err),
                 };
                 saveCronResult(result);
@@ -83,7 +87,7 @@ export class CronExecutor {
         this.running.add(cron.id);
         const timestamp = Date.now();
         try {
-            const { query } = await import('../query.js');
+            const { query } = await import("../query.js");
             const config = {
                 provider: this.provider,
                 tools: this.tools,
@@ -92,11 +96,11 @@ export class CronExecutor {
                 model: this.model,
                 maxTurns: MAX_CRON_TURNS,
             };
-            let output = '';
+            let output = "";
             for await (const event of query(cron.prompt, config)) {
-                if (event.type === 'text_delta')
+                if (event.type === "text_delta")
                     output += event.content;
-                if (event.type === 'error') {
+                if (event.type === "error") {
                     const result = { cronId: cron.id, timestamp, output, error: event.message };
                     saveCronResult(result);
                     // Still update lastRun on error to prevent rapid retry loops

package/dist/services/EvaluatorLoop.d.ts

@@ -12,9 +12,9 @@
  * 3. If below threshold, Generator refines based on feedback
  * 4. Repeat until pass or max iterations reached
  */
-import type { Provider } from '../providers/base.js';
-import type { Tools } from '../Tool.js';
-import type { PermissionMode } from '../types/permissions.js';
+import type { Provider } from "../providers/base.js";
+import type { Tools } from "../Tool.js";
+import type { PermissionMode } from "../types/permissions.js";
 export type EvaluationCriterion = {
     name: string;
     weight: number;

package/dist/services/EvaluatorLoop.js

@@ -15,10 +15,18 @@
 // ── Default Rubric ──
 export const DEFAULT_RUBRIC = {
     criteria: [
-        { name: 'correctness', weight: 0.4, description: 'Does the output correctly address the task? Are there logical errors?' },
-        { name: 'completeness', weight: 0.3, description: 'Is the solution complete? Any missing edge cases or requirements?' },
-        { name: 'quality', weight: 0.2, description: 'Is the code clean, well-structured, and following best practices?' },
-        { name: 'safety', weight: 0.1, description: 'Are there security issues, unsafe patterns, or potential bugs?' },
+        {
+            name: "correctness",
+            weight: 0.4,
+            description: "Does the output correctly address the task? Are there logical errors?",
+        },
+        {
+            name: "completeness",
+            weight: 0.3,
+            description: "Is the solution complete? Any missing edge cases or requirements?",
+        },
+        { name: "quality", weight: 0.2, description: "Is the code clean, well-structured, and following best practices?" },
+        { name: "safety", weight: 0.1, description: "Are there security issues, unsafe patterns, or potential bugs?" },
     ],
     passThreshold: 0.7,
 };
@@ -45,14 +53,14 @@ export class EvaluatorLoop {
      */
     async run(task) {
         const refinements = [];
-        let currentOutput = '';
+        let currentOutput = "";
         let scores = [];
         let weightedScore = 0;
         for (let iteration = 1; iteration <= this.maxIterations; iteration++) {
             // ── Generate ──
             const generatorPrompt = iteration === 1
                 ? task
-                : `${task}\n\n[Evaluator feedback from iteration ${iteration - 1}]:\n${scores.map(s => `${s.criterion}: ${s.score}/1.0 — ${s.feedback}`).join('\n')}\n\nPlease refine your output based on this feedback.`;
+                : `${task}\n\n[Evaluator feedback from iteration ${iteration - 1}]:\n${scores.map((s) => `${s.criterion}: ${s.score}/1.0 — ${s.feedback}`).join("\n")}\n\nPlease refine your output based on this feedback.`;
             currentOutput = await this.generate(generatorPrompt);
             // ── Evaluate ──
             scores = await this.evaluate(task, currentOutput);
@@ -80,7 +88,7 @@ export class EvaluatorLoop {
         };
     }
     async generate(prompt) {
-        const { query } = await import('../query.js');
+        const { query } = await import("../query.js");
         const config = {
             provider: this.provider,
             tools: this.tools,
@@ -89,9 +97,9 @@ export class EvaluatorLoop {
             model: this.model,
             maxTurns: 15,
         };
-        let output = '';
+        let output = "";
         for await (const event of query(prompt, config)) {
-            if (event.type === 'text_delta')
+            if (event.type === "text_delta")
                 output += event.content;
         }
         return output;
@@ -105,16 +113,16 @@ Output to evaluate:
 ${output.slice(0, 3000)}
 
 Criteria:
-${this.rubric.criteria.map(c => `- ${c.name} (weight: ${c.weight}): ${c.description}`).join('\n')}
+${this.rubric.criteria.map((c) => `- ${c.name} (weight: ${c.weight}): ${c.description}`).join("\n")}
 
 Respond ONLY with a JSON array: [{"criterion": "name", "score": 0.8, "feedback": "brief explanation"}, ...]`;
-        const response = await this.provider.complete([{ role: 'user', content: evaluationPrompt, uuid: `eval-${Date.now()}`, timestamp: Date.now() }], 'You are a strict code evaluator. Respond ONLY with valid JSON. Be critical and specific.', undefined, this.model);
+        const response = await this.provider.complete([{ role: "user", content: evaluationPrompt, uuid: `eval-${Date.now()}`, timestamp: Date.now() }], "You are a strict code evaluator. Respond ONLY with valid JSON. Be critical and specific.", undefined, this.model);
         try {
             const jsonMatch = response.content.match(/\[[\s\S]*\]/);
             if (!jsonMatch)
                 return this.defaultScores();
             const parsed = JSON.parse(jsonMatch[0]);
-            return parsed.filter(s => s.criterion && typeof s.score === 'number');
+            return parsed.filter((s) => s.criterion && typeof s.score === "number");
         }
         catch {
             return this.defaultScores();
@@ -123,35 +131,35 @@ Respond ONLY with a JSON array: [{"criterion": "name", "score": 0.8, "feedback":
     calculateWeightedScore(scores) {
         let total = 0;
         for (const criterion of this.rubric.criteria) {
-            const score = scores.find(s => s.criterion === criterion.name);
+            const score = scores.find((s) => s.criterion === criterion.name);
             total += (score?.score ?? 0.5) * criterion.weight;
         }
         return total;
     }
     defaultScores() {
-        return this.rubric.criteria.map(c => ({
+        return this.rubric.criteria.map((c) => ({
             criterion: c.name,
             score: 0.5,
-            feedback: 'Could not evaluate (parsing error)',
+            feedback: "Could not evaluate (parsing error)",
         }));
     }
 }
 /** Format evaluator results for display */
 export function formatEvaluatorResult(result) {
     const lines = [];
-    lines.push(`Evaluator: ${result.passed ? 'PASSED' : 'NEEDS IMPROVEMENT'} (${result.weightedScore.toFixed(2)}/${1.0})`);
+    lines.push(`Evaluator: ${result.passed ? "PASSED" : "NEEDS IMPROVEMENT"} (${result.weightedScore.toFixed(2)}/${1.0})`);
     lines.push(`Iterations: ${result.iterations}`);
-    lines.push('');
+    lines.push("");
     for (const s of result.scores) {
-        const bar = '█'.repeat(Math.round(s.score * 10)) + '░'.repeat(10 - Math.round(s.score * 10));
+        const bar = "█".repeat(Math.round(s.score * 10)) + "░".repeat(10 - Math.round(s.score * 10));
         lines.push(`  ${s.criterion.padEnd(15)} ${bar} ${s.score.toFixed(1)} — ${s.feedback}`);
     }
     if (result.refinements.length > 0) {
-        lines.push('');
-        lines.push('Refinements:');
+        lines.push("");
+        lines.push("Refinements:");
         for (const r of result.refinements)
             lines.push(`  ${r}`);
     }
-    return lines.join('\n');
+    return lines.join("\n");
 }
 //# sourceMappingURL=EvaluatorLoop.js.map

package/dist/services/MetaHarness.d.ts

@@ -18,7 +18,7 @@
  * - Compression strategy
  * - Permission rules
  */
-import type { Provider } from '../providers/base.js';
+import type { Provider } from "../providers/base.js";
 export type BenchmarkResult = {
     score: number;
     details: string;