nova-terminal-assistant 0.1.0

package/src/core/tools/impl/TaskTool.ts

@@ -0,0 +1,207 @@
+// ============================================================================
+// Task Tool - Launch sub-agents for parallel task execution
+// ============================================================================
+
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+import { ToolError } from '../../types/errors.js';
+import { AgentLoop } from '../../session/AgentLoop.js';
+import { SessionManager } from '../../session/SessionManager.js';
+import { ToolRegistry } from '../../tools/ToolRegistry.js';
+import { ModelClient } from '../../model/ModelClient.js';
+import { buildSystemPrompt } from '../../context/defaultSystemPrompt.js';
+import type { ContextCompressor } from '../../context/ContextCompressor.js';
+
+interface TaskInput {
+  description: string;
+  prompt: string;
+  subagentType: 'code-explorer' | 'research' | 'executor';
+  maxTurns?: number;
+  mode?: 'acceptEdits' | 'bypassPermissions' | 'default' | 'plan';
+  name?: string;
+  teamName?: string;
+}
+
+/**
+ * Task handler - launches a sub-agent to perform a specific task
+ * 
+ * This enables parallel task execution and specialized agent behaviors:
+ * - code-explorer: Analyzes codebases and provides insights
+ * - research: Gathers information from web and documentation
+ * - executor: Performs actions and executes commands
+ */
+export const taskHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  // Validate required fields
+  const { description, prompt, subagentType, maxTurns = 10, mode = 'default', name } = input.params as Record<string, unknown>;
+  
+  if (typeof description !== 'string' || typeof prompt !== 'string' || typeof subagentType !== 'string') {
+    throw new ToolError('Task requires description, prompt, and subagentType parameters to be strings', 'task');
+  }
+  
+  if (!description || !prompt || !subagentType) {
+    throw new ToolError('Task requires description, prompt, and subagentType parameters', 'task');
+  }
+  
+  const params: TaskInput = {
+    description,
+    prompt,
+    subagentType: subagentType as TaskInput['subagentType'],
+    maxTurns: typeof maxTurns === 'number' ? maxTurns : 10,
+    mode: typeof mode === 'string' ? mode as TaskInput['mode'] : 'default',
+    name: typeof name === 'string' ? name : undefined,
+  };
+
+  const sessionManager = input.context.sessionManager as SessionManager;
+  const toolRegistry = input.context.toolRegistry as ToolRegistry;
+  const modelClient = input.context.modelClient as ModelClient;
+  const contextCompressor = input.context.contextCompressor as ContextCompressor;
+
+  if (!sessionManager || !toolRegistry || !modelClient) {
+    throw new ToolError('Task tool requires sessionManager, toolRegistry, and modelClient in context', 'task');
+  }
+
+  // Create a new session for the sub-agent
+  const subSession = sessionManager.create({
+    workingDirectory: input.context.workingDirectory,
+    model: modelClient.getModel(),
+    streaming: false,
+    parentSessionId: input.context.sessionId,
+  });
+
+  // Configure approval mode based on task mode
+  let approvalMode = input.context.approvalMode || 'plan';
+  if (mode === 'acceptEdits') {
+    approvalMode = 'plan';
+  } else if (mode === 'bypassPermissions') {
+    approvalMode = 'yolo';
+  }
+
+  // Build system prompt for sub-agent
+  const subSystemPrompt = buildSystemPrompt({
+    workingDirectory: input.context.workingDirectory,
+    model: modelClient.getModel(),
+    approvalMode,
+  });
+
+  // Add sub-agent specialization to system prompt
+  const specializations: Record<string, string> = {
+    'code-explorer': `You are a Code Explorer agent. Your specialty is analyzing codebases, understanding architecture, identifying patterns, and providing code insights. 
+Focus on:
+- Code structure and organization
+- Design patterns and architecture
+- Potential issues and improvements
+- Dependencies and relationships
+
+Be thorough in your analysis and provide actionable insights.`,
+    
+    'research': `You are a Research agent. Your specialty is gathering information, investigating problems, and finding solutions.
+Focus on:
+- Searching for relevant documentation and examples
+- Investigating error messages and issues
+- Finding best practices and patterns
+- Gathering context and background information
+
+Be comprehensive in your research and cite sources when possible.`,
+    
+    'executor': `You are an Executor agent. Your specialty is performing tasks, running commands, and making changes.
+Focus on:
+- Executing commands and scripts
+- Modifying files and code
+- Running tests and builds
+- Implementing solutions
+
+Be careful and precise in your actions, following best practices.`
+  };
+
+  const specializedSystemPrompt = subSystemPrompt + '\n\n' + specializations[subagentType];
+
+  // Create agent loop for sub-agent
+  const agentLoop = new AgentLoop({
+    modelClient,
+    sessionManager,
+    toolRegistry,
+    systemPrompt: specializedSystemPrompt,
+    contextCompressor,
+    maxContextTokens: input.context.maxTokens * 8 || 128000,
+    onApprovalRequired: input.context.onApprovalRequired,
+  });
+
+  // Run the sub-agent
+  const result = await agentLoop.run(subSession.id, prompt);
+
+  // Get all messages from the sub-session
+  const messages = sessionManager.getMessages(subSession.id);
+  const assistantMessages = messages.filter(m => m.role === 'assistant');
+  
+  // Extract the final response
+  let finalResponse = '';
+  if (assistantMessages.length > 0) {
+    const lastMessage = assistantMessages[assistantMessages.length - 1];
+    const textBlocks = lastMessage.content.filter(block => block.type === 'text');
+    finalResponse = textBlocks.map(block => (block as any).text).join('\n\n');
+  }
+
+  // Clean up sub-session
+  sessionManager.delete(subSession.id);
+
+  // Format the result
+  const output = `
+### 🤖 Sub-agent Task Complete
+
+**Task**: ${description}  
+**Type**: ${subagentType}  
+**Agent**: ${name || 'Unnamed'}  
+**Turns**: ${result.turnsCompleted}  
+**Tokens**: ${result.totalInputTokens + result.totalOutputTokens}
+
+---
+
+${finalResponse}
+
+---
+
+**Status**: ✅ Completed successfully
+  `.trim();
+
+  return { content: output };
+};
+
+export const taskSchema = {
+  type: 'object' as const,
+  properties: {
+    description: {
+      type: 'string',
+      description: 'Brief description of the task (3-5 words)',
+    },
+    prompt: {
+      type: 'string',
+      description: 'Detailed task description for the sub-agent',
+    },
+    subagentType: {
+      type: 'string',
+      description: 'Type of sub-agent to spawn',
+      enum: ['code-explorer', 'research', 'executor'],
+      default: 'research',
+    },
+    maxTurns: {
+      type: 'number',
+      description: 'Maximum number of agentic turns',
+      default: 10,
+    },
+    mode: {
+      type: 'string',
+      description: 'Permission mode for the sub-agent',
+      enum: ['acceptEdits', 'bypassPermissions', 'default', 'plan'],
+      default: 'default',
+    },
+    name: {
+      type: 'string',
+      description: 'Name for the sub-agent (enables team mode)',
+    },
+    teamName: {
+      type: 'string',
+      description: 'Team to join (enables team mode)',
+    },
+  },
+  required: ['description', 'prompt', 'subagentType'],
+  additionalProperties: false,
+};

