@hanzo/dev 2.1.1 → 3.0.2

package/tests/editor.test.ts

@@ -1,223 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { FileEditor, EditCommand } from '../src/lib/editor';
-
-describe('Editor', () => {
-  let editor: FileEditor;
-  let testDir: string;
-  let testFile: string;
-
-  beforeEach(() => {
-    // Create temporary test directory
-    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hanzo-dev-test-'));
-    testFile = path.join(testDir, 'test.txt');
-    editor = new FileEditor(testDir);
-  });
-
-  afterEach(() => {
-    // Clean up test directory
-    fs.rmSync(testDir, { recursive: true, force: true });
-  });
-
-  describe('create command', () => {
-    test('should create a new file with content', async () => {
-      const command: EditCommand = {
-        command: 'create',
-        path: testFile,
-        content: 'Hello, World!'
-      };
-
-      const result = await editor.execute(command);
-      expect(result.success).toBe(true);
-      expect(fs.existsSync(testFile)).toBe(true);
-      expect(fs.readFileSync(testFile, 'utf-8')).toBe('Hello, World!');
-    });
-
-    test('should fail when file already exists', async () => {
-      fs.writeFileSync(testFile, 'existing content');
-
-      const command: EditCommand = {
-        command: 'create',
-        path: testFile,
-        content: 'new content'
-      };
-
-      const result = await editor.execute(command);
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('FILE_EXISTS');
-    });
-  });
-
-  describe('view command', () => {
-    test('should view entire file when no line range specified', async () => {
-      const content = 'Line 1\nLine 2\nLine 3';
-      fs.writeFileSync(testFile, content);
-
-      const command: EditCommand = {
-        command: 'view',
-        path: testFile
-      };
-
-      const result = await editor.execute(command);
-      expect(result.success).toBe(true);
-      expect(result.content).toContain('Line 1');
-      expect(result.content).toContain('Line 2');
-      expect(result.content).toContain('Line 3');
-    });
-
-    test('should view specific line range', async () => {
-      const lines = Array.from({ length: 10 }, (_, i) => `Line ${i + 1}`);
-      fs.writeFileSync(testFile, lines.join('\n'));
-
-      const command: EditCommand = {
-        command: 'view',
-        path: testFile,
-        startLine: 3,
-        endLine: 5
-      };
-
-      const result = await editor.execute(command);
-      expect(result.success).toBe(true);
-      expect(result.content).toContain('Line 3');
-      expect(result.content).toContain('Line 4');
-      expect(result.content).toContain('Line 5');
-      expect(result.content).not.toContain('Line 1');
-      expect(result.content).not.toContain('Line 10');
-    });
-  });
-
-  describe('str_replace command', () => {
-    test('should replace string in file', async () => {
-      const content = 'Hello, World!\nThis is a test.\nHello again!';
-      fs.writeFileSync(testFile, content);
-
-      const command: EditCommand = {
-        command: 'str_replace',
-        path: testFile,
-        oldStr: 'Hello, World!',
-        newStr: 'Hi, Universe!'
-      };
-
-      const result = await editor.execute(command);
-      expect(result.success).toBe(true);
-      
-      const newContent = fs.readFileSync(testFile, 'utf-8');
-      expect(newContent).toContain('Hi, Universe!');
-      expect(newContent).not.toContain('Hello, World!');
-      expect(newContent).toContain('Hello again!');
-    });
-
-    test('should fail when old string not found', async () => {
-      fs.writeFileSync(testFile, 'Some content');
-
-      const command: EditCommand = {
-        command: 'str_replace',
-        path: testFile,
-        oldStr: 'Not found',
-        newStr: 'Replacement'
-      };
-
-      const result = await editor.execute(command);
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('STRING_NOT_FOUND');
-    });
-
-    test('should fail when old string appears multiple times', async () => {
-      const content = 'duplicate\nsome text\nduplicate';
-      fs.writeFileSync(testFile, content);
-
-      const command: EditCommand = {
-        command: 'str_replace',
-        path: testFile,
-        oldStr: 'duplicate',
-        newStr: 'unique'
-      };
-
-      const result = await editor.execute(command);
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('STRING_NOT_UNIQUE');
-    });
-  });
-
-  describe('insert command', () => {
-    test('should insert text at specific line', async () => {
-      const content = 'Line 1\nLine 2\nLine 3';
-      fs.writeFileSync(testFile, content);
-
-      const command: EditCommand = {
-        command: 'insert',
-        path: testFile,
-        lineNumber: 2,
-        content: 'Inserted line'
-      };
-
-      const result = await editor.execute(command);
-      expect(result.success).toBe(true);
-
-      const newContent = fs.readFileSync(testFile, 'utf-8');
-      const lines = newContent.split('\n');
-      expect(lines[1]).toBe('Inserted line');
-      expect(lines[2]).toBe('Line 2');
-    });
-  });
-
-  describe('undo_edit command', () => {
-    test('should undo last edit', async () => {
-      const originalContent = 'Original content';
-      fs.writeFileSync(testFile, originalContent);
-
-      // Make an edit
-      await editor.execute({
-        command: 'str_replace',
-        path: testFile,
-        oldStr: 'Original',
-        newStr: 'Modified'
-      });
-
-      // Verify edit was made
-      expect(fs.readFileSync(testFile, 'utf-8')).toContain('Modified');
-
-      // Undo the edit
-      const result = await editor.execute({
-        command: 'undo_edit',
-        path: testFile
-      });
-
-      expect(result.success).toBe(true);
-      expect(fs.readFileSync(testFile, 'utf-8')).toBe(originalContent);
-    });
-  });
-
-  describe('chunk localization', () => {
-    test('should find relevant chunks for search query', async () => {
-      const codeContent = `
-function calculateTotal(items) {
-  let total = 0;
-  for (const item of items) {
-    total += item.price * item.quantity;
-  }
-  return total;
-}
-
-function applyDiscount(total, discountPercent) {
-  return total * (1 - discountPercent / 100);
-}
-
-function formatCurrency(amount) {
-  return new Intl.NumberFormat('en-US', {
-    style: 'currency',
-    currency: 'USD'
-  }).format(amount);
-}
-`;
-      fs.writeFileSync(testFile, codeContent);
-
-      const chunks = await editor.getRelevantChunks(testFile, 'calculate price total');
-      expect(chunks.length).toBeGreaterThan(0);
-      expect(chunks[0].content).toContain('calculateTotal');
-      expect(chunks[0].content).toContain('price');
-    });
-  });
-});

