@ruvnet/open-claude-code 2.0.0

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@ruvnet/open-claude-code",
+  "version": "2.0.0",
+  "description": "Open source Claude Code CLI — based on ruDevolution decompilation of v2.1.91",
+  "type": "module",
+  "bin": {
+    "occ": "src/index.mjs"
+  },
+  "files": [
+    "src/",
+    "test/"
+  ],
+  "scripts": {
+    "start": "node src/index.mjs",
+    "test": "node test/test.mjs"
+  },
+  "keywords": [
+    "claude",
+    "code",
+    "cli",
+    "ai",
+    "decompiler",
+    "open-source"
+  ],
+  "license": "MIT",
+  "repository": "https://github.com/ruvnet/open-claude-code"
+}

package/src/agents/loader.mjs

@@ -0,0 +1,89 @@
+/**
+ * Agent Loader — loads custom agent definitions from .claude/agents/
+ *
+ * Supports two formats:
+ * - JSON: .claude/agents/*.json
+ * - Markdown with YAML frontmatter: .claude/agents/*.md
+ *
+ * Agent definitions specify: name, description, model, tools, hooks, prompt.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { parseAgentDefinition } from './parser.mjs';
+
+export class AgentLoader {
+    constructor() {
+        this.agents = new Map();
+        this.searchPaths = [];
+    }
+
+    /**
+     * Load agents from standard directories.
+     * @param {string} [cwd] - project working directory
+     */
+    load(cwd = process.cwd()) {
+        this.searchPaths = [
+            path.join(cwd, '.claude', 'agents'),
+            path.join(process.env.HOME || '', '.claude', 'agents'),
+        ];
+
+        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.isFile()) continue;
+                const ext = path.extname(entry.name);
+                if (ext !== '.json' && ext !== '.md') continue;
+
+                const filePath = path.join(dir, entry.name);
+                try {
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    const agent = parseAgentDefinition(content, ext);
+                    if (agent && agent.name) {
+                        this.agents.set(agent.name, { ...agent, source: filePath });
+                    }
+                } catch (err) {
+                    if (process.env.DEBUG) {
+                        console.error(`Failed to load agent ${filePath}: ${err.message}`);
+                    }
+                }
+            }
+        } catch {
+            // Directory does not exist
+        }
+    }
+
+    /**
+     * Get an agent definition by name.
+     * @param {string} name
+     * @returns {object|null}
+     */
+    get(name) {
+        return this.agents.get(name) || null;
+    }
+
+    /**
+     * List all loaded agents.
+     * @returns {Array<object>}
+     */
+    list() {
+        return [...this.agents.values()];
+    }
+
+    /**
+     * Check if an agent exists.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    has(name) {
+        return this.agents.has(name);
+    }
+}

package/src/agents/parser.mjs

@@ -0,0 +1,98 @@
+/**
+ * Agent Parser — parses agent definitions from JSON and Markdown formats.
+ *
+ * JSON format:
+ * {
+ *   "name": "my-agent",
+ *   "description": "Does things",
+ *   "model": "claude-sonnet-4-6",
+ *   "tools": ["Bash", "Read", "Write"],
+ *   "hooks": { ... },
+ *   "prompt": "You are a specialized agent..."
+ * }
+ *
+ * Markdown format (YAML frontmatter):
+ * ---
+ * name: my-agent
+ * description: Does things
+ * model: claude-sonnet-4-6
+ * tools: [Bash, Read, Write]
+ * ---
+ * You are a specialized agent...
+ */
+
+/**
+ * Parse an agent definition from file content.
+ * @param {string} content - file content
+ * @param {string} ext - file extension (.json or .md)
+ * @returns {object} agent definition
+ */
+export function parseAgentDefinition(content, ext) {
+    if (ext === '.json') {
+        return parseJsonAgent(content);
+    }
+    if (ext === '.md') {
+        return parseMarkdownAgent(content);
+    }
+    throw new Error(`Unsupported agent format: ${ext}`);
+}
+
+function parseJsonAgent(content) {
+    const data = JSON.parse(content);
+    return normalizeAgent(data);
+}
+
+function parseMarkdownAgent(content) {
+    const { frontmatter, body } = parseFrontmatter(content);
+    return normalizeAgent({ ...frontmatter, prompt: body });
+}
+
+/**
+ * Parse YAML-like frontmatter from markdown.
+ * Simple key-value parser (no full YAML dependency).
+ */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+
+    const yamlBlock = match[1];
+    const body = match[2].trim();
+    const frontmatter = {};
+
+    for (const line of yamlBlock.split('\n')) {
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1) continue;
+
+        const key = line.slice(0, colonIdx).trim();
+        let value = line.slice(colonIdx + 1).trim();
+
+        // Parse arrays: [a, b, c]
+        if (value.startsWith('[') && value.endsWith(']')) {
+            value = value.slice(1, -1).split(',').map(s => s.trim()).filter(Boolean);
+        }
+        // Parse booleans
+        else if (value === 'true') value = true;
+        else if (value === 'false') value = false;
+        // Parse numbers
+        else if (/^\d+$/.test(value)) value = parseInt(value, 10);
+
+        frontmatter[key] = value;
+    }
+
+    return { frontmatter, body };
+}
+
+function normalizeAgent(data) {
+    return {
+        name: data.name || 'unnamed',
+        description: data.description || '',
+        model: data.model || null,
+        tools: Array.isArray(data.tools) ? data.tools : [],
+        hooks: data.hooks || {},
+        prompt: data.prompt || '',
+        maxTurns: data.maxTurns || data.max_turns || 10,
+        temperature: data.temperature || undefined,
+    };
+}