package/src/core/tools/impl/TodoTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TodoTool.d.ts","sourceRoot":"","sources":["TodoTool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAuC,MAAM,sBAAsB,CAAC;AA6B7F,eAAO,MAAM,WAAW,EAAE,WA2DzB,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BtB,CAAC"}

package/src/core/tools/impl/TodoTool.ts

@@ -0,0 +1,122 @@
+// ============================================================================
+// Todo Tool - Task tracking and progress display
+// ============================================================================
+
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+import { ToolError } from '../../types/errors.js';
+
+interface TodoItem {
+  id: string;
+  content: string;
+  status: 'pending' | 'in_progress' | 'completed';
+}
+
+/** In-memory todo storage per session */
+const sessionTodos = new Map<string, TodoItem[]>();
+
+function getTodos(sessionId: string): TodoItem[] {
+  if (!sessionTodos.has(sessionId)) {
+    sessionTodos.set(sessionId, []);
+  }
+  return sessionTodos.get(sessionId)!;
+}
+
+function renderTodos(todos: TodoItem[]): string {
+  if (todos.length === 0) return 'No tasks tracked.';
+  const statusIcons: Record<string, string> = {
+    pending: '○',
+    in_progress: '◉',
+    completed: '●',
+  };
+  return todos.map((t) => `${statusIcons[t.status]} [${t.status.padEnd(12)}] ${t.content}`).join('\n');
+}
+
+export const todoHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const { action, items, id, content, status } = input.params as {
+    action?: string;
+    items?: string;
+    id?: string;
+    content?: string;
+    status?: string;
+  };
+  const sessionId = input.context.sessionId;
+  const todos = getTodos(sessionId);
+
+  switch (action) {
+    case 'list': {
+      return { content: renderTodos(todos) };
+    }
+
+    case 'create': {
+      if (!items) {
+        throw new ToolError('Missing "items" parameter. Provide a JSON array of task strings.', 'todo');
+      }
+      let parsed: unknown[];
+      try {
+        parsed = JSON.parse(typeof items === 'string' ? items : JSON.stringify(items));
+      } catch {
+        parsed = [String(items)];
+      }
+      for (const item of parsed) {
+        todos.push({ id: `t${todos.length + 1}`, content: String(item), status: 'pending' });
+      }
+      return { content: `Added ${parsed.length} task(s).\n${renderTodos(todos)}` };
+    }
+
+    case 'update': {
+      if (!id || !status) {
+        throw new ToolError('Missing "id" or "status" parameter.', 'todo');
+      }
+      const target = todos.find((t) => t.id === id || t.id === `t${id}`);
+      if (!target) {
+        throw new ToolError(`Task "${id}" not found.`, 'todo');
+      }
+      const validStatuses = ['pending', 'in_progress', 'completed'];
+      if (!validStatuses.includes(status)) {
+        throw new ToolError(`Invalid status "${status}". Use: ${validStatuses.join(', ')}`, 'todo');
+      }
+      if (content) target.content = content;
+      target.status = status as TodoItem['status'];
+      return { content: renderTodos(todos) };
+    }
+
+    case 'clear': {
+      todos.length = 0;
+      return { content: 'All tasks cleared.' };
+    }
+
+    default: {
+      // If no action, show current state
+      return { content: renderTodos(todos) };
+    }
+  }
+};
+
+export const todoSchema = {
+  type: 'object' as const,
+  properties: {
+    action: {
+      type: 'string',
+      enum: ['list', 'create', 'update', 'clear'],
+      description: 'Action to perform: list (show tasks), create (add tasks), update (change status), clear (remove all)',
+    },
+    items: {
+      type: 'string',
+      description: 'JSON array of task strings to create (for action=create). Example: \'["Task 1", "Task 2"]\'',
+    },
+    id: {
+      type: 'string',
+      description: 'Task ID to update (for action=update)',
+    },
+    content: {
+      type: 'string',
+      description: 'New content for the task (for action=update)',
+    },
+    status: {
+      type: 'string',
+      enum: ['pending', 'in_progress', 'completed'],
+      description: 'New status for the task (for action=update)',
+    },
+  },
+  additionalProperties: false,
+};

