thatgfsj-code 0.3.0 → 0.3.1

package/src/tools/file.ts

@@ -1,117 +0,0 @@
-/**
- * File Tool - File operations
- */
-
-import type { Tool, ToolResult } from './types.js';
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync, unlinkSync } from 'fs';
-import { join, dirname, basename, extname } from 'path';
-
-export class FileTool implements Tool {
-  name = 'file';
-  description = 'Perform file operations: read, write, list, delete, etc.';
-
-  inputSchema = {
-    type: 'object' as const,
-    properties: {
-      action: { type: 'string', description: 'Action: read, write, list, delete, exists, mkdir' },
-      path: { type: 'string', description: 'File or directory path' },
-      content: { type: 'string', description: 'Content to write (for write action)' }
-    },
-    required: ['action', 'path']
-  };
-
-  metadata = {
-    permissions: ['read', 'write'] as ('read' | 'write' | 'execute' | 'network')[],
-    tags: ['file', 'filesystem'],
-    maxDuration: 30000,
-    version: '1.0.0'
-  };
-
-  parameters = [
-    { name: 'action', type: 'string', description: 'Action to perform: read, write, list, delete, exists', required: true },
-    { name: 'path', type: 'string', description: 'File or directory path', required: true },
-    { name: 'content', type: 'string', description: 'Content to write (for write action)', required: false }
-  ];
-
-  async execute(params: Record<string, any>): Promise<ToolResult> {
-    const { action, path, content } = params;
-    
-    try {
-      switch (action) {
-        case 'read':
-          return this.readFile(path);
-        case 'write':
-          return this.writeFile(path, content || '');
-        case 'list':
-          return this.listDir(path);
-        case 'delete':
-          return this.deleteFile(path);
-        case 'exists':
-          return this.checkExists(path);
-        case 'mkdir':
-          return this.mkdir(path);
-        default:
-          return { success: false, error: `Unknown action: ${action}` };
-      }
-    } catch (error: any) {
-      return { success: false, error: error.message };
-    }
-  }
-
-  private readFile(path: string): ToolResult {
-    if (!existsSync(path)) {
-      return { success: false, error: `File not found: ${path}` };
-    }
-    
-    const content = readFileSync(path, 'utf-8');
-    return { success: true, output: content };
-  }
-
-  private writeFile(path: string, content: string): ToolResult {
-    const dir = dirname(path);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    
-    writeFileSync(path, content, 'utf-8');
-    return { success: true, output: `File written: ${path}` };
-  }
-
-  private listDir(path: string): ToolResult {
-    if (!existsSync(path)) {
-      return { success: false, error: `Directory not found: ${path}` };
-    }
-    
-    const files = readdirSync(path);
-    const items = files.map(f => {
-      const fullPath = join(path, f);
-      const stat = statSync(fullPath);
-      return {
-        name: f,
-        type: stat.isDirectory() ? 'dir' : 'file',
-        size: stat.size,
-        modified: stat.mtime.toISOString()
-      };
-    });
-    
-    return { success: true, output: JSON.stringify(items, null, 2) };
-  }
-
-  private deleteFile(path: string): ToolResult {
-    if (!existsSync(path)) {
-      return { success: false, error: `Path not found: ${path}` };
-    }
-    
-    unlinkSync(path);
-    return { success: true, output: `Deleted: ${path}` };
-  }
-
-  private checkExists(path: string): ToolResult {
-    return { success: true, output: existsSync(path) ? 'true' : 'false' };
-  }
-
-  private mkdir(path: string): ToolResult {
-    mkdirSync(path, { recursive: true });
-    return { success: true, output: `Created: ${path}` };
-  }
-}

package/src/tools/git.ts

