@ruvnet/open-claude-code 2.0.0

package/src/plugins/loader.mjs

@@ -0,0 +1,138 @@
+/**
+ * Plugin Loader — load plugins from directory, git, or npm.
+ *
+ * Plugins can provide: tools, agents, skills, hooks.
+ * Plugin format: a directory with a plugin.json manifest.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+
+export class PluginLoader {
+    /**
+     * @param {string} [pluginDir] - directory to scan for plugins
+     */
+    constructor(pluginDir) {
+        this.pluginDir = pluginDir ||
+            path.join(os.homedir(), '.claude', 'plugins');
+        this.plugins = new Map();
+    }
+
+    /**
+     * Load plugins from the plugin directory.
+     * @returns {Array<object>} loaded plugin manifests
+     */
+    async loadFromDirectory(dir) {
+        const targetDir = dir || this.pluginDir;
+        const loaded = [];
+
+        try {
+            if (!fs.existsSync(targetDir)) return loaded;
+
+            const entries = fs.readdirSync(targetDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+
+                const manifestPath = path.join(targetDir, entry.name, 'plugin.json');
+                if (!fs.existsSync(manifestPath)) continue;
+
+                try {
+                    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+                    manifest._dir = path.join(targetDir, entry.name);
+                    manifest._name = entry.name;
+                    this.plugins.set(manifest.name || entry.name, manifest);
+                    loaded.push(manifest);
+                } catch {
+                    // Skip malformed plugins
+                }
+            }
+        } catch {
+            // Directory not readable
+        }
+
+        return loaded;
+    }
+
+    /**
+     * Clone a plugin from a git repo and load it.
+     * @param {string} repoUrl - git repository URL
+     * @param {string} [name] - plugin name (default: repo name)
+     * @returns {object|null} loaded manifest
+     */
+    async loadFromGit(repoUrl, name) {
+        const pluginName = name || repoUrl.split('/').pop()?.replace('.git', '') || 'plugin';
+        const targetDir = path.join(this.pluginDir, pluginName);
+
+        try {
+            fs.mkdirSync(this.pluginDir, { recursive: true });
+
+            if (fs.existsSync(targetDir)) {
+                // Update existing
+                execSync('git pull', { cwd: targetDir, stdio: 'pipe' });
+            } else {
+                // Clone new
+                execSync(`git clone --depth 1 ${repoUrl} ${targetDir}`, { stdio: 'pipe' });
+            }
+
+            const manifestPath = path.join(targetDir, 'plugin.json');
+            if (fs.existsSync(manifestPath)) {
+                const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+                manifest._dir = targetDir;
+                manifest._name = pluginName;
+                this.plugins.set(manifest.name || pluginName, manifest);
+                return manifest;
+            }
+        } catch {
+            // Git operation failed
+        }
+
+        return null;
+    }
+
+    /**
+     * Get all installed plugins.
+     * @returns {Array<object>}
+     */
+    getInstalledPlugins() {
+        return [...this.plugins.values()];
+    }
+
+    /**
+     * Get a plugin by name.
+     * @param {string} name
+     * @returns {object|undefined}
+     */
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+
+    /**
+     * Remove a plugin by name.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    removePlugin(name) {
+        const plugin = this.plugins.get(name);
+        if (!plugin) return false;
+
+        try {
+            if (plugin._dir && fs.existsSync(plugin._dir)) {
+                fs.rmSync(plugin._dir, { recursive: true, force: true });
+            }
+        } catch {
+            // Best effort
+        }
+
+        return this.plugins.delete(name);
+    }
+
+    /**
+     * Get plugin count.
+     * @returns {number}
+     */
+    count() {
+        return this.plugins.size;
+    }
+}

package/src/skills/loader.mjs