package/src/agents/teams.mjs

@@ -0,0 +1,123 @@
+/**
+ * Agent Teams — multi-agent coordination.
+ *
+ * Allows registering named agents that can communicate via messages.
+ * Each teammate is an agent loop that can be invoked with a prompt.
+ */
+
+export class AgentTeams {
+    constructor() {
+        /** @type {Map<string, { loop: object, role?: string, status: string }>} */
+        this.teammates = new Map();
+        this.messageLog = [];
+    }
+
+    /**
+     * Register a named agent.
+     * @param {string} name - unique agent name
+     * @param {object} agentLoop - agent loop with .run() async generator
+     * @param {object} [options]
+     * @param {string} [options.role] - agent role description
+     */
+    register(name, agentLoop, options = {}) {
+        if (this.teammates.has(name)) {
+            throw new Error(`Agent "${name}" is already registered`);
+        }
+        this.teammates.set(name, {
+            loop: agentLoop,
+            role: options.role || 'general',
+            status: 'idle',
+        });
+    }
+
+    /**
+     * Unregister an agent.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    unregister(name) {
+        return this.teammates.delete(name);
+    }
+
+    /**
+     * Send a message to a teammate and collect all events.
+     * @param {string} to - target agent name
+     * @param {string} message - prompt to send
+     * @returns {Promise<Array<object>>} collected events
+     */
+    async sendMessage(to, message) {
+        const agent = this.teammates.get(to);
+        if (!agent) throw new Error(`Unknown teammate: ${to}`);
+
+        agent.status = 'running';
+        const results = [];
+
+        try {
+            for await (const event of agent.loop.run(message)) {
+                results.push(event);
+            }
+        } finally {
+            agent.status = 'idle';
+        }
+
+        this.messageLog.push({
+            to,
+            message: message.substring(0, 100),
+            resultCount: results.length,
+            timestamp: new Date().toISOString(),
+        });
+
+        return results;
+    }
+
+    /**
+     * Broadcast a message to all teammates.
+     * @param {string} message
+     * @returns {Promise<Map<string, Array<object>>>} results per agent
+     */
+    async broadcast(message) {
+        const results = new Map();
+        const promises = [];
+
+        for (const [name] of this.teammates) {
+            promises.push(
+                this.sendMessage(name, message)
+                    .then(events => results.set(name, events))
+                    .catch(err => results.set(name, [{ type: 'error', message: err.message }]))
+            );
+        }
+
+        await Promise.all(promises);
+        return results;
+    }
+
+    /**
+     * List all registered teammates.
+     * @returns {Array<{ name: string, role: string, status: string }>}
+     */
+    list() {
+        return [...this.teammates.entries()].map(([name, info]) => ({
+            name,
+            role: info.role,
+            status: info.status,
+        }));
+    }
+
+    /**
+     * Get the message log.
+     * @param {number} [limit] - max entries to return
+     * @returns {Array<object>}
+     */
+    getMessageLog(limit) {
+        if (limit) return this.messageLog.slice(-limit);
+        return [...this.messageLog];
+    }
+
+    /**
+     * Get count of registered teammates.
+     * @returns {number}
+     */
+    size() {
+        return this.teammates.size;
+    }
+}

package/src/auth/oauth.mjs

