nova-terminal-assistant 0.1.0

package/src/core/tools/ToolRegistry.test.ts

@@ -0,0 +1,206 @@
+// ============================================================================
+// ToolRegistry Tests
+// ============================================================================
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ToolRegistry } from './ToolRegistry.js';
+import type { ToolDefinition, ToolHandler, ToolExecutionContext } from '../types/tools.js';
+
+describe('ToolRegistry', () => {
+  let registry: ToolRegistry;
+
+  const mockToolDefinition: ToolDefinition = {
+    name: 'test_tool',
+    description: 'A test tool',
+    category: 'utility',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        message: { type: 'string', description: 'A message' },
+      },
+      required: ['message'],
+    },
+  };
+
+  const mockToolHandler: ToolHandler = async (input: { message: string }) => {
+    return { result: `Echo: ${input.message}` };
+  };
+
+  const dangerousToolDefinition: ToolDefinition = {
+    name: 'dangerous_tool',
+    description: 'A dangerous tool',
+    category: 'system',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        command: { type: 'string' },
+      },
+    },
+    requiresApproval: true,
+  };
+
+  const dangerousToolHandler: ToolHandler = async () => ({ success: true });
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+  });
+
+  describe('register()', () => {
+    it('should register a tool with definition and handler', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      expect(registry.has('test_tool')).toBe(true);
+    });
+
+    it('should throw when registering duplicate tool', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      expect(() => {
+        registry.register(mockToolDefinition, mockToolHandler);
+      }).toThrow('already registered');
+    });
+  });
+
+  describe('get()', () => {
+    it('should return tool entry by name', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      const entry = registry.get('test_tool');
+
+      expect(entry).toBeDefined();
+      expect(entry?.definition.name).toBe('test_tool');
+    });
+
+    it('should return undefined for non-existent tool', () => {
+      const entry = registry.get('non_existent');
+      expect(entry).toBeUndefined();
+    });
+  });
+
+  describe('getDefinition()', () => {
+    it('should return tool definition', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      const def = registry.getDefinition('test_tool');
+
+      expect(def).toBeDefined();
+      expect(def?.name).toBe('test_tool');
+    });
+  });
+
+  describe('getHandler()', () => {
+    it('should return tool handler', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      const handler = registry.getHandler('test_tool');
+
+      expect(handler).toBeDefined();
+    });
+  });
+
+  describe('has()', () => {
+    it('should return true for registered tool', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      expect(registry.has('test_tool')).toBe(true);
+    });
+
+    it('should return false for non-existent tool', () => {
+      expect(registry.has('non_existent')).toBe(false);
+    });
+  });
+
+  describe('unregister()', () => {
+    it('should remove tool from registry', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      expect(registry.has('test_tool')).toBe(true);
+
+      registry.unregister('test_tool');
+      expect(registry.has('test_tool')).toBe(false);
+    });
+
+    it('should return false for non-existent tool', () => {
+      expect(registry.unregister('non_existent')).toBe(false);
+    });
+  });
+
+  describe('enable() and disable()', () => {
+    it('should disable a tool', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      registry.disable('test_tool');
+
+      expect(registry.isEnabled('test_tool')).toBe(false);
+    });
+
+    it('should re-enable a disabled tool', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      registry.disable('test_tool');
+      registry.enable('test_tool');
+
+      expect(registry.isEnabled('test_tool')).toBe(true);
+    });
+  });
+
+  describe('getToolNames()', () => {
+    it('should return empty array when no tools registered', () => {
+      expect(registry.getToolNames()).toHaveLength(0);
+    });
+
+    it('should return all registered tool names', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      registry.register(dangerousToolDefinition, dangerousToolHandler);
+
+      const names = registry.getToolNames();
+      expect(names).toHaveLength(2);
+      expect(names).toContain('test_tool');
+      expect(names).toContain('dangerous_tool');
+    });
+  });
+
+  describe('getEnabledToolNames()', () => {
+    it('should return only enabled tools', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      registry.register(dangerousToolDefinition, dangerousToolHandler);
+      registry.disable('dangerous_tool');
+
+      const names = registry.getEnabledToolNames();
+      expect(names).toHaveLength(1);
+      expect(names).toContain('test_tool');
+    });
+  });
+
+  describe('getAllDefinitions()', () => {
+    it('should return definitions for all enabled tools', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+
+      const defs = registry.getAllDefinitions();
+      expect(defs.length).toBeGreaterThan(0);
+      expect(defs[0].name).toBe('test_tool');
+    });
+  });
+
+  describe('requiresApproval()', () => {
+    it('should return false for tool without approval requirement in plan mode', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      // ToolRegistry must be accessed after registration
+      const result = registry.requiresApproval('test_tool', {}, 'plan');
+      expect(result).toBe(false);
+    });
+
+    it('should return true for tool with approval requirement in plan mode', () => {
+      registry.register(dangerousToolDefinition, dangerousToolHandler);
+      expect(registry.requiresApproval('dangerous_tool', {}, 'plan')).toBe(true);
+    });
+
+    it('should return false for all tools in yolo mode', () => {
+      registry.register(dangerousToolDefinition, dangerousToolHandler);
+      expect(registry.requiresApproval('dangerous_tool', {}, 'yolo')).toBe(false);
+    });
+  });
+
+  describe('unregister()', () => {
+    it('should remove all tools when called for each', () => {
+      registry.register(mockToolDefinition, mockToolHandler);
+      registry.register(dangerousToolDefinition, dangerousToolHandler);
+
+      registry.unregister('test_tool');
+      registry.unregister('dangerous_tool');
+
+      expect(registry.getToolNames()).toHaveLength(0);
+    });
+  });
+});

