@zhijiewang/openharness 2.0.0 → 2.3.0

package/dist/harness/memory.js

@@ -7,27 +7,29 @@
  * The system detects learnable patterns from assistant responses and saves them
  * without user intervention.
  */
-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');
-const GLOBAL_MEMORY_DIR = join(homedir(), '.oh', 'memory');
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+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");
 /** Load all memories from project and global dirs */
 export function loadMemories() {
     const entries = [];
     for (const dir of [PROJECT_MEMORY_DIR, GLOBAL_MEMORY_DIR]) {
         if (!existsSync(dir))
             continue;
-        for (const file of readdirSync(dir).filter(f => f.endsWith('.md'))) {
+        for (const file of readdirSync(dir).filter((f) => f.endsWith(".md"))) {
             try {
                 const filePath = join(dir, file);
-                const raw = readFileSync(filePath, 'utf-8');
+                const raw = readFileSync(filePath, "utf-8");
                 const entry = parseMemory(raw, filePath);
                 if (entry)
                     entries.push(entry);
             }
-            catch { /* skip */ }
+            catch {
+                /* skip */
+            }
         }
     }
     return entries;
@@ -40,36 +42,39 @@ function parseMemory(raw, filePath) {
     if (!nameMatch)
         return null;
     // Content is everything after the frontmatter closing ---
-    const fmEnd = raw.indexOf('---', raw.indexOf('---') + 3);
-    const content = fmEnd > 0 ? raw.slice(fmEnd + 3).trim() : '';
+    const fmEnd = raw.indexOf("---", raw.indexOf("---") + 3);
+    const content = fmEnd > 0 ? raw.slice(fmEnd + 3).trim() : "";
     const relevanceMatch = raw.match(/^relevance:\s*([0-9.]+)$/m);
     const lastAccessedMatch = raw.match(/^lastAccessed:\s*(\d+)$/m);
     const createdAtMatch = raw.match(/^createdAt:\s*(\d+)$/m);
     const accessCountMatch = raw.match(/^accessCount:\s*(\d+)$/m);
     return {
         name: nameMatch[1].trim(),
-        type: (typeMatch?.[1]?.trim() ?? 'convention'),
-        description: descMatch?.[1]?.trim() ?? '',
+        type: (typeMatch?.[1]?.trim() ?? "user"),
+        description: descMatch?.[1]?.trim() ?? "",
         content,
         filePath,
         relevance: relevanceMatch ? parseFloat(relevanceMatch[1]) : 0.5,
-        lastAccessed: lastAccessedMatch ? parseInt(lastAccessedMatch[1]) : undefined,
-        createdAt: createdAtMatch ? parseInt(createdAtMatch[1]) : undefined,
-        accessCount: accessCountMatch ? parseInt(accessCountMatch[1]) : 0,
+        lastAccessed: lastAccessedMatch ? parseInt(lastAccessedMatch[1], 10) : undefined,
+        createdAt: createdAtMatch ? parseInt(createdAtMatch[1], 10) : undefined,
+        accessCount: accessCountMatch ? parseInt(accessCountMatch[1], 10) : 0,
     };
 }
 /** Build a system prompt section from loaded memories */
 export function memoriesToPrompt(memories) {
     if (memories.length === 0)
-        return '';
-    const lines = memories.map(m => `- **${m.name}** (${m.type}): ${m.content.slice(0, 200)}`);
-    return `# Remembered Context\n${lines.join('\n')}`;
+        return "";
+    const lines = memories.map((m) => `- **${m.name}** (${m.type}): ${m.content.slice(0, 200)}`);
+    return `# Remembered Context\n${lines.join("\n")}`;
 }
 /** 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;
     mkdirSync(dir, { recursive: true });
-    const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 50);
+    const slug = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .slice(0, 50);
     const filePath = join(dir, `${slug}.md`);
     const now = Date.now();
     const md = `---
@@ -85,45 +90,95 @@ accessCount: 0
 ${content}
 `;
     writeFileSync(filePath, md);
+    updateMemoryIndex(dir);
     return filePath;
 }
+/**
+ * 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 function updateMemoryIndex(dir = PROJECT_MEMORY_DIR) {
+    if (!existsSync(dir))
+        return;
+    const files = readdirSync(dir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+    const entries = [];
+    for (const file of files) {
+        try {
+            const raw = readFileSync(join(dir, file), "utf-8");
+            const nameMatch = raw.match(/^name:\s*(.+)$/m);
+            const descMatch = raw.match(/^description:\s*(.+)$/m);
+            if (nameMatch) {
+                entries.push({
+                    name: nameMatch[1].trim(),
+                    file,
+                    description: descMatch?.[1]?.trim() ?? "",
+                });
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+    const lines = ["# Memory Index", ""];
+    for (const e of entries) {
+        // Keep each line under ~150 chars for readability
+        const hook = e.description.length > 100 ? `${e.description.slice(0, 97)}...` : e.description;
+        lines.push(`- [${e.name}](${e.file}) — ${hook}`);
+    }
+    lines.push("");
+    writeFileSync(join(dir, "MEMORY.md"), lines.join("\n"));
+}
 /** Mark a memory as accessed — updates lastAccessed and accessCount in the file */
 export function touchMemory(entry) {
     try {
-        let raw = readFileSync(entry.filePath, 'utf-8');
+        let raw = readFileSync(entry.filePath, "utf-8");
         const now = Date.now();
         const newCount = (entry.accessCount ?? 0) + 1;
-        // Update or insert metadata fields in frontmatter
+        // Update existing fields in frontmatter, or insert before closing ---
         if (raw.match(/^lastAccessed:/m)) {
             raw = raw.replace(/^lastAccessed:\s*\d+$/m, `lastAccessed: ${now}`);
         }
         else {
-            raw = raw.replace(/^---\s*$/m, `lastAccessed: ${now}\n---`);
+            // Insert before the CLOSING --- (second occurrence)
+            const firstIdx = raw.indexOf("---");
+            const closingIdx = raw.indexOf("---", firstIdx + 3);
+            if (closingIdx > 0) {
+                raw = `${raw.slice(0, closingIdx)}lastAccessed: ${now}\n${raw.slice(closingIdx)}`;
+            }
         }
         if (raw.match(/^accessCount:/m)) {
             raw = raw.replace(/^accessCount:\s*\d+$/m, `accessCount: ${newCount}`);
         }
         else {
-            raw = raw.replace(/^---\s*$/m, `accessCount: ${newCount}\n---`);
+            const firstIdx = raw.indexOf("---");
+            const closingIdx = raw.indexOf("---", firstIdx + 3);
+            if (closingIdx > 0) {
+                raw = `${raw.slice(0, closingIdx)}accessCount: ${newCount}\n${raw.slice(closingIdx)}`;
+            }
         }
         writeFileSync(entry.filePath, raw);
         entry.lastAccessed = now;
         entry.accessCount = newCount;
     }
-    catch { /* ignore write errors */ }
+    catch {
+        /* ignore write errors */
+    }
 }
 /** Boost a memory's relevance score (capped at 1.0) */
 export function boostRelevance(entry, amount = 0.1) {
     const newRelevance = Math.min(1.0, (entry.relevance ?? 0.5) + amount);
     try {
-        let raw = readFileSync(entry.filePath, 'utf-8');
+        let raw = readFileSync(entry.filePath, "utf-8");
         if (raw.match(/^relevance:/m)) {
             raw = raw.replace(/^relevance:\s*[0-9.]+$/m, `relevance: ${newRelevance.toFixed(2)}`);
         }
         writeFileSync(entry.filePath, raw);
         entry.relevance = newRelevance;
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
 }
 /**
  * Apply temporal decay to memory relevance.
@@ -164,30 +219,34 @@ export function loadActiveMemories() {
 /** 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));
+    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)))
+        if (!allowedDirs.some((d) => resolved.startsWith(d + sep)))
             continue;
         try {
             unlinkSync(m.filePath);
             count++;
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     return count;
 }
 /** Write back decayed relevance score to file frontmatter */
 function persistDecayedRelevance(entry) {
     try {
-        let raw = readFileSync(entry.filePath, 'utf-8');
+        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 */ }
+    catch {
+        /* ignore */
+    }
 }
 /**
  * Run full memory consolidation: apply decay, delete pruned files,
@@ -208,8 +267,54 @@ export function consolidateMemories() {
             decayedCount++;
         }
     }
+    // Refresh MEMORY.md index after pruning
+    updateMemoryIndex(PROJECT_MEMORY_DIR);
+    updateMemoryIndex(GLOBAL_MEMORY_DIR);
     return { total: all.length, pruned: prunedCount, decayed: decayedCount };
 }
+// ── User Profile ──
+const USER_PROFILE_FILE = "USER.md";
+const USER_PROFILE_MAX_CHARS = 2000;
+/** Load the user profile from .oh/memory/USER.md */
+export function loadUserProfile() {
+    const filePath = join(PROJECT_MEMORY_DIR, USER_PROFILE_FILE);
+    if (!existsSync(filePath))
+        return "";
+    try {
+        const raw = readFileSync(filePath, "utf-8");
+        const fmEnd = raw.indexOf("---", raw.indexOf("---") + 3);
+        return fmEnd > 0 ? raw.slice(fmEnd + 3).trim() : raw.trim();
+    }
+    catch {
+        return "";
+    }
+}
+/** Update the user profile, truncating to max chars */
+export function updateUserProfile(content) {
+    mkdirSync(PROJECT_MEMORY_DIR, { recursive: true });
+    // Truncate at last newline before max chars to avoid cutting mid-sentence
+    let truncated = content;
+    if (truncated.length > USER_PROFILE_MAX_CHARS) {
+        const lastNewline = content.lastIndexOf("\n", USER_PROFILE_MAX_CHARS);
+        truncated = lastNewline > 0 ? content.slice(0, lastNewline) : content.slice(0, USER_PROFILE_MAX_CHARS);
+    }
+    const md = `---
+name: User Profile
+type: user_profile
+updatedAt: ${Date.now()}
+---
+
+${truncated}
+`;
+    writeFileSync(join(PROJECT_MEMORY_DIR, USER_PROFILE_FILE), md);
+}
+/** Format user profile for system prompt injection */
+export function userProfileToPrompt() {
+    const profile = loadUserProfile();
+    if (!profile)
+        return "";
+    return `# User Profile\n${profile}`;
+}
 /**
  * Detect if recent assistant messages contain learnable patterns.
  * Returns structured memories to save, or empty array.
@@ -219,30 +324,26 @@ export async function detectMemories(provider, recentMessages, model) {
     if (recentMessages.length < 4)
         return [];
     // Extract assistant messages from recent turns
-    const assistantMsgs = recentMessages
-        .filter(m => m.role === 'assistant' && m.content.length > 50)
-        .slice(-3);
+    const assistantMsgs = recentMessages.filter((m) => m.role === "assistant" && m.content.length > 50).slice(-3);
     if (assistantMsgs.length === 0)
         return [];
-    const contextText = assistantMsgs
-        .map(m => m.content.slice(0, 500))
-        .join('\n---\n');
+    const contextText = assistantMsgs.map((m) => m.content.slice(0, 500)).join("\n---\n");
     const prompt = `Analyze this conversation snippet. If there are reusable learnings (coding conventions, project patterns, user preferences, debugging insights), extract them. Respond ONLY with a JSON array of objects with {name, type, description, content} or [] if nothing worth remembering.
 
-Types: "convention" (code style/patterns), "preference" (user likes/dislikes), "project" (architecture/decisions), "debugging" (solutions to problems)
+Types: "user" (role/preferences), "feedback" (corrections/confirmations), "project" (goals/decisions), "reference" (external pointers)
 
 Keep each memory concise (1-2 sentences). Only extract non-obvious learnings.
 
 ${contextText}`;
     try {
-        const response = await provider.complete([createUserMessage(prompt)], 'You are a memory extraction system. Respond ONLY with valid JSON.', undefined, model);
+        const response = await provider.complete([createUserMessage(prompt)], "You are a memory extraction system. Respond ONLY with valid JSON.", undefined, model);
         const jsonMatch = response.content.match(/\[[\s\S]*\]/);
         if (!jsonMatch)
             return [];
         const parsed = JSON.parse(jsonMatch[0]);
         if (!Array.isArray(parsed))
             return [];
-        return parsed.filter((m) => m.name && m.type && m.content && typeof m.content === 'string');
+        return parsed.filter((m) => m.name && m.type && m.content && typeof m.content === "string");
     }
     catch {
         return [];

package/dist/harness/onboarding.js

@@ -1,10 +1,10 @@
 /**
  * Project auto-detection — detect language, framework, test runner, git state.
  */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
 import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
 import { platform, release } from "node:os";
+import { join } from "node:path";
 const DETECTORS = [
     // [indicator, language, framework, packageManager, testRunner]
     ["pyproject.toml", "python", "", "pip", "pytest"],
@@ -30,7 +30,7 @@ const FRAMEWORKS = {
     "svelte.config.js": "Svelte",
     "manage.py": "Django",
     "tailwind.config.js": "Tailwind CSS",
-    "Dockerfile": "Docker",
+    Dockerfile: "Docker",
     "docker-compose.yml": "Docker Compose",
 };
 export function detectProject(root) {
@@ -63,7 +63,9 @@ export function detectProject(root) {
                 gitBranch = head.slice("ref: refs/heads/".length);
             }
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     const hasReadme = ["README.md", "README.rst", "README.txt", "README"].some((f) => existsSync(join(projectRoot, f)));
     let description = "";
@@ -81,7 +83,17 @@ export function detectProject(root) {
             break;
         }
     }
-    return { root: projectRoot, language, framework, packageManager, testRunner, hasGit, gitBranch, hasReadme, description };
+    return {
+        root: projectRoot,
+        language,
+        framework,
+        packageManager,
+        testRunner,
+        hasGit,
+        gitBranch,
+        hasReadme,
+        description,
+    };
 }
 export function projectContextToPrompt(ctx, model) {
     const parts = [];
@@ -123,7 +135,9 @@ export function projectContextToPrompt(ctx, model) {
             else if (refs.includes("master"))
                 mainBranch = "master";
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         parts.push(`Main branch: ${mainBranch}`);
         // Git user
         try {
@@ -131,7 +145,9 @@ export function projectContextToPrompt(ctx, model) {
             if (user)
                 parts.push(`Git user: ${user}`);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         // Git status (brief)
         try {
             const status = execSync("git status --porcelain", { cwd: ctx.root, stdio: "pipe" }).toString().trim();
@@ -140,15 +156,19 @@ export function projectContextToPrompt(ctx, model) {
                 parts.push(`\nStatus:\n${lines.join("\n")}${status.split("\n").length > 20 ? "\n..." : ""}`);
             }
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         // Recent commits
         try {
             const log = execSync("git log --oneline -5", { cwd: ctx.root, stdio: "pipe" }).toString().trim();
             if (log)
                 parts.push(`\nRecent commits:\n${log}`);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
-    return "# Environment\n" + parts.map((p) => `- ${p}`).join("\n");
+    return `# Environment\n${parts.map((p) => `- ${p}`).join("\n")}`;
 }
 //# sourceMappingURL=onboarding.js.map

package/dist/harness/plugins.d.ts

@@ -18,7 +18,7 @@ export type SkillMetadata = {
     args: string[] | undefined;
     content: string;
     filePath: string;
-    source: 'project' | 'global' | 'plugin';
+    source: "project" | "global" | "plugin";
 };
 export type PluginManifest = {
     name: string;
@@ -48,6 +48,14 @@ export declare function discoverSkills(): SkillMetadata[];
 export declare function findSkill(name: string): SkillMetadata | null;
 /** Find skills that match a trigger condition */
 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<{
+    name: string;
+    description: string;
+}>): {
+    name: string;
+    description: string;
+} | null;
 /** Load a plugin manifest from a directory */
 export declare function loadPluginManifest(dir: string): PluginManifest | null;
 /** Discover plugins from node_modules */

package/dist/harness/plugins.js

@@ -10,11 +10,11 @@
  * 2. ~/.oh/skills/ (global)
  * 3. node_modules packages with "openharness-plugin" keyword
  */
-import { readFileSync, readdirSync, existsSync } from 'node:fs';
-import { join, basename } from 'node:path';
-import { homedir } from 'node:os';
-const PROJECT_SKILLS_DIR = join('.oh', 'skills');
-const GLOBAL_SKILLS_DIR = join(homedir(), '.oh', 'skills');
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+const PROJECT_SKILLS_DIR = join(".oh", "skills");
+const GLOBAL_SKILLS_DIR = join(homedir(), ".oh", "skills");
 /** Parse YAML frontmatter from a skill markdown file */
 function parseSkillFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -33,10 +33,10 @@ function parseSkillFrontmatter(content) {
         result.trigger = triggerMatch[1].trim();
     const toolsMatch = frontmatter.match(/^tools:\s*\[(.+)\]$/m);
     if (toolsMatch)
-        result.tools = toolsMatch[1].split(',').map(t => t.trim());
+        result.tools = toolsMatch[1].split(",").map((t) => t.trim());
     const argsMatch = frontmatter.match(/^args:\s*\[(.+)\]$/m);
     if (argsMatch)
-        result.args = argsMatch[1].split(',').map(a => a.trim());
+        result.args = argsMatch[1].split(",").map((a) => a.trim());
     return result;
 }
 /** Load skills from a directory */
@@ -44,15 +44,15 @@ function loadSkillsFromDir(dir, source) {
     if (!existsSync(dir))
         return [];
     return readdirSync(dir)
-        .filter(f => f.endsWith('.md'))
-        .map(f => {
+        .filter((f) => f.endsWith(".md"))
+        .map((f) => {
         const filePath = join(dir, f);
         try {
-            const content = readFileSync(filePath, 'utf-8');
+            const content = readFileSync(filePath, "utf-8");
             const meta = parseSkillFrontmatter(content);
             return {
-                name: meta.name || basename(f, '.md'),
-                description: meta.description || '',
+                name: meta.name || basename(f, ".md"),
+                description: meta.description || "",
                 trigger: meta.trigger,
                 tools: meta.tools,
                 args: meta.args,
@@ -70,14 +70,14 @@ function loadSkillsFromDir(dir, source) {
 /** 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'));
+    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');
+        const { getInstalledPlugins } = require("./marketplace.js");
         for (const plugin of getInstalledPlugins()) {
-            const pluginSkillsDir = join(plugin.cachePath, 'skills');
-            const pluginSkills = loadSkillsFromDir(pluginSkillsDir, 'plugin');
+            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}`;
@@ -85,30 +85,50 @@ export function discoverSkills() {
             skills.push(...pluginSkills);
         }
     }
-    catch { /* marketplace module may not be loaded yet */ }
+    catch {
+        /* marketplace module may not be loaded yet */
+    }
     return skills;
 }
 /** Find a skill by name (case-insensitive) */
 export function findSkill(name) {
     const skills = discoverSkills();
-    return skills.find(s => s.name.toLowerCase() === name.toLowerCase()) ?? null;
+    return skills.find((s) => s.name.toLowerCase() === name.toLowerCase()) ?? null;
 }
 /** Find skills that match a trigger condition */
 export function findTriggeredSkills(userMessage) {
     const skills = discoverSkills();
-    return skills.filter(s => {
+    return skills.filter((s) => {
         if (!s.trigger)
             return false;
         return userMessage.toLowerCase().includes(s.trigger.toLowerCase());
     });
 }
+/** Find a skill similar to a candidate (for patch-vs-create decision) */
+export function findSimilarSkill(candidateName, candidateDescription, skills) {
+    const nameWords = new Set(candidateName.toLowerCase().split(/[-_ ]+/));
+    for (const skill of skills) {
+        const skillWords = new Set(skill.name.toLowerCase().split(/[-_ ]+/));
+        const overlap = [...nameWords].filter((w) => skillWords.has(w)).length;
+        if (overlap >= Math.ceil(nameWords.size * 0.5))
+            return skill;
+        const descWords = new Set(skill.description.toLowerCase().split(/\s+/));
+        const descOverlap = candidateDescription
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((w) => descWords.has(w)).length;
+        if (descOverlap >= 3)
+            return skill;
+    }
+    return null;
+}
 /** Load a plugin manifest from a directory */
 export function loadPluginManifest(dir) {
-    const manifestPath = join(dir, 'openharness-plugin.json');
+    const manifestPath = join(dir, "openharness-plugin.json");
     if (!existsSync(manifestPath))
         return null;
     try {
-        return JSON.parse(readFileSync(manifestPath, 'utf-8'));
+        return JSON.parse(readFileSync(manifestPath, "utf-8"));
     }
     catch {
         return null;
@@ -118,19 +138,19 @@ export function loadPluginManifest(dir) {
 export function discoverPlugins() {
     const plugins = [];
     // Check node_modules for packages with openharness-plugin.json
-    const nodeModules = join('.', 'node_modules');
+    const nodeModules = join(".", "node_modules");
     if (!existsSync(nodeModules))
         return plugins;
     try {
         for (const pkg of readdirSync(nodeModules)) {
-            if (pkg.startsWith('.'))
+            if (pkg.startsWith("."))
                 continue;
             const pkgDir = join(nodeModules, pkg);
             const manifest = loadPluginManifest(pkgDir);
             if (manifest)
                 plugins.push(manifest);
             // Scoped packages
-            if (pkg.startsWith('@')) {
+            if (pkg.startsWith("@")) {
                 try {
                     for (const sub of readdirSync(pkgDir)) {
                         const subDir = join(pkgDir, sub);
@@ -139,18 +159,22 @@ export function discoverPlugins() {
                             plugins.push(subManifest);
                     }
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
             }
         }
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     return plugins;
 }
 /** Build a prompt listing available skills for the LLM */
 export function skillsToPrompt(skills) {
     if (skills.length === 0)
-        return '';
-    const lines = skills.map(s => `- ${s.name}: ${s.description}${s.trigger ? ` (auto-trigger: "${s.trigger}")` : ''}`);
-    return `# Available Skills\nUse the Skill tool to invoke these:\n${lines.join('\n')}`;
+        return "";
+    const lines = skills.map((s) => `- ${s.name}: ${s.description}${s.trigger ? ` (auto-trigger: "${s.trigger}")` : ""}`);
+    return `# Available Skills\nUse the Skill tool to invoke these:\n${lines.join("\n")}`;
 }
 //# sourceMappingURL=plugins.js.map