@@ -0,0 +1,147 @@
+/**
+ * Skills Loader — loads skills from .claude/skills/{name}/SKILL.md
+ *
+ * Skills are invoked via /skill-name in REPL or the Skill tool.
+ * Each skill has a SKILL.md that defines:
+ * - name, description, trigger conditions
+ * - The prompt to inject when the skill is invoked
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+export class SkillsLoader {
+    constructor() {
+        this.skills = new Map();
+        this.searchPaths = [];
+    }
+
+    /**
+     * Load skills from standard directories.
+     * @param {string} [cwd] - project working directory
+     */
+    load(cwd = process.cwd()) {
+        this.searchPaths = [
+            path.join(cwd, '.claude', 'skills'),
+            path.join(process.env.HOME || '', '.claude', 'skills'),
+        ];
+
+        for (const dir of this.searchPaths) {
+            this._loadFromDir(dir);
+        }
+
+        return this;
+    }
+
+    _loadFromDir(dir) {
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+
+                const skillFile = path.join(dir, entry.name, 'SKILL.md');
+                try {
+                    const content = fs.readFileSync(skillFile, 'utf-8');
+                    const skill = parseSkill(content, entry.name);
+                    if (skill) {
+                        skill.source = skillFile;
+                        this.skills.set(skill.name, skill);
+                    }
+                } catch {
+                    // Skill directory without SKILL.md, skip
+                }
+            }
+        } catch {
+            // Directory does not exist
+        }
+    }
+
+    /**
+     * Get a skill by name.
+     * @param {string} name
+     * @returns {object|null}
+     */
+    get(name) {
+        // Try exact match, then prefix match
+        if (this.skills.has(name)) return this.skills.get(name);
+        for (const [key, skill] of this.skills) {
+            if (key.startsWith(name) || skill.aliases?.includes(name)) {
+                return skill;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * List all loaded skills.
+     * @returns {Array<object>}
+     */
+    list() {
+        return [...this.skills.values()];
+    }
+
+    /**
+     * Run a skill, returning its prompt for injection into the conversation.
+     * @param {string} name - skill name
+     * @param {string} [args] - optional arguments
+     * @returns {string} skill prompt
+     */
+    async run(name, args) {
+        const skill = this.get(name);
+        if (!skill) {
+            throw new Error(`Unknown skill: ${name}`);
+        }
+
+        let prompt = skill.prompt;
+        if (args) {
+            prompt = prompt.replace('$ARGUMENTS', args);
+            prompt += `\n\nArguments: ${args}`;
+        }
+
+        return `[Skill: ${skill.name}]\n${prompt}`;
+    }
+}
+
+/**
+ * Parse a SKILL.md file into a skill definition.
+ */
+function parseSkill(content, dirName) {
+    const lines = content.split('\n');
+    const skill = {
+        name: dirName,
+        description: '',
+        aliases: [],
+        trigger: null,
+        prompt: content,
+    };
+
+    // Parse YAML frontmatter if present
+    if (lines[0]?.trim() === '---') {
+        const endIdx = lines.indexOf('---', 1);
+        if (endIdx > 0) {
+            const frontmatter = lines.slice(1, endIdx).join('\n');
+            for (const line of frontmatter.split('\n')) {
+                const colonIdx = line.indexOf(':');
+                if (colonIdx === -1) continue;
+                const key = line.slice(0, colonIdx).trim();
+                const value = line.slice(colonIdx + 1).trim();
+
+                if (key === 'name') skill.name = value;
+                else if (key === 'description') skill.description = value;
+                else if (key === 'trigger') skill.trigger = value;
+                else if (key === 'aliases') {
+                    skill.aliases = value.replace(/[\[\]]/g, '').split(',').map(s => s.trim());
+                }
+            }
+            skill.prompt = lines.slice(endIdx + 1).join('\n').trim();
+        }
+    }
+
+    // Extract description from first paragraph if not in frontmatter
+    if (!skill.description && skill.prompt) {
+        const firstLine = skill.prompt.split('\n').find(l => l.trim() && !l.startsWith('#'));
+        if (firstLine) skill.description = firstLine.trim().slice(0, 100);
+    }
+
+    return skill;
+}

package/src/skills/runner.mjs

@@ -0,0 +1,55 @@
+/**
+ * Skills Runner — executes a skill by injecting its prompt.
+ *
+ * When a skill is invoked, its prompt is injected as a system message
+ * into the conversation context, guiding the agent's behavior.
+ */
+
+export class SkillRunner {
+    /**
+     * @param {object} loader - SkillsLoader instance
+     * @param {object} agentLoop - agent loop instance
+     */
+    constructor(loader, agentLoop) {
+        this.loader = loader;
+        this.loop = agentLoop;
+    }
+
+    /**
+     * Execute a skill.
+     * @param {string} name - skill name
+     * @param {string} [args] - optional arguments
+     * @returns {AsyncGenerator} event stream from agent loop
+     */
+    async *execute(name, args) {
+        const skill = this.loader.get(name);
+        if (!skill) {
+            yield { type: 'error', message: `Unknown skill: ${name}` };
+            return;
+        }
+
+        // Build the skill prompt
+        let prompt = skill.prompt;
+        if (args) {
+            prompt = prompt.replace(/\$ARGUMENTS/g, args);
+        }
+
+        // Inject skill context as a user message
+        const message = `[Invoking skill: ${skill.name}]\n\n${prompt}${args ? `\n\nArguments: ${args}` : ''}`;
+
+        // Run through agent loop
+        yield* this.loop.run(message);
+    }
+
+    /**
+     * List available skills for display.
+     * @returns {Array<{name: string, description: string}>}
+     */
+    listAvailable() {
+        return this.loader.list().map(s => ({
+            name: s.name,
+            description: s.description,
+            aliases: s.aliases || [],
+        }));
+    }
+}

package/src/telemetry/index.mjs

@@ -0,0 +1,96 @@
+/**
+ * Telemetry Stub — basic telemetry interface (no actual reporting).
+ *
+ * Logs events to debug output when CLAUDE_CODE_DEBUG is set.
+ * Designed to be a drop-in interface for the full telemetry system.
+ */
+
+const events = [];
+let enabled = true;
+
+/**
+ * Track a telemetry event.
+ * @param {string} event - event name
+ * @param {object} [properties] - event properties
+ */
+export function track(event, properties = {}) {
+    if (!enabled) return;
+    if (process.env.CLAUDE_CODE_DISABLE_TELEMETRY === '1') return;
+
+    const entry = {
+        event,
+        properties,
+        timestamp: Date.now(),
+    };
+
+    events.push(entry);
+
+    // Keep max 1000 events in memory
+    if (events.length > 1000) {
+        events.splice(0, events.length - 1000);
+    }
+
+    if (process.env.CLAUDE_CODE_DEBUG) {
+        console.error(`[telemetry] ${event}`, JSON.stringify(properties).slice(0, 200));
+    }
+}
+
+/**
+ * Track a timing event.
+ * @param {string} event - event name
+ * @param {number} durationMs - duration in milliseconds
+ * @param {object} [properties] - additional properties
+ */
+export function trackTiming(event, durationMs, properties = {}) {
+    track(event, { ...properties, durationMs });
+}
+
+/**
+ * Track an error.
+ * @param {string} event - error context
+ * @param {Error} error - the error
+ */
+export function trackError(event, error) {
+    track(`error.${event}`, {
+        message: error.message,
+        stack: error.stack?.split('\n').slice(0, 3).join('\n'),
+    });
+}
+
+/**
+ * Get collected events (for debugging).
+ * @returns {Array}
+ */
+export function getEvents() {
+    return [...events];
+}
+
+/**
+ * Clear collected events.
+ */
+export function clear() {
+    events.length = 0;
+}
+
+/**
+ * Enable or disable telemetry.
+ * @param {boolean} value
+ */
+export function setEnabled(value) {
+    enabled = value;
+}
+
+/**
+ * Get telemetry stats.
+ */
+export function getStats() {
+    const counts = {};
+    for (const e of events) {
+        counts[e.event] = (counts[e.event] || 0) + 1;
+    }
+    return {
+        totalEvents: events.length,
+        enabled,
+        eventCounts: counts,
+    };
+}

package/src/tools/agent.mjs

@@ -0,0 +1,127 @@
+/**
+ * Agent Tool — spawn a subagent with its own agent loop.
+ *
+ * Features:
+ * - subagent_type parameter
+ * - isolation: "worktree" option
+ * - run_in_background option
+ * - model override
+ */
+
+import { createAgentLoop } from '../core/agent-loop.mjs';
+import { createToolRegistry } from './registry.mjs';
+import { createPermissionChecker } from '../permissions/checker.mjs';
+
+export const AgentTool = {
+    name: 'Agent',
+    description: 'Spawn a subagent to handle a task. The subagent has its own context and tools.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            prompt: {
+                type: 'string',
+                description: 'The task for the subagent to perform',
+            },
+            allowed_tools: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'List of tool names the subagent can use (default: all)',
+            },
+            subagent_type: {
+                type: 'string',
+                description: 'Type of subagent (e.g. coder, reviewer, researcher)',
+            },
+            isolation: {
+                type: 'string',
+                enum: ['default', 'worktree'],
+                description: 'Isolation mode. "worktree" uses a git worktree.',
+            },
+            run_in_background: {
+                type: 'boolean',
+                description: 'Run in background and return immediately',
+            },
+            model: {
+                type: 'string',
+                description: 'Override model for this subagent',
+            },
+        },
+        required: ['prompt'],
+    },
+
+    validateInput(input) {
+        const errors = [];
+        if (!input.prompt) errors.push('prompt is required');
+        return errors;
+    },
+
+    // Track background subagents
+    _backgroundAgents: new Map(),
+    _nextBgId: 0,
+
+    async call(input) {
+        const model = input.model || process.env.SUBAGENT_MODEL || 'claude-sonnet-4-6';
+        const tools = createToolRegistry();
+        const permissions = createPermissionChecker({ defaultMode: 'bypassPermissions' });
+
+        // Build type-specific system prompt prefix
+        let systemPrefix = '';
+        if (input.subagent_type) {
+            const typePrompts = {
+                coder: 'You are a coding agent. Write clean, tested code.',
+                reviewer: 'You are a code reviewer. Analyze code for bugs and improvements.',
+                researcher: 'You are a research agent. Find and summarize information.',
+                tester: 'You are a testing agent. Write and run tests.',
+                planner: 'You are a planning agent. Break down tasks into steps.',
+            };
+            systemPrefix = typePrompts[input.subagent_type] || `You are a ${input.subagent_type} agent.`;
+        }
+
+        const fullPrompt = systemPrefix
+            ? `${systemPrefix}\n\nTask: ${input.prompt}`
+            : input.prompt;
+
+        const loop = createAgentLoop({
+            model,
+            tools,
+            permissions,
+            settings: { stream: false },
+        });
+
+        if (input.run_in_background) {
+            const bgId = ++AgentTool._nextBgId;
+            const entry = { id: bgId, status: 'running', result: null, prompt: input.prompt };
+            AgentTool._backgroundAgents.set(bgId, entry);
+
+            // Run in background
+            runSubagent(loop, fullPrompt).then(result => {
+                entry.status = 'completed';
+                entry.result = result;
+            }).catch(err => {
+                entry.status = 'error';
+                entry.result = err.message;
+            });
+
+            return `Subagent started in background: id=${bgId}`;
+        }
+
+        return runSubagent(loop, fullPrompt);
+    },
+};
+
+async function runSubagent(loop, prompt) {
+    const results = [];
+    try {
+        for await (const event of loop.run(prompt)) {
+            if (event.type === 'assistant' && event.content) {
+                results.push(event.content);
+            }
+            if (event.type === 'result') {
+                results.push(`[tool:${event.tool}] ${String(event.result).slice(0, 500)}`);
+            }
+        }
+    } catch (err) {
+        return `Subagent error: ${err.message}`;
+    }
+
+    return results.join('\n') || 'Subagent completed with no output.';
+}

