@zhijiewang/openharness 2.1.0 → 2.3.1

package/dist/harness/telemetry.d.ts

@@ -12,7 +12,7 @@
  * Optional: POST to configurable endpoint on session end.
  */
 export type TelemetryEvent = {
-    type: 'session_start' | 'tool_call' | 'error' | 'session_end';
+    type: "session_start" | "tool_call" | "error" | "session_end";
     timestamp: number;
     sessionId: string;
     payload: TelemetryPayload;

package/dist/harness/telemetry.js

@@ -11,11 +11,11 @@
  * Events are batched locally as JSONL in ~/.oh/telemetry/.
  * Optional: POST to configurable endpoint on session end.
  */
-import { appendFileSync, mkdirSync, existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { readOhConfig } from './config.js';
-const TELEMETRY_DIR = join(homedir(), '.oh', 'telemetry');
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readOhConfig } from "./config.js";
+const TELEMETRY_DIR = join(homedir(), ".oh", "telemetry");
 // ── State ──
 let _enabled;
 let _sessionFile = null;
@@ -40,14 +40,16 @@ export function recordEvent(event) {
         return;
     try {
         const file = getSessionFile(event.sessionId);
-        appendFileSync(file, JSON.stringify(event) + '\n');
+        appendFileSync(file, `${JSON.stringify(event)}\n`);
+    }
+    catch {
+        /* never crash on telemetry failure */
     }
-    catch { /* never crash on telemetry failure */ }
 }
 /** Convenience: record a tool call event */
 export function recordToolCall(sessionId, toolName, durationMs, isError) {
     recordEvent({
-        type: 'tool_call',
+        type: "tool_call",
         timestamp: Date.now(),
         sessionId,
         payload: { toolName, durationMs, isError },
@@ -56,7 +58,7 @@ export function recordToolCall(sessionId, toolName, durationMs, isError) {
 /** Convenience: record session start */
 export function recordSessionStart(sessionId, provider, model) {
     recordEvent({
-        type: 'session_start',
+        type: "session_start",
         timestamp: Date.now(),
         sessionId,
         payload: { provider, model, platform: process.platform },
@@ -65,7 +67,7 @@ export function recordSessionStart(sessionId, provider, model) {
 /** Convenience: record session end with stats */
 export function recordSessionEnd(sessionId, stats) {
     recordEvent({
-        type: 'session_end',
+        type: "session_end",
         timestamp: Date.now(),
         sessionId,
         payload: stats,
@@ -74,7 +76,7 @@ export function recordSessionEnd(sessionId, stats) {
 /** Convenience: record an error */
 export function recordError(sessionId, category) {
     recordEvent({
-        type: 'error',
+        type: "error",
         timestamp: Date.now(),
         sessionId,
         payload: { errorCategory: category },
@@ -86,10 +88,10 @@ export function readSessionEvents(sessionId) {
     if (!existsSync(file))
         return [];
     try {
-        return readFileSync(file, 'utf-8')
-            .split('\n')
+        return readFileSync(file, "utf-8")
+            .split("\n")
             .filter(Boolean)
-            .map(line => JSON.parse(line));
+            .map((line) => JSON.parse(line));
     }
     catch {
         return [];
@@ -99,25 +101,27 @@ export function readSessionEvents(sessionId) {
 export function getAggregateStats() {
     if (!existsSync(TELEMETRY_DIR))
         return { totalSessions: 0, totalEvents: 0, toolUsage: {}, errorCategories: {} };
-    const files = readdirSync(TELEMETRY_DIR).filter(f => f.endsWith('.jsonl'));
+    const files = readdirSync(TELEMETRY_DIR).filter((f) => f.endsWith(".jsonl"));
     const toolUsage = {};
     const errorCategories = {};
     let totalEvents = 0;
     for (const file of files) {
         try {
-            const lines = readFileSync(join(TELEMETRY_DIR, file), 'utf-8').split('\n').filter(Boolean);
+            const lines = readFileSync(join(TELEMETRY_DIR, file), "utf-8").split("\n").filter(Boolean);
             totalEvents += lines.length;
             for (const line of lines) {
                 const event = JSON.parse(line);
-                if (event.type === 'tool_call' && event.payload.toolName) {
+                if (event.type === "tool_call" && event.payload.toolName) {
                     toolUsage[event.payload.toolName] = (toolUsage[event.payload.toolName] ?? 0) + 1;
                 }
-                if (event.type === 'error' && event.payload.errorCategory) {
+                if (event.type === "error" && event.payload.errorCategory) {
                     errorCategories[event.payload.errorCategory] = (errorCategories[event.payload.errorCategory] ?? 0) + 1;
                 }
             }
         }
-        catch { /* skip malformed files */ }
+        catch {
+            /* skip malformed files */
+        }
     }
     return { totalSessions: files.length, totalEvents, toolUsage, errorCategories };
 }

package/dist/harness/traces.d.ts

@@ -15,7 +15,7 @@ export type TraceSpan = {
     endTime: number;
     durationMs: number;
     attributes: Record<string, unknown>;
-    status: 'ok' | 'error';
+    status: "ok" | "error";
 };
 export type TraceEvent = {
     name: string;
@@ -31,7 +31,7 @@ export declare class SessionTracer {
     /** Start a new span. Returns the span ID. */
     startSpan(name: string, attributes?: Record<string, unknown>, parentSpanId?: string): string;
     /** End a span and record it. */
-    endSpan(spanId: string, status?: 'ok' | 'error', extraAttributes?: Record<string, unknown>): TraceSpan | null;
+    endSpan(spanId: string, status?: "ok" | "error", extraAttributes?: Record<string, unknown>): TraceSpan | null;
     /** Get all completed spans */
     getSpans(): TraceSpan[];
     /** Get a summary of the trace */

package/dist/harness/traces.js

@@ -7,10 +7,10 @@
  *
  * Compatible with OpenTelemetry export format.
  */
-import { appendFileSync, mkdirSync, existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-const TRACE_DIR = join(homedir(), '.oh', 'traces');
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const TRACE_DIR = join(homedir(), ".oh", "traces");
 // ── Tracer ──
 const MAX_IN_MEMORY_SPANS = 1000;
 export class SessionTracer {
@@ -28,7 +28,7 @@ export class SessionTracer {
         return spanId;
     }
     /** End a span and record it. */
-    endSpan(spanId, status = 'ok', extraAttributes) {
+    endSpan(spanId, status = "ok", extraAttributes) {
         const active = this.activeSpans.get(spanId);
         if (!active)
             return null;
@@ -67,7 +67,7 @@ export class SessionTracer {
             entry.count++;
             entry.totalMs += span.durationMs;
             spansByName[span.name] = entry;
-            if (span.status === 'error')
+            if (span.status === "error")
                 errors++;
             if (span.startTime < minStart)
                 minStart = span.startTime;
@@ -86,9 +86,11 @@ export class SessionTracer {
         try {
             mkdirSync(TRACE_DIR, { recursive: true });
             const file = join(TRACE_DIR, `${this.sessionId}.jsonl`);
-            appendFileSync(file, JSON.stringify(span) + '\n');
+            appendFileSync(file, `${JSON.stringify(span)}\n`);
+        }
+        catch {
+            /* never crash on tracing failure */
         }
-        catch { /* never crash on tracing failure */ }
     }
 }
 // ── Trace Loading ──
@@ -98,10 +100,10 @@ export function loadTrace(sessionId) {
     if (!existsSync(file))
         return [];
     try {
-        return readFileSync(file, 'utf-8')
-            .split('\n')
+        return readFileSync(file, "utf-8")
+            .split("\n")
             .filter(Boolean)
-            .map(line => JSON.parse(line));
+            .map((line) => JSON.parse(line));
     }
     catch {
         return [];
@@ -112,16 +114,16 @@ export function listTracedSessions() {
     if (!existsSync(TRACE_DIR))
         return [];
     return readdirSync(TRACE_DIR)
-        .filter(f => f.endsWith('.jsonl'))
-        .map(f => f.replace('.jsonl', ''));
+        .filter((f) => f.endsWith(".jsonl"))
+        .map((f) => f.replace(".jsonl", ""));
 }
 /** Format trace for display */
 export function formatTrace(spans) {
     if (spans.length === 0)
-        return 'No trace spans recorded.';
+        return "No trace spans recorded.";
     const lines = [`Trace (${spans.length} spans):\n`];
     // Group by parent for tree display
-    const roots = spans.filter(s => !s.parentSpanId);
+    const roots = spans.filter((s) => !s.parentSpanId);
     const children = new Map();
     for (const s of spans) {
         if (s.parentSpanId) {
@@ -131,12 +133,12 @@ export function formatTrace(spans) {
         }
     }
     function renderSpan(span, indent) {
-        const status = span.status === 'error' ? '✗' : '✓';
-        const pad = '  '.repeat(indent);
+        const status = span.status === "error" ? "✗" : "✓";
+        const pad = "  ".repeat(indent);
         const attrs = Object.entries(span.attributes)
             .filter(([, v]) => v !== undefined)
             .map(([k, v]) => `${k}=${String(v).slice(0, 30)}`)
-            .join(' ');
+            .join(" ");
         lines.push(`${pad}${status} ${span.name} (${span.durationMs}ms) ${attrs}`);
         const kids = children.get(span.spanId) ?? [];
         for (const kid of kids)
@@ -146,27 +148,29 @@ export function formatTrace(spans) {
         renderSpan(root, 0);
     // Summary
     const totalMs = spans.reduce((sum, s) => sum + s.durationMs, 0);
-    const errors = spans.filter(s => s.status === 'error').length;
-    lines.push('');
+    const errors = spans.filter((s) => s.status === "error").length;
+    lines.push("");
     lines.push(`Total: ${spans.length} spans, ${totalMs}ms, ${errors} errors`);
-    return lines.join('\n');
+    return lines.join("\n");
 }
 /** Export trace in OpenTelemetry-compatible format */
 export function exportTraceOTLP(sessionId, spans) {
     return {
-        resourceSpans: [{
+        resourceSpans: [
+            {
                 resource: {
                     attributes: [
-                        { key: 'service.name', value: { stringValue: 'openharness' } },
-                        { key: 'session.id', value: { stringValue: sessionId } },
+                        { key: "service.name", value: { stringValue: "openharness" } },
+                        { key: "session.id", value: { stringValue: sessionId } },
                     ],
                 },
-                scopeSpans: [{
-                        scope: { name: 'openharness.agent' },
-                        spans: spans.map(s => ({
-                            traceId: sessionId.padEnd(32, '0').slice(0, 32),
-                            spanId: s.spanId.padEnd(16, '0').slice(0, 16),
-                            parentSpanId: s.parentSpanId?.padEnd(16, '0').slice(0, 16),
+                scopeSpans: [
+                    {
+                        scope: { name: "openharness.agent" },
+                        spans: spans.map((s) => ({
+                            traceId: sessionId.padEnd(32, "0").slice(0, 32),
+                            spanId: s.spanId.padEnd(16, "0").slice(0, 16),
+                            parentSpanId: s.parentSpanId?.padEnd(16, "0").slice(0, 16),
                             name: s.name,
                             startTimeUnixNano: s.startTime * 1_000_000,
                             endTimeUnixNano: s.endTime * 1_000_000,
@@ -174,10 +178,12 @@ export function exportTraceOTLP(sessionId, spans) {
                                 key: k,
                                 value: { stringValue: String(v) },
                             })),
-                            status: { code: s.status === 'ok' ? 1 : 2 },
+                            status: { code: s.status === "ok" ? 1 : 2 },
                         })),
-                    }],
-            }],
+                    },
+                ],
+            },
+        ],
     };
 }
 //# sourceMappingURL=traces.js.map

package/dist/harness/verification.d.ts

@@ -15,7 +15,7 @@ export type VerificationRule = {
 };
 export type VerificationConfig = {
     enabled: boolean;
-    mode: 'warn' | 'block';
+    mode: "warn" | "block";
     rules: VerificationRule[];
 };
 export type VerificationResult = {

package/dist/harness/verification.js

@@ -8,10 +8,10 @@
  * This is the single highest-impact harness engineering pattern —
  * research shows 2-3x quality improvement from automated feedback.
  */
-import { execSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { extname, join } from 'node:path';
-import { readOhConfig } from './config.js';
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { extname, join } from "node:path";
+import { readOhConfig } from "./config.js";
 const MAX_SUMMARY_CHARS = 500;
 const DEFAULT_TIMEOUT_MS = 10_000;
 // ── Auto-detection ──
@@ -20,43 +20,50 @@ export function autoDetectRules(projectRoot) {
     const root = projectRoot ?? process.cwd();
     const rules = [];
     // TypeScript
-    if (existsSync(join(root, 'tsconfig.json'))) {
+    if (existsSync(join(root, "tsconfig.json"))) {
         rules.push({
-            extensions: ['.ts', '.tsx'],
-            lint: 'npx tsc --noEmit 2>&1 | head -20',
+            extensions: [".ts", ".tsx"],
+            lint: "npx tsc --noEmit 2>&1 | head -20",
             timeout: 15_000,
         });
     }
     // ESLint (JS/TS)
-    const eslintConfigs = ['.eslintrc', '.eslintrc.js', '.eslintrc.json', '.eslintrc.yml', 'eslint.config.js', 'eslint.config.mjs'];
-    if (eslintConfigs.some(f => existsSync(join(root, f)))) {
+    const eslintConfigs = [
+        ".eslintrc",
+        ".eslintrc.js",
+        ".eslintrc.json",
+        ".eslintrc.yml",
+        "eslint.config.js",
+        "eslint.config.mjs",
+    ];
+    if (eslintConfigs.some((f) => existsSync(join(root, f)))) {
         rules.push({
-            extensions: ['.js', '.jsx', '.ts', '.tsx'],
-            lint: 'npx eslint {file} --no-color 2>&1 | head -15',
+            extensions: [".js", ".jsx", ".ts", ".tsx"],
+            lint: "npx eslint {file} --no-color 2>&1 | head -15",
             timeout: 10_000,
         });
     }
     // Python — ruff (fast) or pylint
-    if (existsSync(join(root, 'pyproject.toml')) || existsSync(join(root, 'setup.py'))) {
+    if (existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "setup.py"))) {
         rules.push({
-            extensions: ['.py'],
-            lint: 'ruff check {file} 2>&1 | head -10',
+            extensions: [".py"],
+            lint: "ruff check {file} 2>&1 | head -10",
             timeout: 10_000,
         });
     }
     // Go
-    if (existsSync(join(root, 'go.mod'))) {
+    if (existsSync(join(root, "go.mod"))) {
         rules.push({
-            extensions: ['.go'],
-            lint: 'go vet ./... 2>&1 | head -10',
+            extensions: [".go"],
+            lint: "go vet ./... 2>&1 | head -10",
             timeout: 15_000,
         });
     }
     // Rust
-    if (existsSync(join(root, 'Cargo.toml'))) {
+    if (existsSync(join(root, "Cargo.toml"))) {
         rules.push({
-            extensions: ['.rs'],
-            lint: 'cargo check 2>&1 | tail -10',
+            extensions: [".rs"],
+            lint: "cargo check 2>&1 | tail -10",
             timeout: 30_000,
         });
     }
@@ -78,7 +85,7 @@ export function getVerificationConfig() {
         }
         _cachedConfig = {
             enabled: true,
-            mode: v.mode ?? 'warn',
+            mode: v.mode ?? "warn",
             rules: v.rules ?? autoDetectRules(),
         };
         return _cachedConfig;
@@ -89,7 +96,7 @@ export function getVerificationConfig() {
         _cachedConfig = null;
         return null;
     }
-    _cachedConfig = { enabled: true, mode: 'warn', rules: autoRules };
+    _cachedConfig = { enabled: true, mode: "warn", rules: autoRules };
     return _cachedConfig;
 }
 /** Clear cached config (for testing or after config changes) */
@@ -100,15 +107,15 @@ export function invalidateVerificationCache() {
 /** Extract file paths from tool input that were modified */
 export function extractFilePaths(toolName, toolInput) {
     switch (toolName) {
-        case 'Write':
-        case 'Edit':
+        case "Write":
+        case "Edit":
             return toolInput.file_path ? [String(toolInput.file_path)] : [];
-        case 'MultiEdit':
+        case "MultiEdit":
             // MultiEdit has an array of edits, each with file_path
             if (Array.isArray(toolInput.edits)) {
                 const paths = new Set();
                 for (const edit of toolInput.edits) {
-                    if (edit && typeof edit === 'object' && 'file_path' in edit) {
+                    if (edit && typeof edit === "object" && "file_path" in edit) {
                         paths.add(String(edit.file_path));
                     }
                 }
@@ -123,7 +130,7 @@ export function extractFilePaths(toolName, toolInput) {
 /** Find the matching rule for a file extension */
 function findRule(filePath, rules) {
     const ext = extname(filePath).toLowerCase();
-    return rules.find(r => r.extensions.includes(ext)) ?? null;
+    return rules.find((r) => r.extensions.includes(ext)) ?? null;
 }
 /**
  * Shell-escape a file path to prevent command injection.
@@ -131,7 +138,7 @@ function findRule(filePath, rules) {
  */
 function shellEscape(s) {
     // On Windows, use double quotes; on POSIX, use single quotes
-    if (process.platform === 'win32') {
+    if (process.platform === "win32") {
         // Double-quote and escape internal double quotes and special chars
         return `"${s.replace(/"/g, '\\"')}"`;
     }
@@ -144,30 +151,30 @@ function shellEscape(s) {
  */
 export async function runVerificationForFiles(filePaths, config) {
     if (filePaths.length === 0)
-        return { ran: false, passed: true, summary: '' };
+        return { ran: false, passed: true, summary: "" };
     if (filePaths.length === 1)
         return runVerification(filePaths[0], config);
     const results = [];
     for (const fp of filePaths) {
         results.push(await runVerification(fp, config));
     }
-    const ran = results.some(r => r.ran);
-    const passed = results.every(r => r.passed);
-    const failures = results.filter(r => r.ran && !r.passed);
+    const ran = results.some((r) => r.ran);
+    const passed = results.every((r) => r.passed);
+    const failures = results.filter((r) => r.ran && !r.passed);
     if (!ran)
-        return { ran: false, passed: true, summary: '' };
+        return { ran: false, passed: true, summary: "" };
     if (passed)
-        return { ran: true, passed: true, summary: '' };
+        return { ran: true, passed: true, summary: "" };
     // Aggregate failure summaries (cap total to MAX_SUMMARY_CHARS)
-    const summaryParts = failures.map(r => r.summary).filter(Boolean);
-    const summary = summaryParts.join('\n---\n').slice(0, MAX_SUMMARY_CHARS);
+    const summaryParts = failures.map((r) => r.summary).filter(Boolean);
+    const summary = summaryParts.join("\n---\n").slice(0, MAX_SUMMARY_CHARS);
     return { ran: true, passed: false, summary };
 }
 /** Run verification for a single file. Returns result with concise summary. */
 export async function runVerification(filePath, config) {
     const rule = findRule(filePath, config.rules);
-    if (!rule || !rule.lint) {
-        return { ran: false, passed: true, summary: '' };
+    if (!rule?.lint) {
+        return { ran: false, passed: true, summary: "" };
     }
     const command = rule.lint.replace(/\{file\}/g, shellEscape(filePath));
     const timeout = rule.timeout ?? DEFAULT_TIMEOUT_MS;
@@ -175,21 +182,20 @@ export async function runVerification(filePath, config) {
         execSync(command, {
             timeout,
             cwd: process.cwd(),
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
             windowsHide: true,
         });
         // Exit code 0 = passed
-        return { ran: true, passed: true, summary: '' };
+        return { ran: true, passed: true, summary: "" };
     }
     catch (err) {
         // Timeout detection — check killed flag, signal, or error code
-        const isTimeout = err.killed || err.signal === 'SIGTERM' || err.code === 'ETIMEDOUT'
-            || (err.status === null && err.signal);
+        const isTimeout = err.killed || err.signal === "SIGTERM" || err.code === "ETIMEDOUT" || (err.status === null && err.signal);
         if (isTimeout) {
             return { ran: true, passed: false, summary: `Verification timed out after ${timeout / 1000}s` };
         }
-        const output = String(err.stdout ?? err.stderr ?? err.message ?? 'Unknown error');
+        const output = String(err.stdout ?? err.stderr ?? err.message ?? "Unknown error");
         const summary = output.slice(0, MAX_SUMMARY_CHARS).trim();
         return { ran: true, passed: false, summary };
     }