@zhijiewang/openharness 0.11.1 → 0.12.1

package/dist/harness/config.js

@@ -3,6 +3,7 @@
  */
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { join } from "node:path";
+import { homedir } from "node:os";
 import { parse, stringify } from "yaml";
 function yamlScalar(value) {
     return `'${value.replace(/'/g, "''")}'`;
@@ -17,41 +18,62 @@ export function invalidateConfigCache() {
     _configCache = undefined;
     _configCacheRoot = undefined;
 }
+/** Path to global config: ~/.oh/config.yaml */
+function globalConfigPath() {
+    return join(homedir(), '.oh', 'config.yaml');
+}
+/** Read global config as fallback defaults */
+function readGlobalConfig() {
+    const p = globalConfigPath();
+    if (!existsSync(p))
+        return null;
+    try {
+        return parse(readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
 export function readOhConfig(root) {
     const effectiveRoot = root ?? ".";
     if (_configCache !== undefined && _configCacheRoot === effectiveRoot)
         return _configCache;
     const p = configPath(root);
-    if (!existsSync(p)) {
+    // Layer 1: Global defaults from ~/.oh/config.yaml
+    const globalCfg = readGlobalConfig();
+    // Layer 2: Project config from .oh/config.yaml
+    let projectCfg = null;
+    if (existsSync(p)) {
+        try {
+            projectCfg = parse(readFileSync(p, "utf-8"));
+        }
+        catch { /* ignore malformed project config */ }
+    }
+    // If neither exists, no config
+    if (!globalCfg && !projectCfg) {
         _configCache = null;
         _configCacheRoot = effectiveRoot;
         return null;
     }
-    try {
-        const base = parse(readFileSync(p, "utf-8"));
-        // Merge local overrides from config.local.yaml (gitignored personal settings)
-        const localPath = join(root ?? ".", ".oh", "config.local.yaml");
-        if (existsSync(localPath)) {
-            try {
-                const local = parse(readFileSync(localPath, "utf-8"));
-                if (local) {
-                    const merged = { ...base, ...local };
-                    _configCache = merged;
-                    _configCacheRoot = effectiveRoot;
-                    return merged;
-                }
+    // Merge: global → project (project overrides global)
+    const base = { ...globalCfg, ...projectCfg };
+    // Layer 3: Local overrides from .oh/config.local.yaml (gitignored personal settings)
+    const localPath = join(root ?? ".", ".oh", "config.local.yaml");
+    if (existsSync(localPath)) {
+        try {
+            const local = parse(readFileSync(localPath, "utf-8"));
+            if (local) {
+                const merged = { ...base, ...local };
+                _configCache = merged;
+                _configCacheRoot = effectiveRoot;
+                return merged;
             }
-            catch { /* ignore malformed local config */ }
         }
-        _configCache = base;
-        _configCacheRoot = effectiveRoot;
-        return base;
-    }
-    catch {
-        _configCache = null;
-        _configCacheRoot = effectiveRoot;
-        return null;
+        catch { /* ignore malformed local config */ }
     }
+    _configCache = base;
+    _configCacheRoot = effectiveRoot;
+    return base;
 }
 export function writeOhConfig(cfg, root) {
     invalidateConfigCache();

package/dist/harness/memory.d.ts

@@ -41,6 +41,18 @@ export declare function decayAndPrune(memories: MemoryEntry[]): {
 };
 /** Load memories with decay applied, sorted by relevance */
 export declare function loadActiveMemories(): MemoryEntry[];
+/** Delete memory files that have been pruned (relevance < 0.1) */
+export declare function deletePrunedMemories(pruned: MemoryEntry[]): number;
+export type ConsolidationResult = {
+    total: number;
+    pruned: number;
+    decayed: number;
+};
+/**
+ * Run full memory consolidation: apply decay, delete pruned files,
+ * persist updated relevance scores. Designed to run on session end.
+ */
+export declare function consolidateMemories(): ConsolidationResult;
 /**
  * Detect if recent assistant messages contain learnable patterns.
  * Returns structured memories to save, or empty array.

package/dist/harness/memory.js

@@ -7,8 +7,8 @@
  * The system detects learnable patterns from assistant responses and saves them
  * without user intervention.
  */
-import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, unlinkSync } from 'node:fs';
+import { join, resolve, sep } from 'node:path';
 import { homedir } from 'node:os';
 import { createUserMessage } from '../types/message.js';
 const PROJECT_MEMORY_DIR = join('.oh', 'memory');
@@ -159,6 +159,57 @@ export function loadActiveMemories() {
     // Sort by relevance (highest first), then by access count
     return active.sort((a, b) => (b.relevance ?? 0.5) - (a.relevance ?? 0.5) || (b.accessCount ?? 0) - (a.accessCount ?? 0));
 }
+// ── Dream Consolidation ──
+// Background memory pruning and relevance persistence on session end.
+/** Delete memory files that have been pruned (relevance < 0.1) */
+export function deletePrunedMemories(pruned) {
+    // Guard: only delete files within known memory directories
+    const allowedDirs = [PROJECT_MEMORY_DIR, GLOBAL_MEMORY_DIR].map(d => resolve(d));
+    let count = 0;
+    for (const m of pruned) {
+        const resolved = resolve(m.filePath);
+        if (!allowedDirs.some(d => resolved.startsWith(d + sep)))
+            continue;
+        try {
+            unlinkSync(m.filePath);
+            count++;
+        }
+        catch { /* ignore */ }
+    }
+    return count;
+}
+/** Write back decayed relevance score to file frontmatter */
+function persistDecayedRelevance(entry) {
+    try {
+        let raw = readFileSync(entry.filePath, 'utf-8');
+        if (raw.match(/^relevance:/m)) {
+            raw = raw.replace(/^relevance:\s*[0-9.]+$/m, `relevance: ${(entry.relevance ?? 0.5).toFixed(2)}`);
+            writeFileSync(entry.filePath, raw);
+        }
+    }
+    catch { /* ignore */ }
+}
+/**
+ * Run full memory consolidation: apply decay, delete pruned files,
+ * persist updated relevance scores. Designed to run on session end.
+ */
+export function consolidateMemories() {
+    const all = loadMemories();
+    if (all.length === 0)
+        return { total: 0, pruned: 0, decayed: 0 };
+    const { active, pruned } = decayAndPrune(all);
+    // Delete pruned memory files
+    const prunedCount = deletePrunedMemories(pruned);
+    // Persist updated relevance scores for decayed memories
+    let decayedCount = 0;
+    for (const m of active) {
+        if ((m.relevance ?? 0.5) < 0.5) {
+            persistDecayedRelevance(m);
+            decayedCount++;
+        }
+    }
+    return { total: all.length, pruned: prunedCount, decayed: decayedCount };
+}
 /**
  * Detect if recent assistant messages contain learnable patterns.
  * Returns structured memories to save, or empty array.

package/dist/harness/session.d.ts

@@ -13,6 +13,14 @@ export type Session = {
     gitBranch?: string;
     workingDir?: string;
     tools?: string[];
+    /** Hibernate state — saved on exit for wake reconstruction */
+    hibernate?: {
+        summary?: string;
+        lastUserMessage?: string;
+        pendingTask?: string;
+        totalInputTokens?: number;
+        totalOutputTokens?: number;
+    };
 };
 export declare function createSession(provider: string, model: string, extras?: {
     gitBranch?: string;
@@ -30,6 +38,17 @@ export declare function listSessions(dir?: string): Array<{
 }>;
 /** Returns the ID of the most recently updated session, or null if none exist. */
 export declare function getLastSessionId(dir?: string): string | null;
+/**
+ * Build hibernate state from the current session.
+ * Captures the last user message, recent assistant activity,
+ * and a brief summary for context reconstruction on wake.
+ */
+export declare function buildHibernateState(messages: Message[]): Session['hibernate'];
+/**
+ * Generate a wake-up context message for a resumed session.
+ * Tells the LLM what happened in the previous session.
+ */
+export declare function buildWakeContext(session: Session): string;
 /**
  * Evict oldest sessions when count exceeds MAX_SESSIONS.
  * Called automatically by saveSession.

package/dist/harness/session.js

@@ -72,6 +72,59 @@ export function getLastSessionId(dir) {
     const sessions = listSessions(dir);
     return sessions.length > 0 ? sessions[0].id : null;
 }
+/**
+ * Build hibernate state from the current session.
+ * Captures the last user message, recent assistant activity,
+ * and a brief summary for context reconstruction on wake.
+ */
+export function buildHibernateState(messages) {
+    if (messages.length === 0)
+        return undefined;
+    // Find last user message
+    const lastUser = [...messages].reverse().find(m => m.role === 'user');
+    const lastAssistant = [...messages].reverse().find(m => m.role === 'assistant');
+    // Build a brief summary from the last few exchanges
+    const recentMsgs = messages.slice(-6);
+    const summaryParts = [];
+    for (const m of recentMsgs) {
+        if (m.role === 'user') {
+            summaryParts.push(`User: ${m.content.slice(0, 100)}`);
+        }
+        else if (m.role === 'assistant' && m.content) {
+            summaryParts.push(`Assistant: ${m.content.slice(0, 100)}`);
+        }
+    }
+    return {
+        lastUserMessage: lastUser?.content.slice(0, 200),
+        pendingTask: lastAssistant?.content.slice(0, 200),
+        summary: summaryParts.join('\n'),
+    };
+}
+/**
+ * Generate a wake-up context message for a resumed session.
+ * Tells the LLM what happened in the previous session.
+ */
+export function buildWakeContext(session) {
+    const parts = ['[Session Resumed]'];
+    if (session.workingDir) {
+        parts.push(`Previous working directory: ${session.workingDir}`);
+        if (session.workingDir !== process.cwd()) {
+            parts.push(`WARNING: Working directory changed! Was: ${session.workingDir}, Now: ${process.cwd()}`);
+        }
+    }
+    if (session.gitBranch) {
+        parts.push(`Previous git branch: ${session.gitBranch}`);
+    }
+    if (session.hibernate?.summary) {
+        parts.push(`\nPrevious session context:\n${session.hibernate.summary}`);
+    }
+    if (session.hibernate?.lastUserMessage) {
+        parts.push(`\nLast user request: ${session.hibernate.lastUserMessage}`);
+    }
+    parts.push(`\nSession has ${session.messages.length} messages and cost $${session.totalCost.toFixed(4)} so far.`);
+    parts.push('Continue where you left off. If the user\'s last request was incomplete, acknowledge that and ask how to proceed.');
+    return parts.join('\n');
+}
 /** Maximum number of sessions to keep on disk. */
 const MAX_SESSIONS = 100;
 /**

package/dist/harness/verification.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Verification loops — auto-run lint/typecheck after file edits.
+ *
+ * After file-modifying tools (Edit, Write, MultiEdit) execute,
+ * runs language-appropriate verification commands and returns
+ * concise results to feed back into the agent loop.
+ *
+ * This is the single highest-impact harness engineering pattern —
+ * research shows 2-3x quality improvement from automated feedback.
+ */
+export type VerificationRule = {
+    extensions: string[];
+    lint?: string;
+    timeout?: number;
+};
+export type VerificationConfig = {
+    enabled: boolean;
+    mode: 'warn' | 'block';
+    rules: VerificationRule[];
+};
+export type VerificationResult = {
+    ran: boolean;
+    passed: boolean;
+    summary: string;
+};
+/** Detect verification rules from project files */
+export declare function autoDetectRules(projectRoot?: string): VerificationRule[];
+/** Get verification config from .oh/config.yaml or auto-detect */
+export declare function getVerificationConfig(): VerificationConfig | null;
+/** Clear cached config (for testing or after config changes) */
+export declare function invalidateVerificationCache(): void;
+/** Extract file paths from tool input that were modified */
+export declare function extractFilePaths(toolName: string, toolInput: Record<string, unknown>): string[];
+/**
+ * Run verification for multiple files. Aggregates results.
+ * Returns a single result summarizing all files checked.
+ */
+export declare function runVerificationForFiles(filePaths: string[], config: VerificationConfig): Promise<VerificationResult>;
+/** Run verification for a single file. Returns result with concise summary. */
+export declare function runVerification(filePath: string, config: VerificationConfig): Promise<VerificationResult>;
+//# sourceMappingURL=verification.d.ts.map

package/dist/harness/verification.js

@@ -0,0 +1,197 @@
+/**
+ * Verification loops — auto-run lint/typecheck after file edits.
+ *
+ * After file-modifying tools (Edit, Write, MultiEdit) execute,
+ * runs language-appropriate verification commands and returns
+ * concise results to feed back into the agent loop.
+ *
+ * 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';
+const MAX_SUMMARY_CHARS = 500;
+const DEFAULT_TIMEOUT_MS = 10_000;
+// ── Auto-detection ──
+/** Detect verification rules from project files */
+export function autoDetectRules(projectRoot) {
+    const root = projectRoot ?? process.cwd();
+    const rules = [];
+    // TypeScript
+    if (existsSync(join(root, 'tsconfig.json'))) {
+        rules.push({
+            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)))) {
+        rules.push({
+            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'))) {
+        rules.push({
+            extensions: ['.py'],
+            lint: 'ruff check {file} 2>&1 | head -10',
+            timeout: 10_000,
+        });
+    }
+    // Go
+    if (existsSync(join(root, 'go.mod'))) {
+        rules.push({
+            extensions: ['.go'],
+            lint: 'go vet ./... 2>&1 | head -10',
+            timeout: 15_000,
+        });
+    }
+    // Rust
+    if (existsSync(join(root, 'Cargo.toml'))) {
+        rules.push({
+            extensions: ['.rs'],
+            lint: 'cargo check 2>&1 | tail -10',
+            timeout: 30_000,
+        });
+    }
+    return rules;
+}
+// ── Config ──
+let _cachedConfig;
+/** Get verification config from .oh/config.yaml or auto-detect */
+export function getVerificationConfig() {
+    if (_cachedConfig !== undefined)
+        return _cachedConfig;
+    const ohConfig = readOhConfig();
+    if (ohConfig?.verification) {
+        const v = ohConfig.verification;
+        // Explicitly disabled
+        if (v.enabled === false) {
+            _cachedConfig = null;
+            return null;
+        }
+        _cachedConfig = {
+            enabled: true,
+            mode: v.mode ?? 'warn',
+            rules: v.rules ?? autoDetectRules(),
+        };
+        return _cachedConfig;
+    }
+    // Auto-detect if no config
+    const autoRules = autoDetectRules();
+    if (autoRules.length === 0) {
+        _cachedConfig = null;
+        return null;
+    }
+    _cachedConfig = { enabled: true, mode: 'warn', rules: autoRules };
+    return _cachedConfig;
+}
+/** Clear cached config (for testing or after config changes) */
+export function invalidateVerificationCache() {
+    _cachedConfig = undefined;
+}
+// ── File path extraction ──
+/** Extract file paths from tool input that were modified */
+export function extractFilePaths(toolName, toolInput) {
+    switch (toolName) {
+        case 'Write':
+        case 'Edit':
+            return toolInput.file_path ? [String(toolInput.file_path)] : [];
+        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) {
+                        paths.add(String(edit.file_path));
+                    }
+                }
+                return [...paths];
+            }
+            return toolInput.file_path ? [String(toolInput.file_path)] : [];
+        default:
+            return [];
+    }
+}
+// ── Verification execution ──
+/** 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;
+}
+/**
+ * Shell-escape a file path to prevent command injection.
+ * Wraps in single quotes and escapes any embedded single quotes.
+ */
+function shellEscape(s) {
+    // On Windows, use double quotes; on POSIX, use single quotes
+    if (process.platform === 'win32') {
+        // Double-quote and escape internal double quotes and special chars
+        return `"${s.replace(/"/g, '\\"')}"`;
+    }
+    // POSIX: single-quote and escape embedded single quotes
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}
+/**
+ * Run verification for multiple files. Aggregates results.
+ * Returns a single result summarizing all files checked.
+ */
+export async function runVerificationForFiles(filePaths, config) {
+    if (filePaths.length === 0)
+        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);
+    if (!ran)
+        return { ran: false, passed: true, summary: '' };
+    if (passed)
+        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);
+    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: '' };
+    }
+    const command = rule.lint.replace(/\{file\}/g, shellEscape(filePath));
+    const timeout = rule.timeout ?? DEFAULT_TIMEOUT_MS;
+    try {
+        execSync(command, {
+            timeout,
+            cwd: process.cwd(),
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        // Exit code 0 = passed
+        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);
+        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 summary = output.slice(0, MAX_SUMMARY_CHARS).trim();
+        return { ran: true, passed: false, summary };
+    }
+}
+//# sourceMappingURL=verification.js.map

package/dist/mcp/registry.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MCP Server Registry — curated list of compatible MCP servers.
+ *
+ * Provides a browsable catalog of MCP servers that users can add
+ * to their .oh/config.yaml with a single command.
+ */
+export type McpRegistryEntry = {
+    name: string;
+    package: string;
+    description: string;
+    category: 'filesystem' | 'git' | 'database' | 'api' | 'search' | 'productivity' | 'dev-tools' | 'ai';
+    args?: string[];
+    envVars?: string[];
+    riskLevel?: 'low' | 'medium' | 'high';
+};
+/**
+ * Curated registry of popular MCP servers.
+ * Each entry has enough info to generate the config.yaml block.
+ */
+export declare const MCP_REGISTRY: McpRegistryEntry[];
+/** Search the registry by name or keyword */
+export declare function searchRegistry(query: string): McpRegistryEntry[];
+/** Get all entries in a category */
+export declare function getByCategory(category: McpRegistryEntry['category']): McpRegistryEntry[];
+/** Get all unique categories */
+export declare function getCategories(): string[];
+/** Generate the config.yaml block for a registry entry */
+export declare function generateConfigBlock(entry: McpRegistryEntry): string;
+/** Format registry as a browsable list */
+export declare function formatRegistry(entries?: McpRegistryEntry[]): string;
+//# sourceMappingURL=registry.d.ts.map