@zhijiewang/openharness 2.0.0 → 2.3.0

package/dist/harness/credentials.js

@@ -6,23 +6,23 @@
  * Not bulletproof (key derivation is deterministic from machine info),
  * but far better than plaintext YAML.
  */
-import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'node:crypto';
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir, hostname, userInfo } from 'node:os';
-const CRED_DIR = join(homedir(), '.oh');
-const CRED_PATH = join(CRED_DIR, 'credentials.enc');
-const ALGORITHM = 'aes-256-gcm';
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, hostname, userInfo } from "node:os";
+import { join } from "node:path";
+const CRED_DIR = join(homedir(), ".oh");
+const CRED_PATH = join(CRED_DIR, "credentials.enc");
+const ALGORITHM = "aes-256-gcm";
 /** Derive an encryption key from machine identity */
 function deriveKey() {
     const identity = `${hostname()}-${userInfo().username}-openharness`;
-    return scryptSync(identity, 'oh-credential-salt', 32);
+    return scryptSync(identity, "oh-credential-salt", 32);
 }
 function encrypt(data) {
     const key = deriveKey();
     const iv = randomBytes(12);
     const cipher = createCipheriv(ALGORITHM, key, iv);
-    const encrypted = Buffer.concat([cipher.update(data, 'utf-8'), cipher.final()]);
+    const encrypted = Buffer.concat([cipher.update(data, "utf-8"), cipher.final()]);
     const tag = cipher.getAuthTag();
     // Format: [iv (12)] [tag (16)] [encrypted data]
     return Buffer.concat([iv, tag, encrypted]);
@@ -34,7 +34,7 @@ function decrypt(data) {
     const encrypted = data.subarray(28);
     const decipher = createDecipheriv(ALGORITHM, key, iv);
     decipher.setAuthTag(tag);
-    return decipher.update(encrypted, undefined, 'utf-8') + decipher.final('utf-8');
+    return decipher.update(encrypted, undefined, "utf-8") + decipher.final("utf-8");
 }
 function loadStore() {
     if (!existsSync(CRED_PATH))
@@ -82,9 +82,9 @@ export function listCredentials() {
 export function resolveApiKey(provider, configApiKey) {
     // Environment variable names by provider
     const envVarMap = {
-        anthropic: 'ANTHROPIC_API_KEY',
-        openai: 'OPENAI_API_KEY',
-        openrouter: 'OPENROUTER_API_KEY',
+        anthropic: "ANTHROPIC_API_KEY",
+        openai: "OPENAI_API_KEY",
+        openrouter: "OPENROUTER_API_KEY",
     };
     const envVar = envVarMap[provider];
     if (envVar && process.env[envVar])

package/dist/harness/hooks.js

@@ -103,14 +103,14 @@ async function runHttpHook(url, event, ctx, timeoutMs = 10_000) {
     try {
         const body = JSON.stringify({ event, ...ctx });
         const res = await fetch(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
             body,
             signal: AbortSignal.timeout(timeoutMs),
         });
         if (!res.ok)
             return false;
-        const data = await res.json();
+        const data = (await res.json());
         return data.allowed !== false;
     }
     catch {
@@ -118,7 +118,7 @@ async function runHttpHook(url, event, ctx, timeoutMs = 10_000) {
     }
 }
 /** Run a prompt hook. Uses LLM to make a yes/no decision. */
-async function runPromptHook(promptText, ctx) {
+async function runPromptHook(_promptText, _ctx) {
     // Prompt hooks require a provider — skip if not available
     // This is a lightweight check; full LLM call would need provider injection
     // For now, prompt hooks evaluate the prompt text as a simple template
@@ -177,7 +177,9 @@ export function emitHook(event, ctx = {}) {
     for (const def of defs) {
         if (!matchesHook(def, ctx))
             continue;
-        executeHookDef(def, event, ctx).catch(() => { });
+        executeHookDef(def, event, ctx).catch(() => {
+            /* fire-and-forget: non-preToolUse hooks must not block the agent loop */
+        });
     }
     return true;
 }

package/dist/harness/keybindings.js

@@ -10,10 +10,10 @@
  *
  * Supports single keys and two-key chord sequences (e.g., "ctrl+k ctrl+d").
  */
-import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-const KEYBINDINGS_PATH = join(homedir(), '.oh', 'keybindings.json');
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const KEYBINDINGS_PATH = join(homedir(), ".oh", "keybindings.json");
 let cachedBindings = null;
 /** Load keybindings from ~/.oh/keybindings.json */
 export function loadKeybindings() {
@@ -24,37 +24,39 @@ export function loadKeybindings() {
         return cachedBindings;
     }
     try {
-        const raw = readFileSync(KEYBINDINGS_PATH, 'utf-8');
+        const raw = readFileSync(KEYBINDINGS_PATH, "utf-8");
         const parsed = JSON.parse(raw);
         if (Array.isArray(parsed)) {
             cachedBindings = parsed;
             return cachedBindings;
         }
     }
-    catch { /* ignore parse errors */ }
+    catch {
+        /* ignore parse errors */
+    }
     cachedBindings = defaultKeybindings();
     return cachedBindings;
 }
 /** Default keybindings */
 function defaultKeybindings() {
     return [
-        { key: 'ctrl+d', action: '/diff' },
-        { key: 'ctrl+l', action: '/clear' },
-        { key: 'ctrl+u', action: '/undo' },
-        { key: 'ctrl+s', action: '/status' },
-        { key: 'ctrl+k ctrl+c', action: '/cost' },
-        { key: 'ctrl+k ctrl+f', action: '/fast' },
-        { key: 'ctrl+k ctrl+l', action: '/log' },
+        { key: "ctrl+d", action: "/diff" },
+        { key: "ctrl+l", action: "/clear" },
+        { key: "ctrl+u", action: "/undo" },
+        { key: "ctrl+s", action: "/status" },
+        { key: "ctrl+k ctrl+c", action: "/cost" },
+        { key: "ctrl+k ctrl+f", action: "/fast" },
+        { key: "ctrl+k ctrl+l", action: "/log" },
     ];
 }
 /** Parse a key string like "ctrl+s" into components */
 function parseKeyString(keyStr) {
-    const parts = keyStr.toLowerCase().split('+');
+    const parts = keyStr.toLowerCase().split("+");
     return {
-        ctrl: parts.includes('ctrl'),
-        alt: parts.includes('alt'),
-        shift: parts.includes('shift'),
-        key: parts.filter(p => p !== 'ctrl' && p !== 'alt' && p !== 'shift')[0] ?? '',
+        ctrl: parts.includes("ctrl"),
+        alt: parts.includes("alt"),
+        shift: parts.includes("shift"),
+        key: parts.filter((p) => p !== "ctrl" && p !== "alt" && p !== "shift")[0] ?? "",
     };
 }
 /** Check if an Ink key event matches a parsed key */

package/dist/harness/marketplace.d.ts

@@ -15,13 +15,13 @@ export type MarketplaceEntry = {
     keywords?: string[];
 };
 export type MarketplaceSource = {
-    type: 'github';
+    type: "github";
     repo: string;
 } | {
-    type: 'npm';
+    type: "npm";
     package: string;
 } | {
-    type: 'url';
+    type: "url";
     url: string;
 };
 export type Marketplace = {

package/dist/harness/marketplace.js

@@ -6,13 +6,13 @@
  *
  * Inspired by Claude Code's marketplace model.
  */
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, rmSync } from 'node:fs';
-import { join, basename } from 'node:path';
-import { homedir } from 'node:os';
-import { execSync } from 'node:child_process';
-const MARKETPLACE_DIR = join(homedir(), '.oh', 'marketplaces');
-const PLUGIN_CACHE_DIR = join(homedir(), '.oh', 'plugins', 'cache');
-const INSTALLED_PLUGINS_FILE = join(homedir(), '.oh', 'plugins', 'installed.json');
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+const MARKETPLACE_DIR = join(homedir(), ".oh", "marketplaces");
+const PLUGIN_CACHE_DIR = join(homedir(), ".oh", "plugins", "cache");
+const INSTALLED_PLUGINS_FILE = join(homedir(), ".oh", "plugins", "installed.json");
 // ── Marketplace Management ──
 /** Add a marketplace from a URL, GitHub repo, or local path */
 export function addMarketplace(nameOrUrl) {
@@ -20,30 +20,30 @@ export function addMarketplace(nameOrUrl) {
     // Fetch marketplace.json
     let data;
     let marketplaceName;
-    if (nameOrUrl.startsWith('http')) {
+    if (nameOrUrl.startsWith("http")) {
         // URL
         try {
-            data = execSync(`curl -sL "${nameOrUrl}/marketplace.json"`, { encoding: 'utf-8', timeout: 10_000 });
+            data = execSync(`curl -sL "${nameOrUrl}/marketplace.json"`, { encoding: "utf-8", timeout: 10_000 });
             marketplaceName = new URL(nameOrUrl).hostname;
         }
         catch {
             return null;
         }
     }
-    else if (nameOrUrl.includes('/') && !nameOrUrl.startsWith('.')) {
+    else if (nameOrUrl.includes("/") && !nameOrUrl.startsWith(".")) {
         // GitHub repo (owner/repo format)
         try {
             const url = `https://raw.githubusercontent.com/${nameOrUrl}/main/marketplace.json`;
-            data = execSync(`curl -sL "${url}"`, { encoding: 'utf-8', timeout: 10_000 });
-            marketplaceName = nameOrUrl.replace('/', '-');
+            data = execSync(`curl -sL "${url}"`, { encoding: "utf-8", timeout: 10_000 });
+            marketplaceName = nameOrUrl.replace("/", "-");
         }
         catch {
             return null;
         }
     }
-    else if (existsSync(join(nameOrUrl, 'marketplace.json'))) {
+    else if (existsSync(join(nameOrUrl, "marketplace.json"))) {
         // Local path
-        data = readFileSync(join(nameOrUrl, 'marketplace.json'), 'utf-8');
+        data = readFileSync(join(nameOrUrl, "marketplace.json"), "utf-8");
         marketplaceName = basename(nameOrUrl);
     }
     else {
@@ -79,10 +79,10 @@ export function listMarketplaces() {
     if (!existsSync(MARKETPLACE_DIR))
         return [];
     return readdirSync(MARKETPLACE_DIR)
-        .filter(f => f.endsWith('.json'))
-        .map(f => {
+        .filter((f) => f.endsWith(".json"))
+        .map((f) => {
         try {
-            return JSON.parse(readFileSync(join(MARKETPLACE_DIR, f), 'utf-8'));
+            return JSON.parse(readFileSync(join(MARKETPLACE_DIR, f), "utf-8"));
         }
         catch {
             return null;
@@ -98,7 +98,7 @@ export function searchMarketplace(query) {
         for (const plugin of mp.plugins) {
             if (plugin.name.toLowerCase().includes(q) ||
                 plugin.description.toLowerCase().includes(q) ||
-                plugin.keywords?.some(k => k.toLowerCase().includes(q))) {
+                plugin.keywords?.some((k) => k.toLowerCase().includes(q))) {
                 results.push({ ...plugin, marketplace: mp.name });
             }
         }
@@ -111,11 +111,11 @@ export function installPlugin(pluginName, marketplaceName) {
     // Find the plugin in marketplaces
     const marketplaces = listMarketplaces();
     let entry = null;
-    let fromMarketplace = '';
+    let fromMarketplace = "";
     for (const mp of marketplaces) {
         if (marketplaceName && mp.name !== marketplaceName)
             continue;
-        const found = mp.plugins.find(p => p.name === pluginName);
+        const found = mp.plugins.find((p) => p.name === pluginName);
         if (found) {
             entry = found;
             fromMarketplace = mp.name;
@@ -129,24 +129,33 @@ export function installPlugin(pluginName, marketplaceName) {
     mkdirSync(cacheDir, { recursive: true });
     try {
         switch (entry.source.type) {
-            case 'github': {
+            case "github": {
                 // Clone the repo to cache
-                execSync(`git clone --depth 1 "https://github.com/${entry.source.repo}.git" "${cacheDir}"`, { stdio: 'pipe', timeout: 30_000 });
+                execSync(`git clone --depth 1 "https://github.com/${entry.source.repo}.git" "${cacheDir}"`, {
+                    stdio: "pipe",
+                    timeout: 30_000,
+                });
                 break;
             }
-            case 'npm': {
+            case "npm": {
                 // Install npm package to cache
-                execSync(`npm pack "${entry.source.package}" --pack-destination "${cacheDir}"`, { stdio: 'pipe', timeout: 30_000 });
+                execSync(`npm pack "${entry.source.package}" --pack-destination "${cacheDir}"`, {
+                    stdio: "pipe",
+                    timeout: 30_000,
+                });
                 // Extract the tarball
-                const tgz = readdirSync(cacheDir).find(f => f.endsWith('.tgz'));
+                const tgz = readdirSync(cacheDir).find((f) => f.endsWith(".tgz"));
                 if (tgz) {
-                    execSync(`tar xzf "${join(cacheDir, tgz)}" -C "${cacheDir}" --strip-components=1`, { stdio: 'pipe' });
+                    execSync(`tar xzf "${join(cacheDir, tgz)}" -C "${cacheDir}" --strip-components=1`, { stdio: "pipe" });
                 }
                 break;
             }
-            case 'url': {
-                execSync(`curl -sL "${entry.source.url}" -o "${join(cacheDir, 'plugin.tar.gz')}"`, { stdio: 'pipe', timeout: 30_000 });
-                execSync(`tar xzf "${join(cacheDir, 'plugin.tar.gz')}" -C "${cacheDir}"`, { stdio: 'pipe' });
+            case "url": {
+                execSync(`curl -sL "${entry.source.url}" -o "${join(cacheDir, "plugin.tar.gz")}"`, {
+                    stdio: "pipe",
+                    timeout: 30_000,
+                });
+                execSync(`tar xzf "${join(cacheDir, "plugin.tar.gz")}" -C "${cacheDir}"`, { stdio: "pipe" });
                 break;
             }
         }
@@ -156,7 +165,9 @@ export function installPlugin(pluginName, marketplaceName) {
         try {
             rmSync(cacheDir, { recursive: true });
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         return null;
     }
     // Record installation
@@ -173,16 +184,18 @@ export function installPlugin(pluginName, marketplaceName) {
 /** Uninstall a plugin */
 export function uninstallPlugin(name) {
     const installed = getInstalledPlugins();
-    const plugin = installed.find(p => p.name === name);
+    const plugin = installed.find((p) => p.name === name);
     if (!plugin)
         return false;
     // Remove from cache
     try {
         rmSync(plugin.cachePath, { recursive: true });
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     // Remove from installed list
-    const remaining = installed.filter(p => p.name !== name);
+    const remaining = installed.filter((p) => p.name !== name);
     saveInstalledPluginList(remaining);
     return true;
 }
@@ -191,7 +204,7 @@ export function getInstalledPlugins() {
     if (!existsSync(INSTALLED_PLUGINS_FILE))
         return [];
     try {
-        return JSON.parse(readFileSync(INSTALLED_PLUGINS_FILE, 'utf-8'));
+        return JSON.parse(readFileSync(INSTALLED_PLUGINS_FILE, "utf-8"));
     }
     catch {
         return [];
@@ -200,7 +213,7 @@ export function getInstalledPlugins() {
 function saveInstalledPlugin(plugin) {
     const installed = getInstalledPlugins();
     // Replace existing version
-    const idx = installed.findIndex(p => p.name === plugin.name);
+    const idx = installed.findIndex((p) => p.name === plugin.name);
     if (idx >= 0)
         installed[idx] = plugin;
     else
@@ -208,7 +221,7 @@ function saveInstalledPlugin(plugin) {
     saveInstalledPluginList(installed);
 }
 function saveInstalledPluginList(plugins) {
-    const dir = join(homedir(), '.oh', 'plugins');
+    const dir = join(homedir(), ".oh", "plugins");
     mkdirSync(dir, { recursive: true });
     writeFileSync(INSTALLED_PLUGINS_FILE, JSON.stringify(plugins, null, 2));
 }
@@ -216,27 +229,27 @@ function saveInstalledPluginList(plugins) {
 /** Format marketplace entries for display */
 export function formatMarketplaceSearch(results) {
     if (results.length === 0)
-        return 'No plugins found.';
+        return "No plugins found.";
     const lines = [`Found ${results.length} plugin(s):\n`];
     for (const r of results) {
         lines.push(`  ${r.name}@${r.version}  [${r.marketplace}]`);
         lines.push(`    ${r.description}`);
         if (r.author)
             lines.push(`    by ${r.author}`);
-        lines.push('');
+        lines.push("");
     }
-    lines.push('Install with: /plugin install <name>');
-    return lines.join('\n');
+    lines.push("Install with: /plugin install <name>");
+    return lines.join("\n");
 }
 /** Format installed plugins for display */
 export function formatInstalledPlugins(plugins) {
     if (plugins.length === 0)
-        return 'No plugins installed from marketplaces.';
+        return "No plugins installed from marketplaces.";
     const lines = [`Installed Plugins (${plugins.length}):\n`];
     for (const p of plugins) {
         const age = Math.round((Date.now() - p.installedAt) / (1000 * 60 * 60 * 24));
         lines.push(`  ${p.name}@${p.version}  [${p.marketplace}]  ${age}d ago`);
     }
-    return lines.join('\n');
+    return lines.join("\n");
 }
 //# sourceMappingURL=marketplace.js.map

package/dist/harness/memory.d.ts

@@ -7,11 +7,17 @@
  * The system detects learnable patterns from assistant responses and saves them
  * without user intervention.
  */
-import type { Message } from '../types/message.js';
-import type { Provider } from '../providers/base.js';
+import type { Provider } from "../providers/base.js";
+import type { Message } from "../types/message.js";
+/**
+ * Memory types — supports both legacy and Claude Code-compatible names.
+ * Legacy: convention, preference, project, debugging
+ * New:    user, feedback, project, reference
+ */
+export type MemoryType = "convention" | "preference" | "project" | "debugging" | "user" | "feedback" | "reference";
 export type MemoryEntry = {
     name: string;
-    type: 'convention' | 'preference' | 'project' | 'debugging';
+    type: MemoryType;
     description: string;
     content: string;
     filePath: string;
@@ -25,7 +31,13 @@ export declare function loadMemories(): MemoryEntry[];
 /** Build a system prompt section from loaded memories */
 export declare function memoriesToPrompt(memories: MemoryEntry[]): string;
 /** Save a memory entry to the project memory directory */
-export declare function saveMemory(name: string, type: MemoryEntry['type'], description: string, content: string, global?: boolean): string;
+export declare function saveMemory(name: string, type: MemoryType, description: string, content: string, global?: boolean): string;
+/**
+ * Update or create MEMORY.md index file in the given memory directory.
+ * The index is always loaded into context, providing instant awareness of all stored memories.
+ * Each entry is a one-liner pointer to the individual memory file (~200 line cap).
+ */
+export declare function updateMemoryIndex(dir?: string): void;
 /** Mark a memory as accessed — updates lastAccessed and accessCount in the file */
 export declare function touchMemory(entry: MemoryEntry): void;
 /** Boost a memory's relevance score (capped at 1.0) */
@@ -53,13 +65,19 @@ export type ConsolidationResult = {
  * persist updated relevance scores. Designed to run on session end.
  */
 export declare function consolidateMemories(): ConsolidationResult;
+/** Load the user profile from .oh/memory/USER.md */
+export declare function loadUserProfile(): string;
+/** Update the user profile, truncating to max chars */
+export declare function updateUserProfile(content: string): void;
+/** Format user profile for system prompt injection */
+export declare function userProfileToPrompt(): string;
 /**
  * Detect if recent assistant messages contain learnable patterns.
  * Returns structured memories to save, or empty array.
  */
 export declare function detectMemories(provider: Provider, recentMessages: Message[], model?: string): Promise<Array<{
     name: string;
-    type: MemoryEntry['type'];
+    type: MemoryEntry["type"];
     description: string;
     content: string;
 }>>;