@hanzo/dev 1.2.0 → 2.0.0

package/src/lib/editor.ts

@@ -0,0 +1,368 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+
+export interface EditCommand {
+  command: 'view' | 'create' | 'str_replace' | 'insert' | 'undo_edit';
+  path?: string;
+  content?: string;
+  oldStr?: string;
+  newStr?: string;
+  startLine?: number;
+  endLine?: number;
+  lineNumber?: number;
+}
+
+export interface EditResult {
+  success: boolean;
+  message: string;
+  content?: string;
+  error?: string;
+}
+
+export class FileEditor {
+  private static readonly MAX_LINES_TO_EDIT = 300;
+  private static readonly SUPPORTED_BINARY_FORMATS = [
+    '.pdf', '.docx', '.xlsx', '.mp3', '.mp4', '.jpg', '.jpeg', '.png', '.gif'
+  ];
+  
+  private editHistory: Map<string, string[]> = new Map();
+  private currentFile: string | null = null;
+
+  async execute(command: EditCommand): Promise<EditResult> {
+    switch (command.command) {
+      case 'view':
+        return this.viewFile(command.path!, command.startLine, command.endLine);
+      case 'create':
+        return this.createFile(command.path!, command.content || '');
+      case 'str_replace':
+        return this.strReplace(command.path!, command.oldStr!, command.newStr!);
+      case 'insert':
+        return this.insertLine(command.path!, command.lineNumber!, command.content!);
+      case 'undo_edit':
+        return this.undoEdit(command.path!);
+      default:
+        return {
+          success: false,
+          message: `Unknown command: ${command.command}`,
+          error: 'Invalid command'
+        };
+    }
+  }
+
+  private async viewFile(filePath: string, startLine?: number, endLine?: number): Promise<EditResult> {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return {
+          success: false,
+          message: `File not found: ${filePath}`,
+          error: 'FILE_NOT_FOUND'
+        };
+      }
+
+      const ext = path.extname(filePath).toLowerCase();
+      if (FileEditor.SUPPORTED_BINARY_FORMATS.includes(ext)) {
+        const stats = fs.statSync(filePath);
+        return {
+          success: true,
+          message: `Binary file: ${filePath} (${this.formatBytes(stats.size)})`,
+          content: `[Binary file of type ${ext}]`
+        };
+      }
+
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const lines = content.split('\n');
+      
+      if (startLine !== undefined || endLine !== undefined) {
+        const start = (startLine || 1) - 1;
+        const end = endLine || lines.length;
+        const viewLines = lines.slice(start, end);
+        
+        const result = viewLines.map((line, idx) => 
+          `${chalk.gray(`${start + idx + 1}:`)} ${line}`
+        ).join('\n');
+
+        return {
+          success: true,
+          message: `Viewing ${filePath} lines ${start + 1}-${end}`,
+          content: result
+        };
+      }
+
+      // Full file view with line numbers
+      const result = lines.map((line, idx) => 
+        `${chalk.gray(`${idx + 1}:`)} ${line}`
+      ).join('\n');
+
+      this.currentFile = filePath;
+      
+      return {
+        success: true,
+        message: `Viewing ${filePath} (${lines.length} lines)`,
+        content: result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Error reading file: ${error}`,
+        error: 'READ_ERROR'
+      };
+    }
+  }
+
+  private async createFile(filePath: string, content: string): Promise<EditResult> {
+    try {
+      if (fs.existsSync(filePath)) {
+        return {
+          success: false,
+          message: `File already exists: ${filePath}`,
+          error: 'FILE_EXISTS'
+        };
+      }
+
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      fs.writeFileSync(filePath, content);
+      this.addToHistory(filePath, '');
+
+      return {
+        success: true,
+        message: `Created file: ${filePath}`,
+        content: content
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Error creating file: ${error}`,
+        error: 'CREATE_ERROR'
+      };
+    }
+  }
+
+  private async strReplace(filePath: string, oldStr: string, newStr: string): Promise<EditResult> {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return {
+          success: false,
+          message: `File not found: ${filePath}`,
+          error: 'FILE_NOT_FOUND'
+        };
+      }
+
+      const content = fs.readFileSync(filePath, 'utf-8');
+      
+      // Check if old string exists
+      if (!content.includes(oldStr)) {
+        return {
+          success: false,
+          message: `String not found in file: "${oldStr}"`,
+          error: 'STRING_NOT_FOUND'
+        };
+      }
+
+      // Check if old string is unique
+      const occurrences = content.split(oldStr).length - 1;
+      if (occurrences > 1) {
+        return {
+          success: false,
+          message: `String "${oldStr}" found ${occurrences} times. Please provide a unique string.`,
+          error: 'STRING_NOT_UNIQUE'
+        };
+      }
+
+      // Save to history
+      this.addToHistory(filePath, content);
+
+      // Replace
+      const newContent = content.replace(oldStr, newStr);
+      fs.writeFileSync(filePath, newContent);
+
+      return {
+        success: true,
+        message: `Replaced string in ${filePath}`,
+        content: this.showDiff(oldStr, newStr)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Error replacing string: ${error}`,
+        error: 'REPLACE_ERROR'
+      };
+    }
+  }
+
+  private async insertLine(filePath: string, lineNumber: number, content: string): Promise<EditResult> {
+    try {
+      if (!fs.existsSync(filePath)) {
+        return {
+          success: false,
+          message: `File not found: ${filePath}`,
+          error: 'FILE_NOT_FOUND'
+        };
+      }
+
+      const fileContent = fs.readFileSync(filePath, 'utf-8');
+      const lines = fileContent.split('\n');
+
+      if (lineNumber < 1 || lineNumber > lines.length + 1) {
+        return {
+          success: false,
+          message: `Invalid line number: ${lineNumber}. File has ${lines.length} lines.`,
+          error: 'INVALID_LINE_NUMBER'
+        };
+      }
+
+      // Save to history
+      this.addToHistory(filePath, fileContent);
+
+      // Insert line
+      lines.splice(lineNumber - 1, 0, content);
+      const newContent = lines.join('\n');
+      fs.writeFileSync(filePath, newContent);
+
+      return {
+        success: true,
+        message: `Inserted line at ${lineNumber} in ${filePath}`,
+        content: content
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Error inserting line: ${error}`,
+        error: 'INSERT_ERROR'
+      };
+    }
+  }
+
+  private async undoEdit(filePath: string): Promise<EditResult> {
+    const history = this.editHistory.get(filePath);
+    if (!history || history.length === 0) {
+      return {
+        success: false,
+        message: `No edit history for ${filePath}`,
+        error: 'NO_HISTORY'
+      };
+    }
+
+    const previousContent = history.pop()!;
+    fs.writeFileSync(filePath, previousContent);
+
+    return {
+      success: true,
+      message: `Undid last edit to ${filePath}`,
+      content: 'Edit undone'
+    };
+  }
+
+  private addToHistory(filePath: string, content: string): void {
+    if (!this.editHistory.has(filePath)) {
+      this.editHistory.set(filePath, []);
+    }
+    const history = this.editHistory.get(filePath)!;
+    history.push(content);
+    
+    // Keep only last 10 edits
+    if (history.length > 10) {
+      history.shift();
+    }
+  }
+
+  private showDiff(oldStr: string, newStr: string): string {
+    const oldLines = oldStr.split('\n');
+    const newLines = newStr.split('\n');
+    
+    let diff = '';
+    oldLines.forEach(line => {
+      diff += chalk.red(`- ${line}\n`);
+    });
+    newLines.forEach(line => {
+      diff += chalk.green(`+ ${line}\n`);
+    });
+    
+    return diff.trim();
+  }
+
+  private formatBytes(bytes: number): string {
+    if (bytes < 1024) return `${bytes} bytes`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+  }
+}
+
+// Chunk localizer for finding relevant code sections
+export class ChunkLocalizer {
+  static findRelevantChunk(content: string, searchPattern: string, maxLines: number = 50): {
+    startLine: number;
+    endLine: number;
+    content: string;
+  } | null {
+    const lines = content.split('\n');
+    const searchLower = searchPattern.toLowerCase();
+    
+    let bestMatch = { score: 0, index: -1 };
+    
+    // Find best matching line
+    lines.forEach((line, index) => {
+      const score = this.calculateSimilarity(line.toLowerCase(), searchLower);
+      if (score > bestMatch.score) {
+        bestMatch = { score, index };
+      }
+    });
+    
+    if (bestMatch.index === -1 || bestMatch.score < 0.3) {
+      return null;
+    }
+    
+    // Extract chunk around best match
+    const halfLines = Math.floor(maxLines / 2);
+    const startLine = Math.max(0, bestMatch.index - halfLines);
+    const endLine = Math.min(lines.length, bestMatch.index + halfLines);
+    
+    return {
+      startLine: startLine + 1,
+      endLine: endLine,
+      content: lines.slice(startLine, endLine).join('\n')
+    };
+  }
+  
+  private static calculateSimilarity(str1: string, str2: string): number {
+    const longer = str1.length > str2.length ? str1 : str2;
+    const shorter = str1.length > str2.length ? str2 : str1;
+    
+    if (longer.length === 0) return 1.0;
+    
+    const distance = this.levenshteinDistance(longer, shorter);
+    return (longer.length - distance) / longer.length;
+  }
+  
+  private static levenshteinDistance(str1: string, str2: string): number {
+    const matrix: number[][] = [];
+    
+    for (let i = 0; i <= str2.length; i++) {
+      matrix[i] = [i];
+    }
+    
+    for (let j = 0; j <= str1.length; j++) {
+      matrix[0][j] = j;
+    }
+    
+    for (let i = 1; i <= str2.length; i++) {
+      for (let j = 1; j <= str1.length; j++) {
+        if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+          matrix[i][j] = matrix[i - 1][j - 1];
+        } else {
+          matrix[i][j] = Math.min(
+            matrix[i - 1][j - 1] + 1,
+            matrix[i][j - 1] + 1,
+            matrix[i - 1][j] + 1
+          );
+        }
+      }
+    }
+    
+    return matrix[str2.length][str1.length];
+  }
+}

