osborn 0.1.1 → 0.1.6

package/dist/claude-handler.d.ts

@@ -3,8 +3,10 @@ import { EventEmitter } from 'events';
 interface ClaudeHandlerOptions {
     workingDirectory?: string;
     allowedTools?: string[];
-    permissionMode?: 'default' | 'acceptEdits' | 'bypassPermissions';
+    permissionMode?: 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan';
     mcpServers?: Record<string, McpServerConfig>;
+    requireAllPermissions?: boolean;
+    agentRole?: 'plan' | 'execute';
 }
 export type { McpServerConfig };
 export interface PermissionRequestEvent {
@@ -28,10 +30,25 @@ export declare class ClaudeHandler extends EventEmitter {
     private abortController;
     private sessionId;
     private pendingPermission;
-    private dangerousTools;
+    private toolStartTimes;
     private alwaysAllowedTools;
     private static readonly ALL_TOOLS;
+    private static readonly PLAN_TOOLS;
+    private static readonly EXECUTE_TOOLS;
+    private agentRole;
     constructor(options?: ClaudeHandlerOptions);
+    /**
+     * Get the agent's role
+     */
+    getRole(): 'plan' | 'execute';
+    /**
+     * Check if this is a plan-mode agent
+     */
+    isPlanMode(): boolean;
+    /**
+     * Generate human-readable description for a tool call
+     */
+    private getToolDescription;
     run(prompt: string): Promise<string>;
     /**
      * Request permission from user via event emission

package/dist/claude-handler.js

@@ -1,13 +1,41 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { EventEmitter } from 'events';
+// Log tool calls to terminal (async, non-blocking)
+function logToolCall(entry) {
+    // Use setImmediate to avoid blocking the main execution
+    setImmediate(() => {
+        const time = new Date().toLocaleTimeString();
+        const inputStr = JSON.stringify(entry.input).substring(0, 100);
+        switch (entry.status) {
+            case 'started':
+                console.log(`\n🔧 [${time}] TOOL START: ${entry.toolName}`);
+                console.log(`   📥 Input: ${inputStr}${inputStr.length >= 100 ? '...' : ''}`);
+                break;
+            case 'completed':
+                const duration = entry.duration ? `${entry.duration}ms` : '?';
+                console.log(`✅ [${time}] TOOL DONE: ${entry.toolName} (${duration})`);
+                if (entry.output) {
+                    const outStr = typeof entry.output === 'string'
+                        ? entry.output.substring(0, 150)
+                        : JSON.stringify(entry.output).substring(0, 150);
+                    console.log(`   📤 Output: ${outStr}${outStr.length >= 150 ? '...' : ''}`);
+                }
+                break;
+            case 'blocked':
+                console.log(`❌ [${time}] TOOL BLOCKED: ${entry.toolName}`);
+                console.log(`   ⛔ Reason: ${entry.error || 'User denied'}`);
+                break;
+        }
+    });
+}
 export class ClaudeHandler extends EventEmitter {
     options;
     abortController = null;
     sessionId = null;
     pendingPermission = null;
-    // Tools that require permission
-    dangerousTools = ['Bash', 'Write', 'Edit'];
-    // Tools the user has permanently approved
+    // Track tool call start times for duration logging
+    toolStartTimes = new Map();
+    // Tools the user has permanently approved (for this session)
     alwaysAllowedTools = new Set();
     // All available Claude Agent SDK tools
     static ALL_TOOLS = [
@@ -26,19 +54,94 @@ export class ClaudeHandler extends EventEmitter {
         // LSP (Language Server Protocol)
         'LSP',
     ];
+    // Plan mode tools - read-only, research, context gathering
+    static PLAN_TOOLS = [
+        'Read', // View file contents
+        'Glob', // File pattern matching
+        'Grep', // Content searching
+        'Bash', // Read-only bash (ls, git status, git log, etc.)
+        'Task', // Research agents
+        'WebFetch', // Web content analysis
+        'WebSearch', // Internet searching
+        'LSP', // Code intelligence (go to definition, references)
+    ];
+    // Execute mode tools - full access
+    static EXECUTE_TOOLS = ClaudeHandler.ALL_TOOLS;
+    agentRole;
     constructor(options = {}) {
         super();
+        // Set agent role
+        this.agentRole = options.agentRole || (options.permissionMode === 'plan' ? 'plan' : 'execute');
+        // For plan mode, restrict to read-only tools
+        const isPlanMode = options.permissionMode === 'plan';
+        const defaultTools = isPlanMode ? ClaudeHandler.PLAN_TOOLS : ClaudeHandler.ALL_TOOLS;
         this.options = {
             workingDirectory: options.workingDirectory || process.cwd(),
-            allowedTools: options.allowedTools || ClaudeHandler.ALL_TOOLS,
-            permissionMode: options.permissionMode || 'default',
+            allowedTools: options.allowedTools || defaultTools,
+            // Plan mode uses 'default' permission mode but with restricted tools
+            permissionMode: isPlanMode ? 'default' : (options.permissionMode || 'default'),
             mcpServers: options.mcpServers,
+            // Plan mode doesn't require permissions (read-only is safe)
+            // Execute mode requires permissions for safety
+            requireAllPermissions: isPlanMode ? false : (options.requireAllPermissions ?? true),
         };
+        const roleEmoji = this.agentRole === 'plan' ? '📋' : '🔨';
+        console.log(`${roleEmoji} Agent role: ${this.agentRole.toUpperCase()}`);
         console.log(`🔧 Allowed tools: ${this.options.allowedTools?.join(', ')}`);
+        console.log(`🔐 Require permissions: ${this.options.requireAllPermissions}`);
         if (this.options.mcpServers) {
             console.log(`🔌 MCP servers: ${Object.keys(this.options.mcpServers).join(', ')}`);
         }
     }
+    /**
+     * Get the agent's role
+     */
+    getRole() {
+        return this.agentRole;
+    }
+    /**
+     * Check if this is a plan-mode agent
+     */
+    isPlanMode() {
+        return this.agentRole === 'plan';
+    }
+    /**
+     * Generate human-readable description for a tool call
+     */
+    getToolDescription(toolName, toolInput) {
+        switch (toolName) {
+            case 'Bash':
+                return `Run command: ${toolInput.command || 'unknown command'}`;
+            case 'Write':
+                return `Create file: ${toolInput.file_path || 'unknown file'}`;
+            case 'Edit':
+                return `Edit file: ${toolInput.file_path || 'unknown file'}`;
+            case 'MultiEdit':
+                return `Multi-edit: ${toolInput.edits?.length || 0} edits`;
+            case 'Read':
+                return `Read file: ${toolInput.file_path || 'unknown file'}`;
+            case 'Glob':
+                return `Find files: ${toolInput.pattern || 'unknown pattern'}`;
+            case 'Grep':
+                return `Search content: "${toolInput.pattern || 'unknown'}" in ${toolInput.path || 'cwd'}`;
+            case 'WebSearch':
+                return `🌐 Web search: "${toolInput.query || 'unknown query'}"`;
+            case 'WebFetch':
+                return `🌐 Fetch URL: ${toolInput.url || 'unknown url'}`;
+            case 'NotebookEdit':
+                return `Edit notebook: ${toolInput.notebook_path || 'unknown'}`;
+            case 'Task':
+                return `Spawn task: ${toolInput.description || 'unknown task'}`;
+            case 'TodoWrite':
+                return `Update todos: ${toolInput.todos?.length || 0} items`;
+            case 'LSP':
+                return `LSP ${toolInput.operation || 'query'}: ${toolInput.filePath || 'unknown'}`;
+            default:
+                // For MCP tools, show the tool name and first few input keys
+                const inputKeys = Object.keys(toolInput || {}).slice(0, 3).join(', ');
+                return `${toolName}: ${inputKeys || 'no params'}`;
+        }
+    }
     async run(prompt) {
         this.abortController = new AbortController();
         let fullResponse = '';
@@ -68,10 +171,26 @@ export class ClaudeHandler extends EventEmitter {
                             hooks: [async (input, toolUseId) => {
                                     const toolName = input?.tool_name || 'unknown';
                                     const toolInput = input?.tool_input || {};
+                                    const id = toolUseId || `tool-${Date.now()}`;
+                                    const description = this.getToolDescription(toolName, toolInput);
+                                    // Record start time for duration tracking
+                                    this.toolStartTimes.set(id, Date.now());
+                                    // Log tool start (background, non-blocking)
+                                    logToolCall({
+                                        timestamp: new Date().toISOString(),
+                                        toolName,
+                                        toolUseId: id,
+                                        input: toolInput,
+                                        status: 'started',
+                                    });
                                     console.log(`🔧 Tool: ${toolName}`);
-                                    this.emit('tool_use', { name: toolName, input: toolInput });
+                                    console.log(`   📋 ${description}`);
+                                    this.emit('tool_use', { name: toolName, input: toolInput, description });
                                     // Check if this tool needs permission
-                                    if (this.dangerousTools.includes(toolName) && this.options.permissionMode === 'default') {
+                                    // In default mode with requireAllPermissions, ALL tools need permission
+                                    const needsPermission = this.options.permissionMode === 'default' &&
+                                        this.options.requireAllPermissions;
+                                    if (needsPermission) {
                                         // Skip if user has permanently approved this tool
                                         if (this.alwaysAllowedTools.has(toolName)) {
                                             console.log(`✅ Auto-approved (always allow): ${toolName}`);
@@ -79,9 +198,18 @@ export class ClaudeHandler extends EventEmitter {
                                         else {
                                             console.log(`⚠️ Permission required for: ${toolName}`);
                                             // Emit permission request and wait for approval
-                                            const response = await this.requestPermission(toolName, toolInput, toolUseId || 'unknown');
+                                            const response = await this.requestPermission(toolName, toolInput, id, description);
                                             if (response === 'deny') {
                                                 console.log(`❌ Permission denied for: ${toolName}`);
+                                                // Log blocked tool
+                                                logToolCall({
+                                                    timestamp: new Date().toISOString(),
+                                                    toolName,
+                                                    toolUseId: id,
+                                                    input: toolInput,
+                                                    status: 'blocked',
+                                                    error: 'User denied permission',
+                                                });
                                                 return {
                                                     decision: 'block',
                                                     reason: 'User denied permission for this operation'
@@ -101,10 +229,26 @@ export class ClaudeHandler extends EventEmitter {
                         }],
                     PostToolUse: [{
                             matcher: '.*',
-                            hooks: [async (input) => {
+                            hooks: [async (input, toolUseId) => {
                                     const toolName = input?.tool_name || 'unknown';
-                                    console.log(`✅ Completed: ${toolName}`);
-                                    this.emit('tool_result', { name: toolName });
+                                    const toolOutput = input?.tool_output || input?.output;
+                                    const id = toolUseId || 'unknown';
+                                    // Calculate duration
+                                    const startTime = this.toolStartTimes.get(id);
+                                    const duration = startTime ? Date.now() - startTime : undefined;
+                                    this.toolStartTimes.delete(id);
+                                    // Log tool completion (background, non-blocking)
+                                    logToolCall({
+                                        timestamp: new Date().toISOString(),
+                                        toolName,
+                                        toolUseId: id,
+                                        input: input?.tool_input || {},
+                                        status: 'completed',
+                                        output: toolOutput ? (typeof toolOutput === 'string' ? toolOutput.substring(0, 500) : 'object') : undefined,
+                                        duration,
+                                    });
+                                    console.log(`✅ Completed: ${toolName} (${duration ? duration + 'ms' : 'unknown duration'})`);
+                                    this.emit('tool_result', { name: toolName, output: toolOutput, duration });
                                     return {};
                                 }]
                         }]
@@ -168,24 +312,15 @@ export class ClaudeHandler extends EventEmitter {
      * Request permission from user via event emission
      * Returns a promise that resolves when user responds with allow/deny/always_allow
      */
-    requestPermission(toolName, toolInput, toolUseId) {
+    requestPermission(toolName, toolInput, toolUseId, description) {
         return new Promise((resolve) => {
-            // Format the permission request message
-            let description = '';
-            if (toolName === 'Bash') {
-                description = `Run command: ${toolInput.command || 'unknown command'}`;
-            }
-            else if (toolName === 'Write') {
-                description = `Create file: ${toolInput.file_path || 'unknown file'}`;
-            }
-            else if (toolName === 'Edit') {
-                description = `Edit file: ${toolInput.file_path || 'unknown file'}`;
-            }
+            // Use provided description or generate one
+            const desc = description || this.getToolDescription(toolName, toolInput);
             this.pendingPermission = { toolName, toolInput, toolUseId, resolve: resolve };
             // Emit event for voice handler to pick up
             this.emit('permission_request', {
                 toolName,
-                description,
+                description: desc,
                 toolInput,
                 toolUseId,
             });
@@ -240,16 +375,7 @@ export class ClaudeHandler extends EventEmitter {
         if (!this.pendingPermission)
             return null;
         const { toolName, toolInput, toolUseId } = this.pendingPermission;
-        let description = '';
-        if (toolName === 'Bash') {
-            description = `Run command: ${toolInput.command || 'unknown command'}`;
-        }
-        else if (toolName === 'Write') {
-            description = `Create file: ${toolInput.file_path || 'unknown file'}`;
-        }
-        else if (toolName === 'Edit') {
-            description = `Edit file: ${toolInput.file_path || 'unknown file'}`;
-        }
+        const description = this.getToolDescription(toolName, toolInput);
         return { toolName, description, toolInput, toolUseId };
     }
     /**

package/dist/config.d.ts

@@ -0,0 +1,33 @@
+import type { McpServerConfig } from './claude-handler.js';
+export interface OsbornConfig {
+    workingDirectory?: string;
+    mcpServers?: Record<string, McpServerConfigYaml>;
+    defaultProvider?: 'openai' | 'gemini';
+    defaultCodingAgent?: 'claude' | 'codex';
+}
+interface McpServerConfigYaml {
+    enabled?: boolean;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    transport?: 'stdio' | 'sse' | 'http';
+}
+/**
+ * Load configuration from ~/.osborn/config.yaml
+ * Creates default config if it doesn't exist
+ */
+export declare function loadConfig(): OsbornConfig;
+/**
+ * Get enabled MCP servers in the format expected by Claude Agent SDK
+ */
+export declare function getMcpServers(config: OsbornConfig): Record<string, McpServerConfig>;
+/**
+ * Get list of enabled MCP server names (for display)
+ */
+export declare function getEnabledMcpServerNames(config: OsbornConfig): string[];
+/**
+ * Save config to file
+ */
+export declare function saveConfig(config: OsbornConfig): void;
+export {};

package/dist/config.js

@@ -0,0 +1,127 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { parse, stringify } from 'yaml';
+// Config file paths
+const CONFIG_DIR = join(homedir(), '.osborn');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.yaml');
+// Default config template
+const DEFAULT_CONFIG = {
+    workingDirectory: process.cwd(),
+    defaultProvider: 'openai',
+    defaultCodingAgent: 'claude',
+    mcpServers: {
+    // Example MCP servers (disabled by default)
+    // github: {
+    //   enabled: true,
+    //   command: 'npx',
+    //   args: ['@modelcontextprotocol/server-github'],
+    //   env: {
+    //     GITHUB_TOKEN: '${GITHUB_TOKEN}',
+    //   },
+    // },
+    // filesystem: {
+    //   enabled: true,
+    //   command: 'npx',
+    //   args: ['@modelcontextprotocol/server-filesystem', '/allowed/path'],
+    // },
+    },
+};
+/**
+ * Resolve environment variable references in a string
+ * e.g., "${GITHUB_TOKEN}" becomes the value of process.env.GITHUB_TOKEN
+ */
+function resolveEnvVar(value) {
+    return value.replace(/\$\{([^}]+)\}/g, (_, envVar) => {
+        return process.env[envVar] || '';
+    });
+}
+/**
+ * Resolve environment variables in an object of strings
+ */
+function resolveEnvVars(env) {
+    if (!env)
+        return undefined;
+    const resolved = {};
+    for (const [key, value] of Object.entries(env)) {
+        resolved[key] = resolveEnvVar(value);
+    }
+    return resolved;
+}
+/**
+ * Load configuration from ~/.osborn/config.yaml
+ * Creates default config if it doesn't exist
+ */
+export function loadConfig() {
+    // Ensure config directory exists
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+        console.log(`📁 Created config directory: ${CONFIG_DIR}`);
+    }
+    // Create default config if it doesn't exist
+    if (!existsSync(CONFIG_FILE)) {
+        const defaultYaml = stringify(DEFAULT_CONFIG);
+        writeFileSync(CONFIG_FILE, defaultYaml, 'utf-8');
+        console.log(`📝 Created default config: ${CONFIG_FILE}`);
+        return DEFAULT_CONFIG;
+    }
+    // Load and parse config
+    try {
+        const content = readFileSync(CONFIG_FILE, 'utf-8');
+        const config = parse(content);
+        console.log(`📋 Loaded config from: ${CONFIG_FILE}`);
+        return config;
+    }
+    catch (err) {
+        console.error(`❌ Failed to load config: ${err.message}`);
+        return DEFAULT_CONFIG;
+    }
+}
+/**
+ * Get enabled MCP servers in the format expected by Claude Agent SDK
+ */
+export function getMcpServers(config) {
+    const servers = {};
+    if (!config.mcpServers) {
+        return servers;
+    }
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        // Skip disabled servers
+        if (serverConfig.enabled === false) {
+            continue;
+        }
+        // Build the McpServerConfig for Claude Agent SDK
+        if (serverConfig.command) {
+            servers[name] = {
+                command: serverConfig.command,
+                args: serverConfig.args,
+                env: resolveEnvVars(serverConfig.env),
+            };
+        }
+        // Note: SSE/HTTP transport may require different handling
+    }
+    return servers;
+}
+/**
+ * Get list of enabled MCP server names (for display)
+ */
+export function getEnabledMcpServerNames(config) {
+    if (!config.mcpServers)
+        return [];
+    return Object.entries(config.mcpServers)
+        .filter(([_, serverConfig]) => serverConfig.enabled !== false && serverConfig.command)
+        .map(([name, _]) => name);
+}
+/**
+ * Save config to file
+ */
+export function saveConfig(config) {
+    try {
+        const yaml = stringify(config);
+        writeFileSync(CONFIG_FILE, yaml, 'utf-8');
+        console.log(`💾 Saved config to: ${CONFIG_FILE}`);
+    }
+    catch (err) {
+        console.error(`❌ Failed to save config: ${err.message}`);
+    }
+}

package/dist/index.d.ts

@@ -1,3 +1 @@
 import 'dotenv/config';
-declare const _default: import("@livekit/agents").Agent;
-export default _default;