@zhijiewang/openharness 2.8.0 → 2.10.0

package/dist/harness/marketplace.js

@@ -7,59 +7,196 @@
  * Inspired by Claude Code's marketplace model.
  */
 import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, 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");
+// Claude Code plugin manifest path relative to plugin root
+const CC_MANIFEST_PATH = join(".claude-plugin", "plugin.json");
+/** Parse a `.claude-plugin/plugin.json` file at the given plugin root, or null if missing/invalid. */
+export function parseCcPluginManifest(pluginRoot) {
+    const path = join(pluginRoot, CC_MANIFEST_PATH);
+    if (!existsSync(path))
+        return null;
+    try {
+        const m = JSON.parse(readFileSync(path, "utf-8"));
+        if (typeof m?.name !== "string" || typeof m?.description !== "string")
+            return null;
+        return m;
+    }
+    catch {
+        return null;
+    }
+}
+/** Convert a CcMarketplace to OH's internal Marketplace type (lossy: dropped fields like `owner` are not stored). */
+export function ccMarketplaceToOh(cc) {
+    const plugins = [];
+    for (const p of cc.plugins) {
+        const ohSource = ccSourceToOh(p.source);
+        if (!ohSource)
+            continue; // Skip relative-path sources — only resolvable inside the marketplace repo
+        plugins.push({
+            name: p.name,
+            description: p.description ?? "",
+            version: p.version ?? "0.0.0",
+            author: typeof p.author === "string" ? p.author : p.author?.name,
+            source: ohSource,
+        });
+    }
+    return { name: cc.name, version: 1, description: cc.description, plugins };
+}
+function ccSourceToOh(src) {
+    if (typeof src === "string")
+        return null; // relative paths require marketplace-repo context
+    if (src.source === "github")
+        return { type: "github", repo: src.repo };
+    if (src.source === "url")
+        return { type: "url", url: src.url };
+    if (src.source === "npm")
+        return { type: "npm", package: src.package };
+    return null;
+}
+/** Parse marketplace JSON text. Tries CC format (.claude-plugin/marketplace.json shape) first, falls back to OH-native. */
+export function parseMarketplaceJson(text) {
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (!raw || typeof raw !== "object")
+        return null;
+    const obj = raw;
+    if (!Array.isArray(obj.plugins))
+        return null;
+    // Detect CC format: any plugin entry has either a string `source` or `source.source` (kind tag)
+    const looksCc = obj.plugins.some((p) => {
+        if (!p || typeof p !== "object")
+            return false;
+        const s = p.source;
+        return typeof s === "string" || (s !== null && typeof s === "object" && "source" in s);
+    });
+    if (looksCc) {
+        return ccMarketplaceToOh(obj);
+    }
+    // OH-native format
+    return obj;
+}
+/** Discover plugin-shipped MCP servers from `cachePath/.mcp.json`. Returns raw object for the runtime to merge. */
+export function getPluginMcpServers(cachePath) {
+    const path = join(cachePath, ".mcp.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(path, "utf-8"));
+        // Claude Code shape: { "mcpServers": { name: { command, args, env, ... } } }
+        // Some plugins store the inner map directly. Accept both.
+        if (data && typeof data === "object") {
+            if ("mcpServers" in data && typeof data.mcpServers === "object")
+                return data.mcpServers;
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Discover plugin-shipped hooks from `cachePath/hooks/hooks.json`. Returns raw config for the runtime to register. */
+export function getPluginHooks(cachePath) {
+    const path = join(cachePath, "hooks", "hooks.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(path, "utf-8"));
+        if (data && typeof data === "object")
+            return data;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Discover plugin-shipped LSP servers from `cachePath/.lsp.json`. Returns raw config for the runtime to register. */
+export function getPluginLspServers(cachePath) {
+    const path = join(cachePath, ".lsp.json");
+    if (!existsSync(path))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(path, "utf-8"));
+        if (data && typeof data === "object") {
+            if ("lspServers" in data && typeof data.lspServers === "object")
+                return data.lspServers;
+            return data;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 // ── Marketplace Management ──
-/** Add a marketplace from a URL, GitHub repo, or local path */
+/** Add a marketplace from a URL, GitHub repo, or local path.
+ * Probes for both OH-native `marketplace.json` and Claude Code `.claude-plugin/marketplace.json`.
+ */
 export function addMarketplace(nameOrUrl) {
     mkdirSync(MARKETPLACE_DIR, { recursive: true });
-    // Fetch marketplace.json
-    let data;
+    // Candidate filenames to try, in priority order
+    const candidatePaths = ["marketplace.json", ".claude-plugin/marketplace.json"];
+    let data = null;
     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;
+        marketplaceName = new URL(nameOrUrl).hostname;
+        for (const fname of candidatePaths) {
+            try {
+                const text = execSync(`curl -sfL "${nameOrUrl}/${fname}"`, { encoding: "utf-8", timeout: 10_000 });
+                if (text.trim()) {
+                    data = text;
+                    break;
+                }
+            }
+            catch {
+                /* try next */
+            }
         }
     }
     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;
+        marketplaceName = nameOrUrl.replace("/", "-");
+        for (const fname of candidatePaths) {
+            try {
+                const url = `https://raw.githubusercontent.com/${nameOrUrl}/main/${fname}`;
+                const text = execSync(`curl -sfL "${url}"`, { encoding: "utf-8", timeout: 10_000 });
+                if (text.trim()) {
+                    data = text;
+                    break;
+                }
+            }
+            catch {
+                /* try next */
+            }
         }
     }
-    else if (existsSync(join(nameOrUrl, "marketplace.json"))) {
-        // Local path
-        data = readFileSync(join(nameOrUrl, "marketplace.json"), "utf-8");
+    else {
         marketplaceName = basename(nameOrUrl);
+        for (const fname of candidatePaths) {
+            const path = join(nameOrUrl, fname);
+            if (existsSync(path)) {
+                data = readFileSync(path, "utf-8");
+                break;
+            }
+        }
     }
-    else {
+    if (!data)
         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 {
+    const marketplace = parseMarketplaceJson(data);
+    if (!marketplace)
         return null;
-    }
+    marketplace.name = marketplace.name ?? marketplaceName;
+    writeFileSync(join(MARKETPLACE_DIR, `${marketplace.name}.json`), JSON.stringify(marketplace, null, 2));
+    return marketplace;
 }
 /** Remove a marketplace */
 export function removeMarketplace(name) {
@@ -199,17 +336,102 @@ export function uninstallPlugin(name) {
     saveInstalledPluginList(remaining);
     return true;
 }
-/** Get all installed plugins */
+/** Get all installed plugins.
+ * Sources merged in priority order:
+ * 1. installed.json (plugins installed via /plugin install or addMarketplace flow)
+ * 2. CC-style plugins discovered in PLUGIN_CACHE_DIR via .claude-plugin/plugin.json
+ *    (covers plugins manually dropped in the cache, or installed by parallel tooling)
+ * Plugins from #1 are enriched with manifest data if their cachePath has one.
+ * De-duplication is by cachePath.
+ */
 export function getInstalledPlugins() {
-    if (!existsSync(INSTALLED_PLUGINS_FILE))
-        return [];
+    const recorded = (() => {
+        if (!existsSync(INSTALLED_PLUGINS_FILE))
+            return [];
+        try {
+            return JSON.parse(readFileSync(INSTALLED_PLUGINS_FILE, "utf-8"));
+        }
+        catch {
+            return [];
+        }
+    })();
+    // Enrich recorded plugins from their CC manifest if present
+    const enriched = recorded.map((p) => mergeManifest(p, parseCcPluginManifest(p.cachePath)));
+    const seenPaths = new Set(enriched.map((p) => p.cachePath));
+    // Discover CC-style plugins in PLUGIN_CACHE_DIR not already recorded
+    const discovered = [];
+    if (existsSync(PLUGIN_CACHE_DIR)) {
+        try {
+            for (const nameEntry of readdirSync(PLUGIN_CACHE_DIR)) {
+                const nameDir = join(PLUGIN_CACHE_DIR, nameEntry);
+                if (!safeIsDirectory(nameDir))
+                    continue;
+                // Plugin can sit either at <name>/ or <name>/<version>/
+                const candidates = [nameDir, ...listSubdirs(nameDir)];
+                for (const root of candidates) {
+                    if (seenPaths.has(root))
+                        continue;
+                    const manifest = parseCcPluginManifest(root);
+                    if (!manifest)
+                        continue;
+                    discovered.push({
+                        name: manifest.name,
+                        version: manifest.version ?? "0.0.0",
+                        marketplace: "discovered",
+                        installedAt: tryStatTime(root),
+                        cachePath: root,
+                        ...projectManifestFields(manifest),
+                    });
+                    seenPaths.add(root);
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return [...enriched, ...discovered];
+}
+function safeIsDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function listSubdirs(dir) {
     try {
-        return JSON.parse(readFileSync(INSTALLED_PLUGINS_FILE, "utf-8"));
+        return readdirSync(dir)
+            .map((entry) => join(dir, entry))
+            .filter((p) => safeIsDirectory(p));
     }
     catch {
         return [];
     }
 }
+function tryStatTime(path) {
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return Date.now();
+    }
+}
+function projectManifestFields(m) {
+    return {
+        description: m.description,
+        author: typeof m.author === "string" ? m.author : m.author?.name,
+        license: m.license,
+        homepage: m.homepage,
+        keywords: m.keywords,
+    };
+}
+function mergeManifest(plugin, manifest) {
+    if (!manifest)
+        return plugin;
+    return { ...plugin, ...projectManifestFields(manifest) };
+}
 function saveInstalledPlugin(plugin) {
     const installed = getInstalledPlugins();
     // Replace existing version

package/dist/harness/memory.d.ts

@@ -31,6 +31,40 @@ export type MemoryEntry = {
 export declare function loadMemories(): MemoryEntry[];
 /** Build a system prompt section from loaded memories (capped at MEMORY_PROMPT_MAX_CHARS) */
 export declare function memoriesToPrompt(memories: MemoryEntry[]): string;
+/** A single CLAUDE.md source with its resolved content (imports inlined). */
+export type ClaudeMdEntry = {
+    path: string;
+    source: "project" | "project-local" | "user" | "claude-dir";
+    content: string;
+};
+/**
+ * Resolve `@path/to/file` imports inline. Relative paths resolve against
+ * `baseDir`. Absolute paths are read as-is. Each imported file can itself
+ * contain imports — recursion capped at `CLAUDE_MD_MAX_HOPS` to prevent
+ * cycles. Missing or unreadable imports are silently dropped.
+ *
+ * @internal exposed for testing
+ */
+export declare function resolveClaudeMdImports(content: string, baseDir: string, hopsLeft?: number): string;
+/**
+ * Load the hierarchical CLAUDE.md set in the order Anthropic documents:
+ *   1. `./.claude/CLAUDE.md` (project, checked in)
+ *   2. `./CLAUDE.md` (project, checked in)
+ *   3. `./CLAUDE.local.md` (project, gitignored)
+ *   4. `~/.claude/CLAUDE.md` (user-global)
+ *
+ * Each file is read, `@imports` are resolved, and the results are returned in
+ * load order. Missing files are skipped. The caller can format these into the
+ * system prompt alongside `memoriesToPrompt()` — the two systems are additive.
+ *
+ * @param root optional project root (defaults to cwd)
+ */
+export declare function loadClaudeMdHierarchy(root?: string): ClaudeMdEntry[];
+/**
+ * Render loaded CLAUDE.md entries as a system-prompt block. Empty when no
+ * CLAUDE.md files exist — caller should concatenate alongside `memoriesToPrompt`.
+ */
+export declare function claudeMdToPrompt(entries: ClaudeMdEntry[]): string;
 /** Save a memory entry to the project memory directory */
 export declare function saveMemory(name: string, type: MemoryType, description: string, content: string, global?: boolean): string;
 /**

package/dist/harness/memory.js

@@ -13,6 +13,10 @@ import { join, resolve, sep } from "node:path";
 import { createUserMessage } from "../types/message.js";
 const PROJECT_MEMORY_DIR = join(".oh", "memory");
 const GLOBAL_MEMORY_DIR = join(homedir(), ".oh", "memory");
+// Maximum number of @-import hops before giving up (prevents cycles).
+const CLAUDE_MD_MAX_HOPS = 5;
+// Cap per loaded CLAUDE.md source to keep the system prompt bounded.
+const CLAUDE_MD_PER_FILE_CAP = 20_000;
 // Version counter — incremented on every save, used by query loop for live injection
 let _memoryVersion = 0;
 export function memoryVersion() {
@@ -79,6 +83,98 @@ export function memoriesToPrompt(memories) {
     }
     return result.trimEnd();
 }
+/**
+ * Resolve `@path/to/file` imports inline. Relative paths resolve against
+ * `baseDir`. Absolute paths are read as-is. Each imported file can itself
+ * contain imports — recursion capped at `CLAUDE_MD_MAX_HOPS` to prevent
+ * cycles. Missing or unreadable imports are silently dropped.
+ *
+ * @internal exposed for testing
+ */
+export function resolveClaudeMdImports(content, baseDir, hopsLeft = CLAUDE_MD_MAX_HOPS) {
+    if (hopsLeft <= 0)
+        return content;
+    // Match `@path` on its own line or in a line-leading position. We avoid
+    // email addresses (`foo@bar.com`) by requiring whitespace/start-of-line
+    // before the `@` and a path-like token after.
+    const importRe = /(^|\s)@([^\s@]+)/g;
+    return content.replace(importRe, (match, leading, path) => {
+        // Skip obvious non-path tokens (e.g. `@user` mentions without slashes or extensions)
+        if (!path.includes("/") && !path.includes("."))
+            return match;
+        const resolved = path.startsWith("/") || path.startsWith("~") ? path.replace(/^~/, homedir()) : join(baseDir, path);
+        if (!existsSync(resolved))
+            return match;
+        try {
+            const raw = readFileSync(resolved, "utf-8");
+            const subDir = resolved.split(/[/\\]/).slice(0, -1).join("/");
+            const expanded = resolveClaudeMdImports(raw, subDir || baseDir, hopsLeft - 1);
+            return `${leading}<!-- imported from @${path} -->\n${expanded}\n<!-- end @${path} -->`;
+        }
+        catch {
+            return match;
+        }
+    });
+}
+/** Read a single CLAUDE.md candidate path if it exists. Returns null otherwise. */
+function readClaudeMdIfExists(path, source) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, "utf-8").slice(0, CLAUDE_MD_PER_FILE_CAP);
+        const baseDir = path.split(/[/\\]/).slice(0, -1).join("/") || ".";
+        return { path, source, content: resolveClaudeMdImports(raw, baseDir) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load the hierarchical CLAUDE.md set in the order Anthropic documents:
+ *   1. `./.claude/CLAUDE.md` (project, checked in)
+ *   2. `./CLAUDE.md` (project, checked in)
+ *   3. `./CLAUDE.local.md` (project, gitignored)
+ *   4. `~/.claude/CLAUDE.md` (user-global)
+ *
+ * Each file is read, `@imports` are resolved, and the results are returned in
+ * load order. Missing files are skipped. The caller can format these into the
+ * system prompt alongside `memoriesToPrompt()` — the two systems are additive.
+ *
+ * @param root optional project root (defaults to cwd)
+ */
+export function loadClaudeMdHierarchy(root = ".") {
+    const candidates = [
+        [join(root, ".claude", "CLAUDE.md"), "claude-dir"],
+        [join(root, "CLAUDE.md"), "project"],
+        [join(root, "CLAUDE.local.md"), "project-local"],
+        [join(homedir(), ".claude", "CLAUDE.md"), "user"],
+    ];
+    const entries = [];
+    const seen = new Set();
+    for (const [path, source] of candidates) {
+        if (seen.has(path))
+            continue;
+        seen.add(path);
+        const entry = readClaudeMdIfExists(path, source);
+        if (entry)
+            entries.push(entry);
+    }
+    return entries;
+}
+/**
+ * Render loaded CLAUDE.md entries as a system-prompt block. Empty when no
+ * CLAUDE.md files exist — caller should concatenate alongside `memoriesToPrompt`.
+ */
+export function claudeMdToPrompt(entries) {
+    if (entries.length === 0)
+        return "";
+    const parts = ["# Project instructions (CLAUDE.md)"];
+    for (const e of entries) {
+        parts.push(`<!-- source: ${e.source} (${e.path}) -->`);
+        parts.push(e.content.trim());
+    }
+    return parts.join("\n\n").trimEnd();
+}
 /** Save a memory entry to the project memory directory */
 export function saveMemory(name, type, description, content, global = false) {
     const dir = global ? GLOBAL_MEMORY_DIR : PROJECT_MEMORY_DIR;

package/dist/harness/plugins.d.ts

@@ -16,9 +16,19 @@ export type SkillMetadata = {
     trigger: string | undefined;
     tools: string[] | undefined;
     args: string[] | undefined;
+    /** Optional natural-language hint for when this skill applies; concatenated to description for trigger matching */
+    whenToUse: string | undefined;
+    /** SPDX license identifier (e.g. "MIT", "Apache-2.0", "CC-BY-SA-4.0"). Used by install gate. */
+    license: string | undefined;
+    /** Glob patterns scoping skill auto-surfacing to specific file paths */
+    paths: string[] | undefined;
+    /** Execution context: "default" runs in the current agent, "fork" spawns a sub-agent (Anthropic extension) */
+    context: "default" | "fork" | undefined;
+    /** When `context: fork`, the sub-agent type to spawn (must match an AgentRole id) */
+    agent: string | undefined;
     content: string;
     filePath: string;
-    source: "project" | "global" | "plugin";
+    source: "bundled" | "project" | "global" | "plugin";
     /** When false, skill is hidden from system prompt until explicitly invoked */
     invokeModel: boolean;
 };
@@ -44,11 +54,11 @@ export type AgentTeamConfig = {
         tools?: string[];
     }>;
 };
-/** Discover all available skills from project + global dirs + installed plugins */
+/** Discover all available skills from bundled + 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;
-/** Find skills that match a trigger condition */
+/** Find skills that match a trigger condition (substring match against `trigger` field). */
 export declare function findTriggeredSkills(userMessage: string): SkillMetadata[];
 /** Find a skill similar to a candidate (for patch-vs-create decision) */
 export declare function findSimilarSkill(candidateName: string, candidateDescription: string, skills: Array<{