package/src/core/tools/ToolRegistry.ts

@@ -0,0 +1,260 @@
+// ============================================================================
+// ToolRegistry - Central registry for tool management
+// ============================================================================
+
+import type {
+  ToolDefinition,
+  ToolHandler,
+  ToolRegistryEntry,
+  ToolCategory,
+  ToolHandlerInput,
+  ToolHandlerOutput,
+  BuiltinToolName,
+} from '../types/tools.js';
+import type { ApprovalMode } from '../types/session.js';
+import { ToolError, ToolValidationError } from '../types/errors.js';
+import { BUILTIN_TOOLS } from '../types/tools.js';
+
+export class ToolRegistry {
+  private tools = new Map<string, ToolRegistryEntry>();
+  private categories = new Map<ToolCategory, Set<string>>();
+
+  /** Register a tool */
+  register(definition: ToolDefinition, handler: ToolHandler): void {
+    if (this.tools.has(definition.name)) {
+      throw new ToolError(`Tool "${definition.name}" is already registered`, definition.name);
+    }
+
+    this.tools.set(definition.name, {
+      definition,
+      handler,
+      enabled: true,
+    });
+
+    // Add to category index
+    const cat = definition.category;
+    if (!this.categories.has(cat)) {
+      this.categories.set(cat, new Set());
+    }
+    this.categories.get(cat)!.add(definition.name);
+  }
+
+  /** Unregister a tool by name */
+  unregister(name: string): boolean {
+    const entry = this.tools.get(name);
+    if (!entry) return false;
+
+    this.tools.delete(name);
+    this.categories.get(entry.definition.category)?.delete(name);
+    return true;
+  }
+
+  /** Get a tool entry by name */
+  get(name: string): ToolRegistryEntry | undefined {
+    return this.tools.get(name);
+  }
+
+  /** Get a tool's definition */
+  getDefinition(name: string): ToolDefinition | undefined {
+    return this.tools.get(name)?.definition;
+  }
+
+  /** Get a tool's handler */
+  getHandler(name: string): ToolHandler | undefined {
+    return this.tools.get(name)?.handler;
+  }
+
+  /** Check if a tool exists */
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  /** Enable a tool */
+  enable(name: string): void {
+    const entry = this.tools.get(name);
+    if (entry) entry.enabled = true;
+  }
+
+  /** Disable a tool */
+  disable(name: string): void {
+    const entry = this.tools.get(name);
+    if (entry) entry.enabled = false;
+  }
+
+  /** Check if a tool is enabled */
+  isEnabled(name: string): boolean {
+    return this.tools.get(name)?.enabled ?? false;
+  }
+
+  /** Get all tool names */
+  getToolNames(): string[] {
+    return Array.from(this.tools.keys());
+  }
+
+  /** Get all enabled tool names */
+  getEnabledToolNames(): string[] {
+    return Array.from(this.tools.entries())
+      .filter(([, entry]) => entry.enabled)
+      .map(([name]) => name);
+  }
+
+  /** Get tools by category */
+  getToolsByCategory(category: ToolCategory): ToolRegistryEntry[] {
+    const names = this.categories.get(category);
+    if (!names) return [];
+    return Array.from(names)
+      .map((name) => this.tools.get(name)!)
+      .filter(Boolean);
+  }
+
+  /** Get all tool definitions (for LLM schema) */
+  getAllDefinitions(): ToolDefinition[] {
+    return Array.from(this.tools.values())
+      .filter((entry) => entry.enabled)
+      .map((entry) => entry.definition);
+  }
+
+  /** Get tool definitions in Anthropic tool use format */
+  getAnthropicToolDefinitions(): Array<{
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+  }> {
+    return this.getAllDefinitions().map((def) => ({
+      name: def.name,
+      description: def.description,
+      input_schema: def.inputSchema,
+    }));
+  }
+
+  /** Get tool definitions in OpenAI function calling format */
+  getOpenAIToolDefinitions(): Array<{
+    type: 'function';
+    function: {
+      name: string;
+      description: string;
+      parameters: Record<string, unknown>;
+    };
+  }> {
+    return this.getAllDefinitions().map((def) => ({
+      type: 'function' as const,
+      function: {
+        name: def.name,
+        description: def.description,
+        parameters: def.inputSchema,
+      },
+    }));
+  }
+
+  /** Check if a tool requires approval for given input and mode */
+  requiresApproval(name: string, input: Record<string, unknown>, mode: ApprovalMode): boolean {
+    const entry = this.tools.get(name);
+    if (!entry) return false;
+
+    // yolo mode: never require approval
+    if (mode === 'yolo') return false;
+    // accepting_edits: never require approval
+    if (mode === 'accepting_edits') return false;
+
+    const { requiresApproval } = entry.definition;
+    if (requiresApproval === undefined) return false;
+    if (typeof requiresApproval === 'boolean') return requiresApproval;
+    return requiresApproval(input, mode);
+  }
+
+  /** Get the risk level of a tool */
+  getRiskLevel(name: string): 'low' | 'medium' | 'high' | 'critical' {
+    return this.tools.get(name)?.definition.riskLevel ?? 'medium';
+  }
+
+  /** Validate tool input against its schema */
+  validateInput(name: string, input: Record<string, unknown>): { valid: true } | { valid: false; errors: Array<{ field: string; message: string }> } {
+    const entry = this.tools.get(name);
+    if (!entry) {
+      return { valid: false, errors: [{ field: '_', message: `Tool "${name}" not found` }] };
+    }
+
+    const schema = entry.definition.inputSchema;
+    // Basic validation against JSON Schema properties
+    const errors: Array<{ field: string; message: string }> = [];
+    const properties = (schema.properties || {}) as Record<string, Record<string, unknown>>;
+    const required = (schema.required || []) as string[];
+
+    // Check required fields
+    for (const fieldName of required) {
+      if (input[fieldName] === undefined || input[fieldName] === null) {
+        errors.push({ field: fieldName, message: `Required field "${fieldName}" is missing` });
+      }
+    }
+
+    // Check property types
+    for (const [fieldName, value] of Object.entries(input)) {
+      const propSchema = properties[fieldName];
+      if (!propSchema) continue;
+
+      const expectedType = propSchema.type as string | string[];
+      const actualType = Array.isArray(value) ? 'array' : typeof value;
+
+      if (Array.isArray(expectedType)) {
+        if (!expectedType.includes(actualType)) {
+          errors.push({
+            field: fieldName,
+            message: `Expected type ${expectedType.join('|')}, got ${actualType}`,
+          });
+        }
+      } else if (expectedType && expectedType !== actualType) {
+        errors.push({
+          field: fieldName,
+          message: `Expected type ${expectedType}, got ${actualType}`,
+        });
+      }
+    }
+
+    return errors.length === 0 ? { valid: true } : { valid: false, errors };
+  }
+
+  /** Execute a tool with the given input */
+  async execute(
+    name: string,
+    input: ToolHandlerInput
+  ): Promise<ToolHandlerOutput> {
+    const entry = this.tools.get(name);
+    if (!entry) {
+      throw new ToolError(`Tool "${name}" not found`, name);
+    }
+    if (!entry.enabled) {
+      throw new ToolError(`Tool "${name}" is disabled`, name);
+    }
+
+    // Validate input
+    const validation = this.validateInput(name, input.params);
+    if (!validation.valid) {
+      const errors = 'errors' in validation ? validation.errors : [];
+      throw new ToolValidationError(
+        `Invalid input for tool "${name}"`,
+        name,
+        errors
+      );
+    }
+
+    return entry.handler(input);
+  }
+
+  /** Get all builtin tool names */
+  getBuiltinToolNames(): BuiltinToolName[] {
+    return Object.values(BUILTIN_TOOLS);
+  }
+
+  /** Get statistics about registered tools */
+  getStats(): { total: number; enabled: number; byCategory: Record<string, number> } {
+    const byCategory: Record<string, number> = {};
+    for (const [cat, names] of this.categories) {
+      byCategory[cat] = names.size;
+    }
+    return {
+      total: this.tools.size,
+      enabled: this.getEnabledToolNames().length,
+      byCategory,
+    };
+  }
+}

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

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

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