package/tests/fixtures/sample-code.js

@@ -1,13 +0,0 @@
-// Sample JavaScript code for testing
-function calculateSum(numbers) {
-  return numbers.reduce((sum, num) => sum + num, 0);
-}
-
-function findMax(numbers) {
-  return Math.max(...numbers);
-}
-
-module.exports = {
-  calculateSum,
-  findMax
-};

package/tests/fixtures/sample-code.py

@@ -1,28 +0,0 @@
-# Sample Python code for testing
-import json
-from typing import List, Dict, Optional
-
-class DataProcessor:
-    """Process and analyze data."""
-    
-    def __init__(self):
-        self.data = []
-    
-    def add_item(self, item: Dict) -> None:
-        """Add an item to the dataset."""
-        self.data.append(item)
-    
-    def get_summary(self) -> Dict:
-        """Get summary statistics."""
-        if not self.data:
-            return {"count": 0, "total": 0, "average": 0}
-        
-        values = [item.get("value", 0) for item in self.data]
-        total = sum(values)
-        count = len(values)
-        
-        return {
-            "count": count,
-            "total": total,
-            "average": total / count if count > 0 else 0
-        }

package/tests/fixtures/sample-code.ts

@@ -1,22 +0,0 @@
-// Sample TypeScript code for testing
-interface User {
-  id: number;
-  name: string;
-  email: string;
-}
-
-export class UserService {
-  private users: User[] = [];
-
-  addUser(user: User): void {
-    this.users.push(user);
-  }
-
-  getUser(id: number): User | undefined {
-    return this.users.find(user => user.id === id);
-  }
-
-  getAllUsers(): User[] {
-    return [...this.users];
-  }
-}

package/tests/mcp-client.test.ts