package/src/tools/ask-user.mjs

@@ -0,0 +1,61 @@
+/**
+ * AskUser Tool — prompt the user with a question and return their response.
+ *
+ * Used when the agent needs clarification or confirmation from the user.
+ * In non-interactive mode, returns a default or times out.
+ */
+
+import readline from 'readline';
+
+export const AskUserTool = {
+    name: 'AskUser',
+    description: 'Ask the user a question and wait for their response.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            question: {
+                type: 'string',
+                description: 'The question to ask the user',
+            },
+            default_value: {
+                type: 'string',
+                description: 'Default value if user provides no input',
+            },
+            timeout: {
+                type: 'number',
+                description: 'Timeout in milliseconds (default: 60000)',
+            },
+        },
+        required: ['question'],
+    },
+
+    validateInput(input) {
+        return input.question ? [] : ['question is required'];
+    },
+
+    async call(input) {
+        // In non-interactive mode, return default
+        if (!process.stdin.isTTY) {
+            return input.default_value || '[non-interactive: no user input available]';
+        }
+
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stderr,
+            });
+
+            const timeout = setTimeout(() => {
+                rl.close();
+                resolve(input.default_value || '[timeout: no response]');
+            }, input.timeout || 60000);
+
+            process.stderr.write(`\n\x1b[36m? ${input.question}\x1b[0m\n> `);
+            rl.question('', (answer) => {
+                clearTimeout(timeout);
+                rl.close();
+                resolve(answer.trim() || input.default_value || '');
+            });
+        });
+    },
+};