@zhijiewang/openharness 1.2.0 → 1.4.0

package/dist/harness/marketplace.js

@@ -0,0 +1,242 @@
+/**
+ * Plugin Marketplace — discover, install, and manage plugins from curated registries.
+ *
+ * Marketplaces are JSON files listing available plugins with versions and sources.
+ * Plugins are downloaded and cached to ~/.oh/plugins/cache/ for security and versioning.
+ *
+ * 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');
+// ── Marketplace Management ──
+/** Add a marketplace from a URL, GitHub repo, or local path */
+export function addMarketplace(nameOrUrl) {
+    mkdirSync(MARKETPLACE_DIR, { recursive: true });
+    // Fetch marketplace.json
+    let data;
+    let marketplaceName;
+    if (nameOrUrl.startsWith('http')) {
+        // URL
+        try {
+            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('.')) {
+        // 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('/', '-');
+        }
+        catch {
+            return null;
+        }
+    }
+    else if (existsSync(join(nameOrUrl, 'marketplace.json'))) {
+        // Local path
+        data = readFileSync(join(nameOrUrl, 'marketplace.json'), 'utf-8');
+        marketplaceName = basename(nameOrUrl);
+    }
+    else {
+        return null;
+    }
+    try {
+        const marketplace = JSON.parse(data);
+        if (!marketplace.plugins || !Array.isArray(marketplace.plugins))
+            return null;
+        marketplace.name = marketplace.name ?? marketplaceName;
+        writeFileSync(join(MARKETPLACE_DIR, `${marketplace.name}.json`), JSON.stringify(marketplace, null, 2));
+        return marketplace;
+    }
+    catch {
+        return null;
+    }
+}
+/** Remove a marketplace */
+export function removeMarketplace(name) {
+    const path = join(MARKETPLACE_DIR, `${name}.json`);
+    if (!existsSync(path))
+        return false;
+    try {
+        rmSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** List all configured marketplaces */
+export function listMarketplaces() {
+    if (!existsSync(MARKETPLACE_DIR))
+        return [];
+    return readdirSync(MARKETPLACE_DIR)
+        .filter(f => f.endsWith('.json'))
+        .map(f => {
+        try {
+            return JSON.parse(readFileSync(join(MARKETPLACE_DIR, f), 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((m) => m !== null);
+}
+/** Search all marketplaces for plugins matching a query */
+export function searchMarketplace(query) {
+    const q = query.toLowerCase();
+    const results = [];
+    for (const mp of listMarketplaces()) {
+        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))) {
+                results.push({ ...plugin, marketplace: mp.name });
+            }
+        }
+    }
+    return results;
+}
+// ── Plugin Installation ──
+/** Install a plugin from a marketplace */
+export function installPlugin(pluginName, marketplaceName) {
+    // Find the plugin in marketplaces
+    const marketplaces = listMarketplaces();
+    let entry = null;
+    let fromMarketplace = '';
+    for (const mp of marketplaces) {
+        if (marketplaceName && mp.name !== marketplaceName)
+            continue;
+        const found = mp.plugins.find(p => p.name === pluginName);
+        if (found) {
+            entry = found;
+            fromMarketplace = mp.name;
+            break;
+        }
+    }
+    if (!entry)
+        return null;
+    // Download to cache
+    const cacheDir = join(PLUGIN_CACHE_DIR, entry.name, entry.version);
+    mkdirSync(cacheDir, { recursive: true });
+    try {
+        switch (entry.source.type) {
+            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 });
+                break;
+            }
+            case 'npm': {
+                // Install npm package to cache
+                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'));
+                if (tgz) {
+                    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' });
+                break;
+            }
+        }
+    }
+    catch {
+        // Clean up failed install
+        try {
+            rmSync(cacheDir, { recursive: true });
+        }
+        catch { /* ignore */ }
+        return null;
+    }
+    // Record installation
+    const installed = {
+        name: entry.name,
+        version: entry.version,
+        marketplace: fromMarketplace,
+        installedAt: Date.now(),
+        cachePath: cacheDir,
+    };
+    saveInstalledPlugin(installed);
+    return installed;
+}
+/** Uninstall a plugin */
+export function uninstallPlugin(name) {
+    const installed = getInstalledPlugins();
+    const plugin = installed.find(p => p.name === name);
+    if (!plugin)
+        return false;
+    // Remove from cache
+    try {
+        rmSync(plugin.cachePath, { recursive: true });
+    }
+    catch { /* ignore */ }
+    // Remove from installed list
+    const remaining = installed.filter(p => p.name !== name);
+    saveInstalledPluginList(remaining);
+    return true;
+}
+/** Get all installed plugins */
+export function getInstalledPlugins() {
+    if (!existsSync(INSTALLED_PLUGINS_FILE))
+        return [];
+    try {
+        return JSON.parse(readFileSync(INSTALLED_PLUGINS_FILE, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+function saveInstalledPlugin(plugin) {
+    const installed = getInstalledPlugins();
+    // Replace existing version
+    const idx = installed.findIndex(p => p.name === plugin.name);
+    if (idx >= 0)
+        installed[idx] = plugin;
+    else
+        installed.push(plugin);
+    saveInstalledPluginList(installed);
+}
+function saveInstalledPluginList(plugins) {
+    const dir = join(homedir(), '.oh', 'plugins');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(INSTALLED_PLUGINS_FILE, JSON.stringify(plugins, null, 2));
+}
+// ── Formatting ──
+/** Format marketplace entries for display */
+export function formatMarketplaceSearch(results) {
+    if (results.length === 0)
+        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('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.';
+    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');
+}
+//# sourceMappingURL=marketplace.js.map

package/dist/harness/plugins.d.ts

@@ -42,7 +42,7 @@ export type AgentTeamConfig = {
         tools?: string[];
     }>;
 };
-/** Discover all available skills from project + global dirs */
+/** Discover all available skills from project + global dirs + installed plugins */
 export declare function discoverSkills(): SkillMetadata[];
 /** Find a skill by name (case-insensitive) */
 export declare function findSkill(name: string): SkillMetadata | null;

package/dist/harness/plugins.js

@@ -67,11 +67,25 @@ function loadSkillsFromDir(dir, source) {
     })
         .filter((s) => s !== null);
 }
-/** Discover all available skills from project + global dirs */
+/** Discover all available skills from project + global dirs + installed plugins */
 export function discoverSkills() {
     const skills = [];
     skills.push(...loadSkillsFromDir(PROJECT_SKILLS_DIR, 'project'));
     skills.push(...loadSkillsFromDir(GLOBAL_SKILLS_DIR, 'global'));
+    // Load skills from installed marketplace plugins (namespaced as plugin-name:skill-name)
+    try {
+        const { getInstalledPlugins } = require('./marketplace.js');
+        for (const plugin of getInstalledPlugins()) {
+            const pluginSkillsDir = join(plugin.cachePath, 'skills');
+            const pluginSkills = loadSkillsFromDir(pluginSkillsDir, 'plugin');
+            // Namespace: prefix skill name with plugin name
+            for (const skill of pluginSkills) {
+                skill.name = `${plugin.name}:${skill.name}`;
+            }
+            skills.push(...pluginSkills);
+        }
+    }
+    catch { /* marketplace module may not be loaded yet */ }
     return skills;
 }
 /** Find a skill by name (case-insensitive) */

package/dist/harness/rules.js

@@ -65,13 +65,28 @@ export function loadRules(projectPath) {
         if (content)
             rules.push(content);
     }
-    // 4. Project rules/*.md
+    // 4. Project rules/*.md (with optional path-scoped filtering)
     const rulesDir = join(root, ".oh", "rules");
     if (existsSync(rulesDir)) {
         for (const file of readdirSync(rulesDir).filter((f) => f.endsWith(".md")).sort()) {
-            const content = readSafe(join(rulesDir, file));
-            if (content)
-                rules.push(content);
+            const raw = readSafe(join(rulesDir, file));
+            if (!raw)
+                continue;
+            // Check for paths frontmatter: only include if matching current context
+            const pathsMatch = raw.match(/^---\n[\s\S]*?^paths:\s*(.+)$/m);
+            if (pathsMatch) {
+                // Path-scoped rule — strip frontmatter and only include if glob matches
+                const pattern = pathsMatch[1].trim();
+                const fmEnd = raw.indexOf('---', raw.indexOf('---') + 3);
+                const content = fmEnd > 0 ? raw.slice(fmEnd + 3).trim() : raw;
+                if (content && matchesPathGlob(root, pattern)) {
+                    rules.push(content);
+                }
+            }
+            else {
+                // No paths restriction — always include
+                rules.push(raw);
+            }
         }
     }
     // 5. CLAUDE.local.md (personal overrides, typically gitignored)
@@ -110,4 +125,17 @@ function readSafe(path) {
         return "";
     }
 }
+/**
+ * Check if any file in the project matches a glob pattern.
+ * Simple implementation: checks if the pattern directory exists.
+ * For `src/api/**`, checks if `src/api/` exists.
+ */
+function matchesPathGlob(root, pattern) {
+    // Extract the directory portion before any wildcard
+    const dirPart = pattern.split('*')[0].replace(/\/+$/, '');
+    if (!dirPart)
+        return true; // Pattern like "**/*.ts" matches everything
+    const fullDir = join(root, dirPart);
+    return existsSync(fullDir);
+}
 //# sourceMappingURL=rules.js.map

package/dist/harness/submit-handler.js

@@ -69,14 +69,30 @@ export async function handleUserInput(input, ctx) {
     }
     // Normal prompt — add user message
     messages = [...messages, createUserMessage(input)];
-    // Resolve @mentions
+    // Resolve @mentions — local files first, then MCP resources
     let resolvedInput = input;
-    const mentionPattern = /@(\w[\w.-]*)/g;
+    const mentionPattern = /@([\w][\w./-]*)/g;
     const mentions = [...input.matchAll(mentionPattern)].map(m => m[1]);
     const companionName = ctx.companionConfig?.soul?.name?.toLowerCase();
     for (const mention of mentions) {
         if (companionName && mention.toLowerCase() === companionName)
             continue;
+        // Try local file first (supports paths like @src/main.ts, @README.md)
+        try {
+            const { existsSync, readFileSync } = await import('node:fs');
+            const { resolve } = await import('node:path');
+            const filePath = resolve(process.cwd(), mention);
+            if (existsSync(filePath)) {
+                const content = readFileSync(filePath, 'utf-8');
+                const truncated = content.length > 10_000
+                    ? content.slice(0, 10_000) + '\n[...truncated]'
+                    : content;
+                resolvedInput += `\n\n[File @${mention}]:\n${truncated}`;
+                continue;
+            }
+        }
+        catch { /* ignore */ }
+        // Fall back to MCP resource
         try {
             const content = await resolveMcpMention(mention);
             if (content)

package/dist/main.js

@@ -233,6 +233,7 @@ program
     .option("--fork <id>", "Fork (branch) from an existing session")
     .option("--light", "Use light theme")
     .option("--output-format <format>", "Output format for -p mode (text, json, stream-json)", "text")
+    .option("--json-schema <schema>", "Constrain output to match a JSON schema (headless mode)")
     .action(async (opts) => {
     // Load saved config as defaults (env vars + CLI flags override)
     const savedConfig = readOhConfig();

package/dist/query/compress.js

@@ -4,6 +4,7 @@
  */
 import { createUserMessage } from "../types/message.js";
 import { defaultEstimateTokens } from "../providers/base.js";
+import { emitHook } from "../harness/hooks.js";
 const DEFAULT_KEEP_LAST = 10;
 /**
  * Semantic importance scoring for messages.
@@ -61,6 +62,7 @@ export function estimateMessagesTokens(messages, estimateTokens = (t) => Math.ce
 export function compressMessages(messages, targetTokens) {
     if (messages.length <= 2)
         return messages;
+    emitHook("preCompact", {});
     const result = [...messages];
     const keepLast = DEFAULT_KEEP_LAST;
     // MicroCompact: Truncate long tool results and assistant messages
@@ -114,12 +116,14 @@ export function compressMessages(messages, targetTokens) {
                 validCallIds.add(tc.id);
         }
     }
-    return result.filter((msg) => {
+    const filtered = result.filter((msg) => {
         if (msg.role !== "tool")
             return true;
         return (msg.toolResults?.length ?? 0) > 0 &&
             msg.toolResults.every((tr) => validCallIds.has(tr.callId));
     });
+    emitHook("postCompact", {});
+    return filtered;
 }
 /**
  * LLM-assisted summarization of older messages.

package/dist/query/tools.js

@@ -85,6 +85,13 @@ export async function executeSingleTool(toolCall, tools, context, permissionMode
             toolArgs: JSON.stringify(toolCall.arguments).slice(0, 1000),
             toolOutput: result.output.slice(0, 1000),
         });
+        // Emit fileChanged hook for file-modifying tools
+        if (!result.isError && ['Edit', 'Write', 'MultiEdit'].includes(tool.name)) {
+            const filePaths = getAffectedFiles(tool.name, parsed.data);
+            for (const fp of filePaths) {
+                emitHook("fileChanged", { filePath: fp, toolName: tool.name });
+            }
+        }
         // Verification loop: auto-run lint/typecheck after file-modifying tools
         let verificationSuffix = '';
         if (!result.isError && ['Edit', 'Write', 'MultiEdit'].includes(tool.name)) {

package/dist/tools/AgentTool/index.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { createWorktree, removeWorktree, hasWorktreeChanges, isGitRepo } from "../../git/index.js";
+import { emitHook } from "../../harness/hooks.js";
 const inputSchema = z.object({
     prompt: z.string(),
     description: z.string().optional(),
@@ -80,9 +81,11 @@ export const AgentTool = {
             maxTurns: 20,
             abortSignal: context.abortSignal,
         };
+        const agentId = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+        emitHook("subagentStart", { agentId, toolName: input.subagent_type ?? 'general' });
         // Background execution: start agent and return immediately
         if (input.run_in_background) {
-            const bgId = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+            const bgId = agentId;
             const runAgent = async () => {
                 let finalText = "";
                 const originalCwd = process.cwd();
@@ -190,6 +193,7 @@ export const AgentTool = {
                 }
             }
         }
+        emitHook("subagentStop", { agentId });
         return { output: finalText || "(sub-agent completed with no text output)", isError: false };
     },
     prompt() {

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

@@ -2,17 +2,17 @@ import { z } from "zod";
 import type { Tool } from "../../Tool.js";
 declare const inputSchema: z.ZodObject<{
     file_path: z.ZodString;
-    action: z.ZodDefault<z.ZodEnum<["diagnostics", "definition", "references"]>>;
+    action: z.ZodDefault<z.ZodEnum<["diagnostics", "definition", "references", "hover"]>>;
     line: z.ZodOptional<z.ZodNumber>;
     character: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    action: "diagnostics" | "definition" | "references";
     file_path: string;
+    action: "diagnostics" | "definition" | "references" | "hover";
     line?: number | undefined;
     character?: number | undefined;
 }, {
     file_path: string;
-    action?: "diagnostics" | "definition" | "references" | undefined;
+    action?: "diagnostics" | "definition" | "references" | "hover" | undefined;
     line?: number | undefined;
     character?: number | undefined;
 }>;

package/dist/tools/DiagnosticsTool/index.js

@@ -2,8 +2,8 @@ import { z } from "zod";
 import { LspClient } from "../../lsp/client.js";
 const inputSchema = z.object({
     file_path: z.string().describe("Absolute path to the file to check"),
-    action: z.enum(["diagnostics", "definition", "references"]).default("diagnostics")
-        .describe("Action: diagnostics (errors/warnings), definition (go-to-def), references (find-refs)"),
+    action: z.enum(["diagnostics", "definition", "references", "hover"]).default("diagnostics")
+        .describe("Action: diagnostics (errors/warnings), definition (go-to-def), references (find-refs), hover (type info)"),
     line: z.number().optional().describe("Line number (0-indexed) for definition/references"),
     character: z.number().optional().describe("Column number (0-indexed) for definition/references"),
 });
@@ -16,6 +16,12 @@ function getLspCommand(filePath) {
     if (filePath.endsWith('.py')) {
         return { command: 'pylsp', args: [] };
     }
+    if (filePath.endsWith('.go')) {
+        return { command: 'gopls', args: ['serve'] };
+    }
+    if (filePath.endsWith('.rs')) {
+        return { command: 'rust-analyzer', args: [] };
+    }
     return null;
 }
 async function getClient(filePath, workingDir) {
@@ -84,6 +90,28 @@ export const DiagnosticsTool = {
                 const lines = refs.map(r => `${r.uri.replace('file://', '')}:${r.range.start.line + 1}:${r.range.start.character}`);
                 return { output: `${refs.length} reference(s):\n${lines.join('\n')}`, isError: false };
             }
+            if (input.action === "hover") {
+                if (input.line === undefined || input.character === undefined) {
+                    return { output: "line and character are required for hover.", isError: true };
+                }
+                await client.openFile(input.file_path);
+                // Hover uses textDocument/hover which returns MarkupContent
+                try {
+                    const result = await client.send('textDocument/hover', {
+                        textDocument: { uri: `file://${input.file_path.replace(/\\/g, '/')}` },
+                        position: { line: input.line, character: input.character },
+                    });
+                    if (!result || !result.contents)
+                        return { output: "No hover information.", isError: false };
+                    const content = typeof result.contents === 'string'
+                        ? result.contents
+                        : result.contents.value ?? JSON.stringify(result.contents);
+                    return { output: content, isError: false };
+                }
+                catch {
+                    return { output: "Hover not supported by this language server.", isError: false };
+                }
+            }
             return { output: `Unknown action: ${input.action}`, isError: true };
         }
         catch (err) {
@@ -94,15 +122,16 @@ export const DiagnosticsTool = {
         }
     },
     prompt() {
-        return `Get code intelligence from the language server. Actions:
+        return `Get code intelligence from the language server. Supports TypeScript, JavaScript, Python, Go, and Rust. Actions:
 - diagnostics: Get errors and warnings for a file
-- definition: Go to definition of a symbol at a given position (requires line, character)
-- references: Find all references to a symbol at a given position (requires line, character)
+- definition: Go to definition of a symbol at a given position
+- references: Find all references to a symbol at a given position
+- hover: Get type information and documentation for a symbol
 Parameters:
 - file_path (string, required): Absolute path to the file
-- action (string): "diagnostics" | "definition" | "references" (default: diagnostics)
-- line (number, optional): 0-indexed line for definition/references
-- character (number, optional): 0-indexed column for definition/references`;
+- action (string): "diagnostics" | "definition" | "references" | "hover" (default: diagnostics)
+- line (number, optional): 0-indexed line for definition/references/hover
+- character (number, optional): 0-indexed column for definition/references/hover`;
     },
 };
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const inputSchema: z.ZodObject<{
+    command: z.ZodString;
+    pattern: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    maxLines: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    pattern?: string | undefined;
+    timeout?: number | undefined;
+    maxLines?: number | undefined;
+}, {
+    command: string;
+    pattern?: string | undefined;
+    timeout?: number | undefined;
+    maxLines?: number | undefined;
+}>;
+export declare const MonitorTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map