omniharness-cli 0.1.77 → 0.1.78

package/dist/agent/mastraEngine.js

@@ -5,7 +5,8 @@ import { attachmentBlock, kindFromName } from '../attachments.js';
 import { OmniRouteClient } from '../config/omniRoute.js';
 import { saveActiveCombo } from '../config/settings.js';
 import { createSystemTools } from '../tools/systemTools.js';
-import { loadSkills, renderSkillCommand, skillSchema } from '../skills.js';
+import { loadSkills, renderSkillCommand, skillKind, skillSchema } from '../skills.js';
+import { loadPluginSkills, renderCommandBody } from '../plugins.js';
 import { chunkText, cosineSimilarity } from '../search.js';
 import { loadSemanticIndex, saveSemanticIndex } from '../semanticStore.js';
 import { loadSession, saveSession, clearSession } from '../sessionStore.js';
@@ -122,7 +123,14 @@ export async function createMastraEngine(config) {
     };
     const emit = (event) => { for (const listener of listeners)
         listener(event); };
-    const skills = await loadSkills(config.workspaceRoot);
+    // OMNIHARNESS.md skills first: a workspace's own definition wins a name
+    // collision with a plugin's.
+    const ownSkills = await loadSkills(config.workspaceRoot);
+    const taken = new Set(ownSkills.map((skill) => skill.name));
+    const skills = [
+        ...ownSkills,
+        ...(await loadPluginSkills(config.workspaceRoot)).filter((skill) => !taken.has(skill.name)),
+    ];
     const systemTools = {
         read_file: {
             name: 'read_file', description: tools.readFile.description, highRisk: false, parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
@@ -228,9 +236,19 @@ export async function createMastraEngine(config) {
         }
     };
     for (const skill of skills) {
+        const prompt = skillKind(skill) === 'prompt';
         systemTools[skill.name] = {
-            name: skill.name, description: skill.description, highRisk: true, parameters: skillSchema(skill).parameters ?? { type: 'object', properties: {} },
+            name: skill.name,
+            description: skill.description,
+            // A prompt skill returns instructions. It runs nothing itself, so it
+            // does not need the shell and does not carry the shell's risk — the
+            // tools it then asks for are gated on their own terms.
+            highRisk: !prompt,
+            parameters: skillSchema(skill).parameters ?? { type: 'object', properties: {} },
             execute: async (input) => {
+                if (prompt) {
+                    return renderCommandBody(skill.prompt ?? '', String(input.arguments ?? ''));
+                }
                 if (!config.shellAllowed)
                     throw new Error('shell execution is disabled; custom skills need shell access');
                 const script = renderSkillCommand(skill.command, skill.parameters, input);

package/dist/plugins.js

@@ -0,0 +1,235 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * Split leading `---` delimited frontmatter from a markdown body.
+ *
+ * Deliberately a small key/value reader rather than a YAML parser: command
+ * frontmatter in practice is flat scalars, and a dependency that can evaluate
+ * arbitrary YAML is a poor thing to point at files the user downloaded. A file
+ * with no frontmatter is not an error — it is a prompt with no metadata.
+ */
+export function parseFrontmatter(text) {
+    const normalized = text.replace(/^/, '');
+    const match = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(normalized);
+    if (!match)
+        return { fields: {}, body: normalized.trim() };
+    const fields = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const kv = /^([A-Za-z0-9_-]+)[ \t]*:[ \t]*(.*)$/.exec(line);
+        if (!kv)
+            continue;
+        let value = kv[2].trim();
+        // Strip one layer of matching quotes, the only quoting seen in practice.
+        if ((value.startsWith('"') && value.endsWith('"') && value.length > 1)
+            || (value.startsWith("'") && value.endsWith("'") && value.length > 1)) {
+            value = value.slice(1, -1);
+        }
+        fields[kv[1].toLowerCase()] = value;
+    }
+    return { fields, body: normalized.slice(match[0].length).trim() };
+}
+function splitList(value) {
+    if (!value)
+        return [];
+    const inner = value.trim().replace(/^\[/, '').replace(/\]$/, '');
+    // Split on commas that are not inside the parentheses of Bash(gh pr view:*).
+    const out = [];
+    let depth = 0;
+    let current = '';
+    for (const ch of inner) {
+        if (ch === '(')
+            depth += 1;
+        if (ch === ')')
+            depth = Math.max(0, depth - 1);
+        if (ch === ',' && depth === 0) {
+            out.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    out.push(current);
+    return out.map((entry) => entry.trim().replace(/^["']|["']$/g, '')).filter((entry) => entry !== '');
+}
+async function readJSON(file) {
+    try {
+        return JSON.parse(await fs.readFile(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function readCommands(root, pluginName, dir) {
+    const base = path.join(root, dir);
+    let entries;
+    try {
+        entries = await fs.readdir(base);
+    }
+    catch {
+        return [];
+    }
+    const commands = [];
+    for (const entry of entries.sort()) {
+        if (!entry.toLowerCase().endsWith('.md'))
+            continue;
+        const file = path.join(base, entry);
+        let raw;
+        try {
+            raw = await fs.readFile(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const { fields, body } = parseFrontmatter(raw);
+        if (body === '')
+            continue; // nothing to instruct with
+        commands.push({
+            name: entry.replace(/\.md$/i, ''),
+            description: fields.description ?? `${dir.replace(/s$/, '')} from ${pluginName}`,
+            body,
+            allowedTools: splitList(fields['allowed-tools']),
+            plugin: pluginName,
+            path: file,
+        });
+    }
+    return commands;
+}
+/** Read one plugin directory. Returns null if it is not a plugin. */
+export async function loadPlugin(root) {
+    const manifest = await readJSON(path.join(root, '.claude-plugin', 'plugin.json'));
+    if (!manifest || typeof manifest.name !== 'string' || manifest.name === '')
+        return null;
+    const name = manifest.name;
+    const author = manifest.author;
+    const commands = [
+        ...await readCommands(root, name, 'commands'),
+        ...await readCommands(root, name, 'agents'),
+    ];
+    return {
+        name,
+        description: typeof manifest.description === 'string' ? manifest.description : '',
+        version: typeof manifest.version === 'string' ? manifest.version : '0.0.0',
+        author: typeof author === 'string' ? author : (author?.name ?? ''),
+        root,
+        commands,
+    };
+}
+async function subdirectories(dir) {
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => path.join(dir, e.name)).sort();
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Read a directory as either a single plugin or a marketplace of them. A
+ * marketplace's `source` entries are relative to the marketplace root; a
+ * source pointing outside it is ignored rather than followed.
+ */
+export async function loadFrom(dir, depth = 2) {
+    const single = await loadPlugin(dir);
+    if (single)
+        return [single];
+    const market = await readJSON(path.join(dir, '.claude-plugin', 'marketplace.json'));
+    const out = [];
+    if (market && Array.isArray(market.plugins)) {
+        for (const entry of market.plugins) {
+            const source = typeof entry.source === 'string' ? entry.source : '';
+            if (source === '')
+                continue;
+            const resolved = path.resolve(dir, source);
+            const rel = path.relative(dir, resolved);
+            if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel))
+                continue;
+            const plugin = await loadPlugin(resolved);
+            if (plugin)
+                out.push(plugin);
+        }
+        return out;
+    }
+    // A directory of plugin directories — and a child may itself be a
+    // marketplace rather than a plugin, which is what cloning a plugin
+    // repository into the plugins directory gives you. Descending only one
+    // level found nothing in that very ordinary case. Bounded, so a plugins
+    // directory holding a deep source tree is not walked to the bottom.
+    if (depth <= 0)
+        return out;
+    for (const child of await subdirectories(dir)) {
+        out.push(...await loadFrom(child, depth - 1));
+    }
+    return out;
+}
+/**
+ * The directories searched for plugins, nearest first.
+ *
+ * OMNIHARNESS_PLUGIN_PATH replaces the list entirely, delimited like PATH.
+ * Setting it empty disables discovery. It exists because the default reaches
+ * into the user's home directory: without an override, what the agent can do
+ * depends on what happens to be installed on the machine, which makes a test
+ * or a CI run read differently from one box to the next.
+ */
+export function pluginSearchPath(workspaceRoot) {
+    const override = process.env.OMNIHARNESS_PLUGIN_PATH;
+    if (override !== undefined) {
+        return override.split(path.delimiter).map((entry) => entry.trim()).filter((entry) => entry !== '');
+    }
+    const home = os.homedir();
+    return [
+        path.join(workspaceRoot, '.claude', 'plugins'),
+        path.join(workspaceRoot, '.omniharness', 'plugins'),
+        ...(home ? [path.join(home, '.claude', 'plugins')] : []),
+    ];
+}
+/**
+ * Discover every plugin on the search path. A workspace plugin wins a name
+ * collision with a user-level one, because the nearer definition is the more
+ * specific.
+ */
+export async function discoverPlugins(workspaceRoot, roots = pluginSearchPath(workspaceRoot)) {
+    const seen = new Set();
+    const out = [];
+    for (const root of roots) {
+        for (const plugin of await loadFrom(root)) {
+            if (seen.has(plugin.name))
+                continue;
+            seen.add(plugin.name);
+            out.push(plugin);
+        }
+    }
+    return out;
+}
+/** Substitute the argument tokens a command body may use. */
+export function renderCommandBody(body, args) {
+    const words = args.trim() === '' ? [] : args.trim().split(/\s+/);
+    let out = body.split('$ARGUMENTS').join(args.trim());
+    // $1..$9 take one word each, matching the shell convention the format borrows.
+    out = out.replace(/\$([1-9])/g, (_, digit) => words[Number(digit) - 1] ?? '');
+    return out;
+}
+const ARGUMENTS_PARAM = [{ name: 'arguments', type: 'string' }];
+/**
+ * Present a plugin command as a Skill so the rest of the engine does not have
+ * to know where it came from. Names are prefixed with the plugin so two
+ * plugins can both ship a "review" command.
+ */
+export function commandToSkill(command) {
+    return {
+        name: `${command.plugin}:${command.name}`.replace(/[^A-Za-z0-9_:.-]/g, '-'),
+        description: command.description,
+        command: '',
+        parameters: ARGUMENTS_PARAM,
+        kind: 'prompt',
+        prompt: command.body,
+        source: command.plugin,
+        allowedTools: command.allowedTools,
+    };
+}
+/** Every command from every discovered plugin, as Skills. */
+export async function loadPluginSkills(workspaceRoot) {
+    const plugins = await discoverPlugins(workspaceRoot);
+    return plugins.flatMap((plugin) => plugin.commands.map(commandToSkill));
+}
+//# sourceMappingURL=plugins.js.map

package/dist/skills.js

@@ -1,5 +1,9 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+/** Whether a skill runs a command or supplies instructions. */
+export function skillKind(skill) {
+    return skill.kind ?? 'shell';
+}
 /**
  * Parse an OMNIHARNESS.md skills definition. Blocks start with `## <name>`
  * and contain `description:`, `command:`, and `param: <name> <type>` fields.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omniharness-cli",
-  "version": "0.1.77",
+  "version": "0.1.78",
   "description": "OmniHarness — local-first agent orchestration harness for OmniRoute.",
   "license": "MIT",
   "type": "module",