@@ -1,132 +0,0 @@
-/**
- * Git Tool - Git operations
- */
-
-import type { Tool, ToolResult } from './types.js';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { existsSync } from 'fs';
-
-const execAsync = promisify(exec);
-
-export class GitTool implements Tool {
-  name = 'git';
-  description = 'Git operations: status, log, diff, commit, branch, etc.';
-
-  inputSchema = {
-    type: 'object' as const,
-    properties: {
-      action: { type: 'string', description: 'Git action: status, log, diff, commit, branch, checkout, pull, push' },
-      args: { type: 'string', description: 'Additional arguments' },
-      message: { type: 'string', description: 'Commit message' },
-      cwd: { type: 'string', description: 'Working directory' }
-    },
-    required: ['action']
-  };
-
-  metadata = {
-    permissions: ['execute'] as ('read' | 'write' | 'execute' | 'network')[],
-    tags: ['git', 'vcs'],
-    version: '1.0.0'
-  };
-
-  parameters = [
-    { name: 'action', type: 'string', description: 'Git action: status, log, diff, commit, branch, checkout, pull, push', required: true },
-    { name: 'args', type: 'string', description: 'Additional arguments', required: false },
-    { name: 'message', type: 'string', description: 'Commit message (for commit action)', required: false },
-    { name: 'cwd', type: 'string', description: 'Working directory', required: false }
-  ];
-
-  async execute(params: Record<string, any>): Promise<ToolResult> {
-    const { action, args, message, cwd } = params;
-    const workDir = cwd || process.cwd();
-    
-    // Check if git repo exists
-    if (!existsSync(`${workDir}/.git`)) {
-      return { success: false, error: 'Not a git repository' };
-    }
-    
-    try {
-      switch (action) {
-        case 'status':
-          return await this.status(workDir);
-        case 'log':
-          return await this.log(workDir, args || '10');
-        case 'diff':
-          return await this.diff(workDir, args || '');
-        case 'commit':
-          return await this.commit(workDir, message || args);
-        case 'branch':
-          return await this.branch(workDir);
-        case 'checkout':
-          return await this.checkout(workDir, args);
-        case 'pull':
-          return await this.pull(workDir);
-        case 'push':
-          return await this.push(workDir);
-        case 'add':
-          return await this.add(workDir, args || '.');
-        default:
-          return { success: false, error: `Unknown action: ${action}` };
-      }
-    } catch (error: any) {
-      return { success: false, error: error.message };
-    }
-  }
-
-  private async status(cwd: string): Promise<ToolResult> {
-    const { stdout } = await execAsync('git status --short', { cwd });
-    return { success: true, output: stdout || '(clean)' };
-  }
-
-  private async log(cwd: string, limit: string): Promise<ToolResult> {
-    const { stdout } = await execAsync(`git log --oneline -n ${limit}`, { cwd });
-    return { success: true, output: stdout || 'No commits yet' };
-  }
-
-  private async diff(cwd: string, args: string): Promise<ToolResult> {
-    const { stdout } = await execAsync(`git diff ${args}`, { cwd });
-    return { success: true, output: stdout || 'No changes' };
-  }
-
-  private async commit(cwd: string, message: string): Promise<ToolResult> {
-    if (!message) {
-      return { success: false, error: 'Commit message required' };
-    }
-    
-    // Stage all changes
-    await execAsync('git add -A', { cwd });
-    
-    const { stdout } = await execAsync(`git commit -m "${message}"`, { cwd });
-    return { success: true, output: stdout || 'Committed successfully' };
-  }
-
-  private async branch(cwd: string): Promise<ToolResult> {
-    const { stdout } = await execAsync('git branch -a', { cwd });
-    return { success: true, output: stdout };
-  }
-
-  private async checkout(cwd: string, branch: string): Promise<ToolResult> {
-    if (!branch) {
-      return { success: false, error: 'Branch name required' };
-    }
-    
-    const { stdout } = await execAsync(`git checkout ${branch}`, { cwd });
-    return { success: true, output: stdout };
-  }
-
-  private async pull(cwd: string): Promise<ToolResult> {
-    const { stdout } = await execAsync('git pull', { cwd });
-    return { success: true, output: stdout };
-  }
-
-  private async push(cwd: string): Promise<ToolResult> {
-    const { stdout } = await execAsync('git push', { cwd });
-    return { success: true, output: stdout };
-  }
-
-  private async add(cwd: string, files: string): Promise<ToolResult> {
-    const { stdout } = await execAsync(`git add ${files}`, { cwd });
-    return { success: true, output: stdout || 'Added successfully' };
-  }
-}

package/src/tools/index.ts