@@ -1,238 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest';
-import { MCPClient, MCPSession, MCPServerConfig } from '../src/lib/mcp-client';
-import { EventEmitter } from 'events';
-import * as child_process from 'child_process';
-
-// Mock child_process
-vi.mock('child_process');
-
-describe('MCPClient', () => {
-  let client: MCPClient;
-  let mockProcess: any;
-
-  beforeEach(() => {
-    client = new MCPClient();
-    
-    // Mock spawn to return a fake process
-    mockProcess = new EventEmitter();
-    mockProcess.stdin = { write: vi.fn() };
-    mockProcess.stdout = new EventEmitter();
-    mockProcess.stderr = new EventEmitter();
-    mockProcess.kill = vi.fn();
-
-    vi.mocked(child_process.spawn).mockReturnValue(mockProcess as any);
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('stdio transport', () => {
-    test('should connect to MCP server via stdio', async () => {
-      const config: MCPServerConfig = {
-        name: 'test-server',
-        transport: 'stdio',
-        command: 'test-mcp-server',
-        args: ['--test']
-      };
-
-      // Start connection in background
-      const connectPromise = client.connect(config);
-
-      // Simulate server sending initialization response
-      setTimeout(() => {
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 1,
-          result: {
-            protocolVersion: '1.0',
-            serverInfo: { name: 'test-server', version: '1.0.0' }
-          }
-        }) + '\n');
-
-        // Simulate tools list response
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: 2,
-          result: {
-            tools: [
-              {
-                name: 'test_tool',
-                description: 'A test tool',
-                parameters: {
-                  type: 'object',
-                  properties: {
-                    input: { type: 'string' }
-                  }
-                }
-              }
-            ]
-          }
-        }) + '\n');
-      }, 10);
-
-      const session = await connectPromise;
-      expect(session).toBeDefined();
-      expect(session.tools).toHaveLength(1);
-      expect(session.tools[0].name).toBe('test_tool');
-    });
-
-    test('should handle server errors', async () => {
-      const config: MCPServerConfig = {
-        name: 'error-server',
-        transport: 'stdio',
-        command: 'failing-server'
-      };
-
-      const connectPromise = client.connect(config);
-
-      // Simulate process error
-      setTimeout(() => {
-        mockProcess.emit('error', new Error('Failed to start'));
-      }, 10);
-
-      await expect(connectPromise).rejects.toThrow('Failed to start');
-    });
-  });
-
-  describe('tool calling', () => {
-    test('should call tool on MCP server', async () => {
-      const session: MCPSession = {
-        serverName: 'test-server',
-        tools: [{
-          name: 'echo',
-          description: 'Echo input',
-          parameters: {
-            type: 'object',
-            properties: {
-              message: { type: 'string' }
-            }
-          }
-        }],
-        prompts: [],
-        resources: []
-      };
-
-      // Mock session in client
-      (client as any).sessions.set('test-server', session);
-      (client as any).processes.set('test-server', mockProcess);
-
-      // Start tool call
-      const callPromise = client.callTool('test-server', 'echo', { message: 'Hello' });
-
-      // Simulate server response
-      setTimeout(() => {
-        // Find the request that was sent
-        const writeCall = mockProcess.stdin.write.mock.calls[0];
-        const request = JSON.parse(writeCall[0]);
-        
-        // Send response with same ID
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: request.id,
-          result: {
-            output: 'Echo: Hello'
-          }
-        }) + '\n');
-      }, 10);
-
-      const result = await callPromise;
-      expect(result.output).toBe('Echo: Hello');
-    });
-  });
-
-  describe('session management', () => {
-    test('should list connected sessions', async () => {
-      // Mock two sessions
-      (client as any).sessions.set('server1', {
-        serverName: 'server1',
-        tools: [],
-        prompts: [],
-        resources: []
-      });
-      (client as any).sessions.set('server2', {
-        serverName: 'server2',
-        tools: [],
-        prompts: [],
-        resources: []
-      });
-
-      const sessions = client.listSessions();
-      expect(sessions).toHaveLength(2);
-      expect(sessions.map(s => s.serverName)).toContain('server1');
-      expect(sessions.map(s => s.serverName)).toContain('server2');
-    });
-
-    test('should disconnect from server', async () => {
-      const serverName = 'test-server';
-      
-      // Mock session and process
-      (client as any).sessions.set(serverName, {
-        serverName,
-        tools: [],
-        prompts: [],
-        resources: []
-      });
-      (client as any).processes.set(serverName, mockProcess);
-
-      await client.disconnect(serverName);
-
-      expect(mockProcess.kill).toHaveBeenCalled();
-      expect(client.listSessions()).toHaveLength(0);
-    });
-  });
-
-  describe('error handling', () => {
-    test('should handle JSON-RPC errors', async () => {
-      const session: MCPSession = {
-        serverName: 'test-server',
-        tools: [{
-          name: 'failing_tool',
-          description: 'A tool that fails',
-          parameters: { type: 'object' }
-        }],
-        prompts: [],
-        resources: []
-      };
-
-      (client as any).sessions.set('test-server', session);
-      (client as any).processes.set('test-server', mockProcess);
-
-      const callPromise = client.callTool('test-server', 'failing_tool', {});
-
-      setTimeout(() => {
-        const writeCall = mockProcess.stdin.write.mock.calls[0];
-        const request = JSON.parse(writeCall[0]);
-        
-        // Send error response
-        mockProcess.stdout.emit('data', JSON.stringify({
-          jsonrpc: '2.0',
-          id: request.id,
-          error: {
-            code: -32601,
-            message: 'Method not found'
-          }
-        }) + '\n');
-      }, 10);
-
-      await expect(callPromise).rejects.toThrow('Method not found');
-    });
-
-    test('should handle malformed responses', async () => {
-      const config: MCPServerConfig = {
-        name: 'malformed-server',
-        transport: 'stdio',
-        command: 'test-server'
-      };
-
-      const connectPromise = client.connect(config);
-
-      setTimeout(() => {
-        // Send malformed JSON
-        mockProcess.stdout.emit('data', 'not valid json\n');
-      }, 10);
-
-      await expect(connectPromise).rejects.toThrow();
-    });
-  });
-});