package/src/core/tools/impl/WebFetchTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebFetchTool.d.ts","sourceRoot":"","sources":["WebFetchTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuC,MAAM,sBAAsB,CAAC;AAG7F,eAAO,MAAM,eAAe,EAAE,WA+E7B,CAAC"}

package/src/core/tools/impl/WebFetchTool.ts

@@ -0,0 +1,103 @@
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+import { ToolError, TimeoutError } from '../../types/errors.js';
+
+export const webFetchHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const {
+    url,
+    method = 'GET',
+    headers: extraHeaders,
+    body,
+    timeout = 15000,
+    followRedirects = true,
+    maxLength = 50000,
+  } = input.params as {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeout?: number;
+    followRedirects?: boolean;
+    maxLength?: number;
+  };
+
+  try {
+    // Basic URL validation
+    const parsedUrl = new URL(url);
+    if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+      throw new Error(`Unsupported protocol: ${parsedUrl.protocol}`);
+    }
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+
+    const response = await fetch(url, {
+      method,
+      headers: {
+        'User-Agent': 'NovaCLI/0.1.0 (Research Agent)',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,text/markdown;q=0.9,*/*;q=0.8',
+        ...extraHeaders,
+      },
+      body: method !== 'GET' ? body : undefined,
+      signal: controller.signal,
+      redirect: followRedirects ? 'follow' : 'manual',
+    });
+
+    clearTimeout(timer);
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const contentType = response.headers.get('content-type') || '';
+    let content = await response.text();
+
+    // Truncate if too long
+    if (content.length > maxLength) {
+      content = content.slice(0, maxLength) + `\n\n[Content truncated: showing ${maxLength} of ${content.length} characters]`;
+    }
+
+    // Basic HTML to text conversion
+    if (contentType.includes('text/html')) {
+      content = htmlToText(content);
+    }
+
+    return {
+      content,
+      metadata: {
+        url,
+        status: response.status,
+        contentType,
+        contentLength: content.length,
+        finalUrl: response.url,
+      },
+    };
+  } catch (err) {
+    if (err instanceof DOMException && err.name === 'AbortError') {
+      throw new TimeoutError(`Fetch timed out after ${timeout}ms`, timeout);
+    }
+    if (err instanceof TypeError && (err as Error).message.includes('URL')) {
+      throw new ToolError(`Invalid URL: ${url}`, 'web_fetch');
+    }
+    throw new ToolError(`Failed to fetch URL: ${(err as Error).message}`, 'web_fetch');
+  }
+};
+
+/** Basic HTML to text converter */
+function htmlToText(html: string): string {
+  return html
+    // Remove scripts and styles
+    .replace(/<script[\s\S]*?<\/script>/gi, '')
+    .replace(/<style[\s\S]*?<\/style>/gi, '')
+    // Remove HTML tags
+    .replace(/<[^>]+>/g, ' ')
+    // Decode HTML entities
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&nbsp;/g, ' ')
+    // Collapse whitespace
+    .replace(/\s+/g, ' ')
+    .trim();
+}

package/src/core/tools/impl/WebSearchTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSearchTool.d.ts","sourceRoot":"","sources":["WebSearchTool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAuC,MAAM,sBAAsB,CAAC;AAG7F,eAAO,MAAM,gBAAgB,EAAE,WAqF9B,CAAC"}

package/src/core/tools/impl/WebSearchTool.ts

@@ -0,0 +1,89 @@
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+import { ToolError } from '../../types/errors.js';
+
+export const webSearchHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const { query, maxResults = 10, language, region, safeSearch = true, freshness } = input.params as {
+    query: string;
+    maxResults?: number;
+    language?: string;
+    region?: string;
+    safeSearch?: boolean;
+    freshness?: string;
+  };
+
+  // This is a placeholder implementation. In production, integrate with a search API
+  // such as Google Custom Search, Bing Web Search, or Serper API.
+  
+  const apiKey = process.env.NOVA_SEARCH_API_KEY || process.env.SERPER_API_KEY;
+  
+  if (!apiKey) {
+    // Fallback: provide a helpful message about configuration
+    return {
+      content: `[Web Search Placeholder]\n\nQuery: ${query}\n\nTo enable web search, configure one of:\n- NOVA_SEARCH_API_KEY: Set to a Serper.dev API key\n- SERPER_API_KEY: Alternative Serper key\n\nGet a Serper API key at: https://serper.dev/\n\nConfiguration can be set in:\n- Environment variables\n- ~/.nova/config.yaml (search.apiKey)\n- Project .nova/config.yaml`,
+      metadata: { query, configured: false },
+    };
+  }
+
+  try {
+    // Serper.dev API integration
+    const response = await fetch('https://google.serper.dev/search', {
+      method: 'POST',
+      headers: {
+        'X-API-KEY': apiKey,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        q: query,
+        num: maxResults,
+        gl: region,
+        hl: language,
+        safe: safeSearch ? 'active' : 'off',
+        tbs: freshness ? `qdr:${freshness}` : undefined,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Search API returned ${response.status}: ${response.statusText}`);
+    }
+
+    const data = await response.json() as Record<string, unknown>;
+    const organic = (data.organic || []) as Array<{
+      title: string;
+      link: string;
+      snippet: string;
+      position: number;
+    }>;
+
+    if (organic.length === 0) {
+      return {
+        content: `No results found for: "${query}"`,
+        metadata: { query, count: 0 },
+      };
+    }
+
+    const results = organic
+      .map((r, i) => `${i + 1}. ${r.title}\n   ${r.link}\n   ${r.snippet}`)
+      .join('\n\n');
+
+    const knowledgeGraph = data.knowledgeGraph as { title?: string; description?: string } | undefined;
+    let output = '';
+    if (knowledgeGraph?.title) {
+      output += `Knowledge Graph: ${knowledgeGraph.title}\n`;
+      if (knowledgeGraph.description) output += `${knowledgeGraph.description}\n`;
+      output += '\n';
+    }
+
+    output += results;
+
+    return {
+      content: output,
+      metadata: {
+        query,
+        count: organic.length,
+        hasKnowledgeGraph: !!knowledgeGraph,
+      },
+    };
+  } catch (err) {
+    throw new ToolError(`Web search failed: ${(err as Error).message}`, 'web_search');
+  }
+};

package/src/core/tools/impl/WriteFileTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WriteFileTool.d.ts","sourceRoot":"","sources":["WriteFileTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAuC,MAAM,sBAAsB,CAAC;AAG7F,eAAO,MAAM,gBAAgB,EAAE,WA2C9B,CAAC"}

package/src/core/tools/impl/WriteFileTool.ts

@@ -0,0 +1,49 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { ToolHandler, ToolHandlerInput, ToolHandlerOutput } from '../../types/tools.js';
+import { ToolError } from '../../types/errors.js';
+
+export const writeFileHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const { filePath, content, createDirectories = false, encoding = 'utf-8' } = input.params as {
+    filePath: string;
+    content: string;
+    createDirectories?: boolean;
+    encoding?: BufferEncoding;
+  };
+
+  const resolvedPath = path.resolve(filePath);
+
+  try {
+    if (createDirectories) {
+      const dir = path.dirname(resolvedPath);
+      await fs.mkdir(dir, { recursive: true });
+    }
+
+    // Verify parent directory exists
+    const dir = path.dirname(resolvedPath);
+    try {
+      await fs.access(dir, fs.constants.W_OK);
+    } catch {
+      throw new ToolError(`Cannot write to directory: ${dir}`, 'write_file');
+    }
+
+    await fs.writeFile(resolvedPath, content, { encoding });
+
+    return {
+      content: `Successfully wrote ${content.length} characters to ${resolvedPath}`,
+      metadata: {
+        path: resolvedPath,
+        size: Buffer.byteLength(content, encoding),
+        encoding,
+      },
+      filesAffected: [resolvedPath],
+    };
+  } catch (err) {
+    if (err instanceof ToolError) throw err;
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === 'EACCES') {
+      throw new ToolError(`Permission denied: ${filePath}`, 'write_file', undefined, { code });
+    }
+    throw new ToolError(`Failed to write file: ${(err as Error).message}`, 'write_file');
+  }
+};

package/src/core/tools/impl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/src/core/tools/impl/index.ts

@@ -0,0 +1,16 @@
+// ============================================================================
+// Tool Implementations Barrel Export
+// ============================================================================
+
+export { readFileHandler } from './ReadFileTool.js';
+export { writeFileHandler } from './WriteFileTool.js';
+export { editFileHandler } from './EditFileTool.js';
+export { listDirectoryHandler } from './ListDirectoryTool.js';
+export { searchFileHandler } from './SearchFileTool.js';
+export { searchContentHandler } from './SearchContentTool.js';
+export { shellHandler } from './ShellTool.js';
+export { webSearchHandler } from './WebSearchTool.js';
+export { webFetchHandler } from './WebFetchTool.js';
+export { memoryReadHandler, memoryWriteHandler } from './MemoryTool.js';
+export { todoHandler } from './TodoTool.js';
+export { taskHandler } from './TaskTool.js';

package/src/core/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC"}

package/src/core/tools/index.ts

@@ -0,0 +1,7 @@
+// ============================================================================
+// Tools Package Barrel Export
+// ============================================================================
+
+export { ToolRegistry } from './ToolRegistry.js';
+export * from './schemas/index.js';
+export * from './impl/index.js';

package/src/core/tools/schemas/execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["execution.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqChC,CAAC"}

package/src/core/tools/schemas/execution.ts

@@ -0,0 +1,42 @@
+// ============================================================================
+// Execution Tool Schemas - JSON schemas for shell command execution
+// ============================================================================
+
+export const executeCommandSchema = {
+  type: 'object' as const,
+  properties: {
+    command: {
+      type: 'string',
+      description: 'The shell command to execute',
+    },
+    workingDirectory: {
+      type: 'string',
+      description: 'Working directory for the command (overrides session default)',
+    },
+    env: {
+      type: 'object',
+      description: 'Additional environment variables for the command',
+      additionalProperties: { type: 'string' },
+    },
+    timeout: {
+      type: 'number',
+      description: 'Timeout in milliseconds (default: 30000)',
+      default: 30000,
+    },
+    shell: {
+      type: 'string',
+      description: 'Shell to use (e.g., "bash", "powershell", "cmd")',
+    },
+    captureStderr: {
+      type: 'boolean',
+      description: 'Whether to capture stderr separately',
+      default: true,
+    },
+    input: {
+      type: 'string',
+      description: 'Stdin input for the command',
+    },
+  },
+  required: ['command'],
+  additionalProperties: false,
+};

package/src/core/tools/schemas/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["file.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;CAuB1B,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;CAwB3B,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4B1B,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiC/B,CAAC"}