package/src/lib/function-calling.ts

@@ -0,0 +1,318 @@
+import { FileEditor, EditCommand } from './editor';
+import { MCPClient, MCPSession } from './mcp-client';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: any; // JSON Schema
+  handler: (args: any) => Promise<any>;
+}
+
+export interface FunctionCall {
+  id: string;
+  name: string;
+  arguments: any;
+}
+
+export interface ToolCallResult {
+  id: string;
+  result?: any;
+  error?: string;
+}
+
+export class FunctionCallingSystem {
+  private tools: Map<string, Tool> = new Map();
+  private fileEditor: FileEditor;
+  private mcpClient: MCPClient;
+  private mcpSessions: Map<string, MCPSession> = new Map();
+
+  constructor() {
+    this.fileEditor = new FileEditor();
+    this.mcpClient = new MCPClient();
+    this.registerBuiltinTools();
+  }
+
+  private registerBuiltinTools() {
+    // File editing tools
+    this.registerTool({
+      name: 'view_file',
+      description: 'View contents of a file with optional line range',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path' },
+          start_line: { type: 'number', description: 'Start line (optional)' },
+          end_line: { type: 'number', description: 'End line (optional)' }
+        },
+        required: ['path']
+      },
+      handler: async (args) => {
+        const result = await this.fileEditor.execute({
+          command: 'view',
+          path: args.path,
+          startLine: args.start_line,
+          endLine: args.end_line
+        });
+        return result;
+      }
+    });
+
+    this.registerTool({
+      name: 'create_file',
+      description: 'Create a new file with content',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path' },
+          content: { type: 'string', description: 'File content' }
+        },
+        required: ['path', 'content']
+      },
+      handler: async (args) => {
+        const result = await this.fileEditor.execute({
+          command: 'create',
+          path: args.path,
+          content: args.content
+        });
+        return result;
+      }
+    });
+
+    this.registerTool({
+      name: 'str_replace',
+      description: 'Replace exact string match in file',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'File path' },
+          old_str: { type: 'string', description: 'String to replace' },
+          new_str: { type: 'string', description: 'Replacement string' }
+        },
+        required: ['path', 'old_str', 'new_str']
+      },
+      handler: async (args) => {
+        const result = await this.fileEditor.execute({
+          command: 'str_replace',
+          path: args.path,
+          oldStr: args.old_str,
+          newStr: args.new_str
+        });
+        return result;
+      }
+    });
+
+    // Command execution
+    this.registerTool({
+      name: 'run_command',
+      description: 'Execute a shell command',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string', description: 'Command to execute' },
+          cwd: { type: 'string', description: 'Working directory (optional)' },
+          timeout: { type: 'number', description: 'Timeout in ms (optional)' }
+        },
+        required: ['command']
+      },
+      handler: async (args) => {
+        return this.executeCommand(args.command, args.cwd, args.timeout);
+      }
+    });
+
+    // File system tools
+    this.registerTool({
+      name: 'list_directory',
+      description: 'List contents of a directory',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Directory path' }
+        },
+        required: ['path']
+      },
+      handler: async (args) => {
+        try {
+          const files = fs.readdirSync(args.path);
+          const details = files.map(file => {
+            const fullPath = path.join(args.path, file);
+            const stats = fs.statSync(fullPath);
+            return {
+              name: file,
+              type: stats.isDirectory() ? 'directory' : 'file',
+              size: stats.size,
+              modified: stats.mtime
+            };
+          });
+          return { success: true, files: details };
+        } catch (error) {
+          return { success: false, error: error.toString() };
+        }
+      }
+    });
+
+    this.registerTool({
+      name: 'search_files',
+      description: 'Search for files matching a pattern',
+      parameters: {
+        type: 'object',
+        properties: {
+          pattern: { type: 'string', description: 'Search pattern' },
+          path: { type: 'string', description: 'Directory to search in' },
+          regex: { type: 'boolean', description: 'Use regex matching' }
+        },
+        required: ['pattern']
+      },
+      handler: async (args) => {
+        const searchPath = args.path || process.cwd();
+        return this.searchFiles(searchPath, args.pattern, args.regex);
+      }
+    });
+  }
+
+  registerTool(tool: Tool): void {
+    this.tools.set(tool.name, tool);
+  }
+
+  async registerMCPServer(name: string, session: MCPSession): Promise<void> {
+    this.mcpSessions.set(name, session);
+    
+    // Register MCP tools as function calling tools
+    for (const tool of session.tools) {
+      this.registerTool({
+        name: `${name}.${tool.name}`,
+        description: tool.description,
+        parameters: tool.inputSchema,
+        handler: async (args) => {
+          return this.mcpClient.callTool(session.id, tool.name, args);
+        }
+      });
+    }
+  }
+
+  async callFunction(call: FunctionCall): Promise<ToolCallResult> {
+    const tool = this.tools.get(call.name);
+    if (!tool) {
+      return {
+        id: call.id,
+        error: `Tool '${call.name}' not found`
+      };
+    }
+
+    try {
+      const result = await tool.handler(call.arguments);
+      return {
+        id: call.id,
+        result
+      };
+    } catch (error) {
+      return {
+        id: call.id,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+
+  async callFunctions(calls: FunctionCall[]): Promise<ToolCallResult[]> {
+    return Promise.all(calls.map(call => this.callFunction(call)));
+  }
+
+  getAvailableTools(): Tool[] {
+    return Array.from(this.tools.values());
+  }
+
+  getToolSchema(name: string): any {
+    const tool = this.tools.get(name);
+    if (!tool) return null;
+    
+    return {
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    };
+  }
+
+  getAllToolSchemas(): any[] {
+    return this.getAvailableTools().map(tool => this.getToolSchema(tool.name));
+  }
+
+  private async executeCommand(command: string, cwd?: string, timeout?: number): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const options: any = {
+        shell: true,
+        cwd: cwd || process.cwd()
+      };
+
+      const proc = spawn(command, [], options);
+      let stdout = '';
+      let stderr = '';
+
+      const timer = timeout ? setTimeout(() => {
+        proc.kill();
+        reject(new Error(`Command timeout after ${timeout}ms`));
+      }, timeout) : null;
+
+      proc.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      proc.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      proc.on('close', (code) => {
+        if (timer) clearTimeout(timer);
+        
+        resolve({
+          success: code === 0,
+          code,
+          stdout,
+          stderr
+        });
+      });
+
+      proc.on('error', (error) => {
+        if (timer) clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+
+  private async searchFiles(searchPath: string, pattern: string, useRegex: boolean = false): Promise<any> {
+    const results: string[] = [];
+    const regex = useRegex ? new RegExp(pattern) : null;
+
+    const walkDir = (dir: string) => {
+      try {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+          const fullPath = path.join(dir, file);
+          const stats = fs.statSync(fullPath);
+          
+          if (stats.isDirectory() && !file.startsWith('.') && file !== 'node_modules') {
+            walkDir(fullPath);
+          } else if (stats.isFile()) {
+            if (regex ? regex.test(file) : file.includes(pattern)) {
+              results.push(fullPath);
+            }
+          }
+        }
+      } catch (error) {
+        // Ignore permission errors
+      }
+    };
+
+    walkDir(searchPath);
+    
+    return {
+      success: true,
+      matches: results.slice(0, 100), // Limit results
+      total: results.length
+    };
+  }
+}