@@ -1,108 +0,0 @@
-/**
- * Tool Registry - Manages available tools
- * Migrated from old src/core/tool-registry.ts + src/tools/index.ts
- */
-
-import type { Tool, ToolResult, ToolContext, ToolInputSchema } from './types.js';
-import { FileTool } from './file.js';
-import { ShellTool } from './shell.js';
-import { GitTool } from './git.js';
-import { SearchTool } from './search.js';
-
-export class ToolRegistry {
-  private tools: Map<string, Tool> = new Map();
-  private context: ToolContext = {};
-
-  constructor() {
-    this.registerDefaults();
-  }
-
-  /**
-   * Register default built-in tools
-   */
-  private registerDefaults(): void {
-    this.register(new FileTool());
-    this.register(new ShellTool());
-    this.register(new GitTool());
-    this.register(new SearchTool());
-  }
-
-  setContext(ctx: Partial<ToolContext>): void {
-    this.context = { ...this.context, ...ctx };
-  }
-
-  register(tool: Tool): void {
-    this.tools.set(tool.name, tool);
-  }
-
-  unregister(name: string): boolean {
-    return this.tools.delete(name);
-  }
-
-  get(name: string): Tool | undefined {
-    return this.tools.get(name);
-  }
-
-  list(): Tool[] {
-    return [...this.tools.values()];
-  }
-
-  listNames(): string[] {
-    return [...this.tools.keys()];
-  }
-
-  /**
-   * Get tools formatted for AI API
-   */
-  getToolsForAPI(): Array<{ type: 'function'; function: any }> {
-    return [...this.tools.values()].map(tool => ({
-      type: 'function' as const,
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.inputSchema || this.buildInputSchema(tool),
-      },
-    }));
-  }
-
-  /**
-   * Build JSON Schema from legacy parameters array
-   */
-  private buildInputSchema(tool: Tool): ToolInputSchema {
-    return {
-      type: 'object',
-      properties: tool.parameters.reduce((acc, p) => {
-        acc[p.name] = {
-          type: p.type === 'number' ? 'number' : p.type === 'boolean' ? 'boolean' : 'string',
-          description: p.description,
-        };
-        return acc;
-      }, {} as Record<string, { type: string; description: string }>),
-      required: tool.parameters.filter(p => p.required).map(p => p.name),
-    };
-  }
-
-  /**
-   * Execute a tool by name
-   */
-  async execute(name: string, params: Record<string, any>): Promise<ToolResult> {
-    const tool = this.tools.get(name);
-    if (!tool) {
-      return { success: false, error: `Tool "${name}" not found` };
-    }
-
-    try {
-      return await tool.execute(params, this.context);
-    } catch (error: any) {
-      return { success: false, error: error.message };
-    }
-  }
-}
-
-// Re-export types and tools
-export type { Tool, ToolResult, ToolContext, ToolParameter, ToolInputSchema, ToolMetadata } from './types.js';
-export { ToolBuilder } from './types.js';
-export { FileTool } from './file.js';
-export { ShellTool } from './shell.js';
-export { GitTool } from './git.js';
-export { SearchTool } from './search.js';

package/src/tools/search.ts