@@ -0,0 +1,97 @@
+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 editFileHandler: ToolHandler = async (input: ToolHandlerInput): Promise<ToolHandlerOutput> => {
+  const { filePath, oldText, newText, allOccurrences = false, dryRun = false } = input.params as {
+    filePath: string;
+    oldText: string;
+    newText: string;
+    allOccurrences?: boolean;
+    dryRun?: boolean;
+  };
+
+  const resolvedPath = path.resolve(filePath);
+
+  try {
+    const content = await fs.readFile(resolvedPath, 'utf-8');
+
+    // Check if oldText exists
+    if (!content.includes(oldText)) {
+      throw new ToolError(
+        `The specified text was not found in the file. Make sure oldText matches exactly (including whitespace).`,
+        'edit_file'
+      );
+    }
+
+    // Count occurrences
+    const occurrences = content.split(oldText).length - 1;
+
+    if (occurrences > 1 && !allOccurrences) {
+      throw new ToolError(
+        `The text appears ${occurrences} times in the file. Set allOccurrences=true to replace all, or make oldText more specific to match only once.`,
+        'edit_file',
+        undefined,
+        { occurrences }
+      );
+    }
+
+    let newContent: string;
+    if (allOccurrences) {
+      newContent = content.split(oldText).join(newText);
+    } else {
+      newContent = content.replace(oldText, newText);
+    }
+
+    if (dryRun) {
+      // Show a unified diff-like preview
+      const oldLines = content.split('\n');
+      const newLines = newContent.split('\n');
+      const preview = generateDiffPreview(oldLines, newLines);
+      return {
+        content: `Dry run preview for ${resolvedPath}:\n${preview}\n\n${occurrences} occurrence(s) would be replaced.`,
+        metadata: { dryRun: true, occurrences, path: resolvedPath },
+      };
+    }
+
+    await fs.writeFile(resolvedPath, newContent, 'utf-8');
+
+    return {
+      content: `Successfully replaced ${occurrences} occurrence(s) in ${resolvedPath}`,
+      metadata: {
+        path: resolvedPath,
+        occurrences,
+        oldSize: Buffer.byteLength(content, 'utf-8'),
+        newSize: Buffer.byteLength(newContent, 'utf-8'),
+      },
+      filesAffected: [resolvedPath],
+    };
+  } catch (err) {
+    if (err instanceof ToolError) throw err;
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT') {
+      throw new ToolError(`File not found: ${filePath}`, 'edit_file', undefined, { code });
+    }
+    throw new ToolError(`Failed to edit file: ${(err as Error).message}`, 'edit_file');
+  }
+};
+
+function generateDiffPreview(oldLines: string[], newLines: string[]): string {
+  const result: string[] = [];
+  const maxLines = Math.max(oldLines.length, newLines.length);
+  let shown = 0;
+
+  for (let i = 0; i < maxLines && shown < 20; i++) {
+    const oldLine = oldLines[i];
+    const newLine = newLines[i];
+    if (oldLine === newLine) continue;
+    if (oldLine !== undefined) result.push(`- ${oldLine}`);
+    if (newLine !== undefined) result.push(`+ ${newLine}`);
+    shown++;
+  }
+
+  if (shown >= 20) result.push('... (truncated)');
+
+  return result.join('\n');
+}

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

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