@@ -0,0 +1,220 @@
+/**
+ * OAuth Client — PKCE OAuth flow for Anthropic and other providers.
+ *
+ * Supports:
+ * - Device code flow (for headless environments)
+ * - Authorization code + PKCE
+ * - Token refresh
+ * - Credential storage in ~/.claude/credentials
+ */
+
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export class OAuthClient {
+    /**
+     * @param {string} clientId - OAuth client ID
+     * @param {object} [options]
+     * @param {string} [options.authUrl] - authorization endpoint
+     * @param {string} [options.tokenUrl] - token endpoint
+     * @param {string} [options.deviceUrl] - device authorization endpoint
+     * @param {string} [options.credentialsPath] - path to store credentials
+     */
+    constructor(clientId, options = {}) {
+        this.clientId = clientId;
+        this.authUrl = options.authUrl || 'https://console.anthropic.com/oauth/authorize';
+        this.tokenUrl = options.tokenUrl || 'https://console.anthropic.com/oauth/token';
+        this.deviceUrl = options.deviceUrl || 'https://console.anthropic.com/oauth/device';
+        this.credentialsPath = options.credentialsPath ||
+            path.join(os.homedir(), '.claude', 'credentials');
+    }
+
+    /**
+     * Generate a PKCE code verifier and challenge.
+     * @returns {{ verifier: string, challenge: string }}
+     */
+    generatePKCE() {
+        const verifier = crypto.randomBytes(32)
+            .toString('base64url')
+            .replace(/[^a-zA-Z0-9]/g, '')
+            .substring(0, 128);
+
+        const challenge = crypto
+            .createHash('sha256')
+            .update(verifier)
+            .digest('base64url');
+
+        return { verifier, challenge };
+    }
+
+    /**
+     * Get the authorization URL for the PKCE flow.
+     * @param {object} [options]
+     * @param {string} [options.redirectUri] - redirect URI
+     * @param {string} [options.scope] - requested scope
+     * @returns {{ url: string, verifier: string, state: string }}
+     */
+    getAuthorizationUrl(options = {}) {
+        const { verifier, challenge } = this.generatePKCE();
+        const state = crypto.randomBytes(16).toString('hex');
+
+        const params = new URLSearchParams({
+            client_id: this.clientId,
+            response_type: 'code',
+            code_challenge: challenge,
+            code_challenge_method: 'S256',
+            state,
+            redirect_uri: options.redirectUri || 'http://localhost:9876/callback',
+            ...(options.scope && { scope: options.scope }),
+        });
+
+        return {
+            url: `${this.authUrl}?${params.toString()}`,
+            verifier,
+            state,
+        };
+    }
+
+    /**
+     * Start a device code flow (for headless environments).
+     * @returns {Promise<{ device_code: string, user_code: string, verification_uri: string, interval: number, expires_in: number }>}
+     */
+    async startDeviceFlow() {
+        const body = new URLSearchParams({
+            client_id: this.clientId,
+        });
+
+        const res = await fetch(this.deviceUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: body.toString(),
+        });
+
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Device flow failed (${res.status}): ${text}`);
+        }
+
+        return res.json();
+    }
+
+    /**
+     * Exchange an authorization code for tokens (PKCE flow).
+     * @param {string} code - authorization code
+     * @param {string} verifier - PKCE code verifier
+     * @param {string} [redirectUri]
+     * @returns {Promise<{ access_token: string, refresh_token?: string, expires_in: number }>}
+     */
+    async exchangeCode(code, verifier, redirectUri) {
+        const body = new URLSearchParams({
+            grant_type: 'authorization_code',
+            client_id: this.clientId,
+            code,
+            code_verifier: verifier,
+            redirect_uri: redirectUri || 'http://localhost:9876/callback',
+        });
+
+        const res = await fetch(this.tokenUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: body.toString(),
+        });
+
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Token exchange failed (${res.status}): ${text}`);
+        }
+
+        const token = await res.json();
+        this.saveToken(token);
+        return token;
+    }
+
+    /**
+     * Refresh an access token using a refresh token.
+     * @param {string} refreshToken
+     * @returns {Promise<{ access_token: string, refresh_token?: string, expires_in: number }>}
+     */
+    async refreshToken(refreshToken) {
+        const body = new URLSearchParams({
+            grant_type: 'refresh_token',
+            client_id: this.clientId,
+            refresh_token: refreshToken,
+        });
+
+        const res = await fetch(this.tokenUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: body.toString(),
+        });
+
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`Token refresh failed (${res.status}): ${text}`);
+        }
+
+        const token = await res.json();
+        this.saveToken(token);
+        return token;
+    }
+
+    /**
+     * Get stored token from credentials file.
+     * @returns {object|null}
+     */
+    getStoredToken() {
+        try {
+            const raw = fs.readFileSync(this.credentialsPath, 'utf-8');
+            return JSON.parse(raw);
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Save a token to the credentials file.
+     * @param {object} token
+     */
+    saveToken(token) {
+        try {
+            const dir = path.dirname(this.credentialsPath);
+            fs.mkdirSync(dir, { recursive: true });
+
+            const data = {
+                ...token,
+                saved_at: new Date().toISOString(),
+            };
+
+            fs.writeFileSync(this.credentialsPath, JSON.stringify(data, null, 2), { mode: 0o600 });
+        } catch {
+            // Best effort
+        }
+    }
+
+    /**
+     * Delete stored credentials.
+     */
+    clearToken() {
+        try {
+            fs.unlinkSync(this.credentialsPath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Check if the stored token is expired.
+     * @returns {boolean}
+     */
+    isTokenExpired() {
+        const token = this.getStoredToken();
+        if (!token || !token.saved_at || !token.expires_in) return true;
+
+        const savedAt = new Date(token.saved_at).getTime();
+        const expiresAt = savedAt + (token.expires_in * 1000);
+        return Date.now() >= expiresAt;
+    }
+}

package/src/config/cli-args.mjs

@@ -0,0 +1,139 @@
+/**
+ * CLI Argument Parser — supports all major Claude Code flags.
+ *
+ * Flags:
+ * --model, -m          Model to use
+ * --permission-mode    Permission mode
+ * --print, -p          Print mode (non-interactive prompt)
+ * --output-format      json, text, stream-json
+ * --system-prompt      Override system prompt
+ * --add-dir            Additional CLAUDE.md directories
+ * --max-turns          Maximum conversation turns
+ * --allowedTools       Comma-separated allowed tools
+ * --disallowedTools    Comma-separated denied tools
+ * --verbose, -v        Verbose output
+ * --debug, -d          Debug mode
+ * --version            Show version
+ * --help, -h           Show help
+ */
+
+export function parseArgs(args) {
+    const result = {
+        prompt: null,
+        model: null,
+        permissionMode: null,
+        outputFormat: null,
+        systemPrompt: null,
+        addDirs: [],
+        maxTurns: null,
+        allowedTools: null,
+        disallowedTools: null,
+        verbose: false,
+        debug: false,
+        showVersion: false,
+        showHelp: false,
+    };
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+
+        switch (arg) {
+            case '--model':
+            case '-m':
+                result.model = args[++i];
+                break;
+
+            case '--permission-mode':
+                result.permissionMode = args[++i];
+                break;
+
+            case '--print':
+            case '-p':
+                result.prompt = args[++i];
+                break;
+
+            case '--output-format':
+                result.outputFormat = args[++i];
+                break;
+
+            case '--system-prompt':
+                result.systemPrompt = args[++i];
+                break;
+
+            case '--add-dir':
+                result.addDirs.push(args[++i]);
+                break;
+
+            case '--max-turns':
+                result.maxTurns = parseInt(args[++i], 10);
+                break;
+
+            case '--allowedTools':
+                result.allowedTools = args[++i]?.split(',').map(s => s.trim());
+                break;
+
+            case '--disallowedTools':
+                result.disallowedTools = args[++i]?.split(',').map(s => s.trim());
+                break;
+
+            case '--verbose':
+            case '-v':
+                result.verbose = true;
+                break;
+
+            case '--debug':
+            case '-d':
+                result.debug = true;
+                break;
+
+            case '--version':
+                result.showVersion = true;
+                break;
+
+            case '--help':
+            case '-h':
+                result.showHelp = true;
+                break;
+
+            default:
+                // Bare argument becomes prompt
+                if (!arg.startsWith('-')) {
+                    result.prompt = arg;
+                }
+                break;
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Print usage/help text.
+ * @returns {string}
+ */
+export function getUsageText() {
+    return `
+Usage: occ [options] [prompt]
+
+Options:
+  --model, -m <model>        Model to use (default: claude-sonnet-4-6)
+  --permission-mode <mode>   Permission mode (bypassPermissions, acceptEdits, plan, auto, dontAsk)
+  --print, -p <prompt>       Non-interactive mode: run prompt and exit
+  --output-format <fmt>      Output format: text, json, stream-json
+  --system-prompt <text>     Override system prompt
+  --add-dir <dir>            Additional directory to search for CLAUDE.md
+  --max-turns <n>            Maximum conversation turns
+  --allowedTools <tools>     Comma-separated list of allowed tools
+  --disallowedTools <tools>  Comma-separated list of denied tools
+  --verbose, -v              Verbose output
+  --debug, -d                Debug mode
+  --version                  Show version
+  --help, -h                 Show this help
+
+Examples:
+  occ                        Start interactive REPL
+  occ -p "What is 2+2?"     Run prompt and exit
+  occ -m claude-haiku-4-5    Use Haiku model
+  occ --debug -p "Fix bug"  Debug mode with prompt
+`.trim();
+}