@@ -1,263 +0,0 @@
-/**
- * Search Tool - Code search and file operations
- */
-
-import type { Tool, ToolResult } from './types.js';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { readdirSync, statSync, readFileSync } from 'fs';
-import { join, relative } from 'path';
-
-const execAsync = promisify(exec);
-
-export class SearchTool implements Tool {
-  name = 'search';
-  description = 'Search and find: grep, find files, list directory tree';
-  
-  parameters = [
-    { name: 'action', type: 'string', description: 'Action: grep, find, tree, files', required: true },
-    { name: 'pattern', type: 'string', description: 'Search pattern or file pattern', required: false },
-    { name: 'path', type: 'string', description: 'Directory to search in', required: false },
-    { name: 'options', type: 'string', description: 'Additional options', required: false }
-  ];
-
-  async execute(params: Record<string, any>): Promise<ToolResult> {
-    const { action, pattern, path, options } = params;
-    const workDir = path || process.cwd();
-    
-    try {
-      switch (action) {
-        case 'grep':
-        case 'search':
-          return await this.grep(pattern || '', workDir, options || '');
-        
-        case 'find':
-          return await this.find(pattern || '*', workDir);
-        
-        case 'tree':
-          return await this.tree(workDir, parseInt(options) || 3);
-        
-        case 'files':
-          return await this.listFiles(workDir, pattern || '*');
-        
-        default:
-          return { success: false, error: `Unknown action: ${action}` };
-      }
-    } catch (error: any) {
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Grep - search for pattern in files
-   */
-  private async grep(pattern: string, path: string, options: string): Promise<ToolResult> {
-    if (!pattern) {
-      return { success: false, error: 'Pattern required' };
-    }
-    
-    // Build grep command
-    let cmd = `grep -rn "${pattern}" "${path}"`;
-    
-    if (options?.includes('i')) cmd += ' -i';  // Case insensitive
-    if (options?.includes('w')) cmd += ' -w';  // Whole word
-    if (options?.includes('l')) cmd += ' -l';  // Files only
-    if (options?.includes('n')) cmd += ' -n';  // Line numbers
-    
-    cmd += ' --color=never';
-    
-    try {
-      const { stdout, stderr } = await execAsync(cmd, { timeout: 30000 });
-      
-      if (!stdout && stderr) {
-        return { success: false, error: stderr };
-      }
-      
-      const lines = (stdout || '').split('\n').filter(l => l.trim());
-      
-      if (lines.length === 0) {
-        return { success: true, output: 'No matches found' };
-      }
-      
-      // Limit output
-      const limited = lines.slice(0, 50);
-      const output = limited.join('\n');
-      
-      return { 
-        success: true, 
-        output: lines.length > 50 
-          ? output + `\n... and ${lines.length - 50} more matches`
-          : output 
-      };
-      
-    } catch (error: any) {
-      if (error.killed) {
-        return { success: false, error: 'Search timed out (>30s)' };
-      }
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Find - find files by pattern
-   */
-  private async find(pattern: string, path: string): Promise<ToolResult> {
-    if (!pattern) {
-      pattern = '*';
-    }
-    
-    const results: string[] = [];
-    
-    const search = (dir: string, depth: number) => {
-      if (depth > 5) return; // Max depth
-      
-      try {
-        const items = readdirSync(dir);
-        
-        for (const item of items) {
-          // Skip common ignored directories
-          if (item === 'node_modules' || item === '.git' || item === 'dist' || item === 'build') {
-            continue;
-          }
-          
-          const fullPath = join(dir, item);
-          
-          try {
-            const stat = statSync(fullPath);
-            
-            if (stat.isDirectory()) {
-              // Check if matches pattern
-              if (this.matchPattern(item, pattern)) {
-                results.push(fullPath);
-              }
-              search(fullPath, depth + 1);
-            } else if (stat.isFile()) {
-              if (this.matchPattern(item, pattern)) {
-                results.push(fullPath);
-              }
-            }
-          } catch {
-            // Skip inaccessible files
-          }
-        }
-      } catch {
-        // Skip inaccessible directories
-      }
-    };
-    
-    search(path, 0);
-    
-    if (results.length === 0) {
-      return { success: true, output: 'No files found' };
-    }
-    
-    const limited = results.slice(0, 100);
-    const output = limited.join('\n');
-    
-    return {
-      success: true,
-      output: results.length > 100
-        ? output + `\n... and ${results.length - 100} more files`
-        : output
-    };
-  }
-
-  /**
-   * Tree - show directory structure
-   */
-  private async tree(path: string, maxDepth: number): Promise<ToolResult> {
-    const lines: string[] = [];
-    
-    const walk = (dir: string, prefix: string, depth: number) => {
-      if (depth > maxDepth) return;
-      
-      try {
-        const items = readdirSync(dir).filter(i => 
-          !i.startsWith('.') && i !== 'node_modules' && i !== 'dist'
-        );
-        
-        for (let i = 0; i < items.length; i++) {
-          const item = items[i];
-          const fullPath = join(dir, item);
-          const isLast = i === items.length - 1;
-          const connector = isLast ? '└── ' : '├── ';
-          
-          lines.push(prefix + connector + item);
-          
-          try {
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-              const newPrefix = prefix + (isLast ? '    ' : '│   ');
-              walk(fullPath, newPrefix, depth + 1);
-            }
-          } catch {
-            // Skip
-          }
-        }
-      } catch {
-        // Skip inaccessible
-      }
-    };
-    
-    lines.push(relative(process.cwd(), path) || '.');
-    walk(path, '', 0);
-    
-    return { success: true, output: lines.join('\n') };
-  }
-
-  /**
-   * List files in directory
-   */
-  private async listFiles(path: string, pattern: string): Promise<ToolResult> {
-    const files: string[] = [];
-    
-    const scan = (dir: string) => {
-      try {
-        const items = readdirSync(dir);
-        
-        for (const item of items) {
-          if (item === 'node_modules' || item === '.git') continue;
-          
-          const fullPath = join(dir, item);
-          
-          try {
-            const stat = statSync(fullPath);
-            if (stat.isFile() && this.matchPattern(item, pattern)) {
-              files.push(relative(process.cwd(), fullPath));
-            }
-          } catch {
-            // Skip
-          }
-        }
-      } catch {
-        // Skip
-      }
-    };
-    
-    scan(path);
-    
-    if (files.length === 0) {
-      return { success: true, output: 'No files found' };
-    }
-    
-    return { success: true, output: files.join('\n') };
-  }
-
-  /**
-   * Simple glob-like pattern matching
-   */
-  private matchPattern(filename: string, pattern: string): boolean {
-    if (pattern === '*') return true;
-    
-    // Convert glob to regex
-    const regex = new RegExp(
-      '^' + pattern
-        .replace(/\./g, '\\.')
-        .replace(/\*/g, '.*')
-        .replace(/\?/g, '.') + '$',
-      'i'
-    );
-    
-    return regex.test(filename);
-  }
-}