thatgfsj-code 0.2.1 → 0.2.2

package/src/tools/search.ts

@@ -1,263 +0,0 @@
-/**
- * Search Tool - Code search and file operations
- */
-
-import { Tool, ToolResult } from '../core/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);
-  }
-}

package/src/tools/shell.ts

@@ -1,181 +0,0 @@
-/**
- * Shell Tool - Execute shell commands with security checks
- */
-
-import { Tool, ToolResult, ToolContext } from '../core/types.js';
-import { PermissionChecker } from '../core/permissions.js';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
-
-// Shared permission checker instance
-let permissionChecker: PermissionChecker | null = null;
-
-export function setPermissionChecker(checker: PermissionChecker) {
-  permissionChecker = checker;
-}
-
-const execAsync = promisify(exec);
-
-// Dangerous command patterns
-const DANGEROUS_PATTERNS = [
-  /^rm\s+-rf\s+\//i,           // rm -rf /
-  /^del\s+\/f\s+\/s\s+\/q/i,   // del /f /s /q
-  /^format\s+[a-z]:/i,         // format c:
-  /^mkfs/i,                     // mkfs
-  /^dd\s+if=/i,                 // dd if=
-  /^shred/i,                    // shred
-  /^cat\s+\/dev\/null\s*>/i,   // cat /dev/null >
-  />\s*\/dev\/sda/i,           // Write to disk
-  /^rm\s+-rf\s+\$HOME/i,       // rm -rf $HOME
-  /^rm\s+-rf\s+%USERPROFILE%/i // Windows user profile
-];
-
-// Commands that need confirmation
-const CONFIRM_REQUIRED = [
-  'rm -rf',
-  'rmdir',
-  'del /s /q',
-  'format',
-  'mkfs',
-  'dd',
-  'shutdown',
-  'restart',
-  'init 0',
-  'init 6',
-  'poweroff',
-  'reboot'
-];
-
-export class ShellTool implements Tool {
-  name = 'shell';
-  description = 'Execute shell commands and scripts. Use with caution - some commands require user confirmation.';
-
-  /** S02: Input schema for shell command */
-  inputSchema = {
-    type: 'object' as const,
-    properties: {
-      command: { type: 'string', description: 'Shell command to execute' },
-      cwd: { type: 'string', description: 'Working directory' },
-      timeout: { type: 'number', description: 'Timeout in seconds', default: 30 }
-    },
-    required: ['command']
-  };
-
-  /** S02: Tool metadata — permission and category info */
-  metadata = {
-    permissions: ['execute', 'write', 'network'] as ('read' | 'write' | 'execute' | 'network')[],
-    tags: ['shell', 'system', 'dangerous'],
-    maxDuration: 120000, // 2 min max
-    version: '1.0.0'
-  };
-
-  parameters = [
-    { name: 'command', type: 'string', description: 'Shell command to execute', required: true },
-    { name: 'cwd', type: 'string', description: 'Working directory', required: false },
-    { name: 'timeout', type: 'number', description: 'Timeout in seconds', required: false }
-  ];
-
-  /**
-   * Check if command is dangerous
-   */
-  private isDangerous(command: string): boolean {
-    return DANGEROUS_PATTERNS.some(pattern => pattern.test(command.trim()));
-  }
-
-  /**
-   * Check if command needs confirmation
-   */
-  private needsConfirmation(command: string): boolean {
-    const lower = command.toLowerCase();
-    return CONFIRM_REQUIRED.some(cmd => lower.includes(cmd.toLowerCase()));
-  }
-
-  /**
-   * Validate command before execution
-   */
-  private validateCommand(command: string): string | null {
-    if (!command || typeof command !== 'string') {
-      return 'Command is required and must be a string';
-    }
-
-    const trimmed = command.trim();
-    
-    // Check for dangerous commands
-    if (this.isDangerous(trimmed)) {
-      return `Dangerous command blocked: ${trimmed.substring(0, 50)}...`;
-    }
-
-    // Check command length
-    if (trimmed.length > 10000) {
-      return 'Command too long (max 10000 characters)';
-    }
-
-    return null;
-  }
-
-  async execute(params: Record<string, any>, ctx?: ToolContext): Promise<ToolResult> {
-    const { command, cwd, timeout = 30 } = params;
-
-    // Validate command
-    const validationError = this.validateCommand(command);
-    if (validationError) {
-      return { success: false, error: validationError };
-    }
-
-    // S03: 6-stage permission check
-    if (permissionChecker) {
-      const result = await permissionChecker.check('shell', params, ctx || {});
-      if (!result.allowed) {
-        return { success: false, error: `Permission denied: ${result.reason}` };
-      }
-      if (result.requiresConfirmation) {
-        // Ask user for confirmation
-        if (ctx?.confirmAction) {
-          const confirmed = await ctx.confirmAction(
-            `⚠️  Confirm command:\n  ${command}\n\n[y] Yes  [n] No`
-          );
-          if (!confirmed) {
-            return { success: false, error: 'Command cancelled by user' };
-          }
-        }
-      }
-    } else if (ctx?.confirmAction && this.needsConfirmation(command)) {
-      // Fallback confirmation
-      const confirmed = await ctx.confirmAction(`Execute this command?\n  ${command}\n\nType 'y' to confirm or 'n' to cancel:`);
-      if (!confirmed) {
-        return { success: false, error: 'Command cancelled by user' };
-      }
-    }
-
-    try {
-      const options: any = { 
-        timeout: timeout * 1000,
-        maxBuffer: 10 * 1024 * 1024 // 10MB
-      };
-      
-      if (cwd) {
-        options.cwd = cwd;
-      }
-
-      const { stdout, stderr } = await execAsync(command, options);
-      const stdoutStr = stdout?.toString() || '';
-      const stderrStr = stderr?.toString() || '';
-      
-      // Combine output, prioritize stdout
-      const output = stdoutStr + (stderrStr ? `\n[stderr]: ${stderrStr}` : '');
-      
-      return { success: true, output: output.trim() || '(command executed successfully with no output)' };
-      
-    } catch (error: any) {
-      // Handle timeout
-      if (error.killed) {
-        return { success: false, error: 'Command timed out' };
-      }
-      
-      return { 
-        success: false, 
-        error: error.message || 'Command execution failed' 
-      };
-    }
-  }
-}

package/src/utils/diff-preview.ts

@@ -1,202 +0,0 @@
-/**
- * Diff Preview - Show file changes before modification
- * Simple implementation without external dependencies
- */
-
-import { readFileSync, existsSync } from 'fs';
-
-export interface DiffResult {
-  hasChanges: boolean;
-  oldContent?: string;
-  newContent?: string;
-  diff?: string;
-  preview?: string;
-}
-
-export class DiffPreview {
-  /**
-   * Compare old and new content and generate diff
-   */
-  static compare(oldContent: string, newContent: string): DiffResult {
-    const oldLines = oldContent.split('\n');
-    const newLines = newContent.split('\n');
-    
-    const diff = this.computeDiff(oldLines, newLines);
-    
-    if (diff.length === 0) {
-      return { hasChanges: false };
-    }
-
-    return {
-      hasChanges: true,
-      oldContent,
-      newContent,
-      diff: this.formatDiff(diff),
-      preview: this.formatPreview(diff)
-    };
-  }
-
-  /**
-   * Compute simple line-by-line diff
-   */
-  private static computeDiff(oldLines: string[], newLines: string[]): DiffChunk[] {
-    const result: DiffChunk[] = [];
-    
-    // Simple LCS-based diff
-    const lcs = this.longestCommonSubsequence(oldLines, newLines);
-    
-    let oldIdx = 0;
-    let newIdx = 0;
-    let lcsIdx = 0;
-    
-    while (oldIdx < oldLines.length || newIdx < newLines.length) {
-      if (lcsIdx < lcs.length) {
-        // Output removed lines from old
-        while (oldIdx < oldLines.length && oldLines[oldIdx] !== lcs[lcsIdx]) {
-          result.push({ type: 'removed', content: oldLines[oldIdx] });
-          oldIdx++;
-        }
-        
-        // Output added lines from new
-        while (newIdx < newLines.length && newLines[newIdx] !== lcs[lcsIdx]) {
-          result.push({ type: 'added', content: newLines[newIdx] });
-          newIdx++;
-        }
-        
-        // Output common line
-        if (oldIdx < oldLines.length && newIdx < newLines.length) {
-          result.push({ type: 'unchanged', content: oldLines[oldIdx] });
-          oldIdx++;
-          newIdx++;
-          lcsIdx++;
-        }
-      } else {
-        // Remaining lines
-        while (oldIdx < oldLines.length) {
-          result.push({ type: 'removed', content: oldLines[oldIdx] });
-          oldIdx++;
-        }
-        while (newIdx < newLines.length) {
-          result.push({ type: 'added', content: newLines[newIdx] });
-          newIdx++;
-        }
-      }
-    }
-    
-    return result;
-  }
-
-  /**
-   * Find longest common subsequence
-   */
-  private static longestCommonSubsequence(a: string[], b: string[]): string[] {
-    const m = a.length;
-    const n = b.length;
-    const dp: number[][] = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
-    
-    for (let i = 1; i <= m; i++) {
-      for (let j = 1; j <= n; j++) {
-        if (a[i - 1] === b[j - 1]) {
-          dp[i][j] = dp[i - 1][j - 1] + 1;
-        } else {
-          dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
-        }
-      }
-    }
-    
-    // Backtrack to find LCS
-    const lcs: string[] = [];
-    let i = m, j = n;
-    while (i > 0 && j > 0) {
-      if (a[i - 1] === b[j - 1]) {
-        lcs.unshift(a[i - 1]);
-        i--;
-        j--;
-      } else if (dp[i - 1][j] > dp[i][j - 1]) {
-        i--;
-      } else {
-        j--;
-      }
-    }
-    
-    return lcs;
-  }
-
-  /**
-   * Show diff between file and proposed changes
-   */
-  static diffFile(filePath: string, newContent: string): DiffResult {
-    let oldContent = '';
-    
-    if (existsSync(filePath)) {
-      try {
-        oldContent = readFileSync(filePath, 'utf-8');
-      } catch {
-        // File exists but can't read
-      }
-    }
-    
-    return this.compare(oldContent, newContent);
-  }
-
-  /**
-   * Format diff for display with colors
-   */
-  private static formatDiff(diff: DiffChunk[]): string {
-    const lines: string[] = [];
-    const green = '\x1b[32m';
-    const red = '\x1b[31m';
-    const gray = '\x1b[90m';
-    const reset = '\x1b[0m';
-    
-    for (const chunk of diff) {
-      if (chunk.type === 'added') {
-        lines.push(`${green}+ ${chunk.content}${reset}`);
-      } else if (chunk.type === 'removed') {
-        lines.push(`${red}- ${chunk.content}${reset}`);
-      } else {
-        lines.push(`${gray}  ${chunk.content}${reset}`);
-      }
-    }
-    
-    return lines.join('\n');
-  }
-
-  /**
-   * Format a compact preview
-   */
-  private static formatPreview(diff: DiffChunk[]): string {
-    let added = 0;
-    let removed = 0;
-    
-    for (const chunk of diff) {
-      if (chunk.type === 'added') added++;
-      if (chunk.type === 'removed') removed++;
-    }
-    
-    const parts: string[] = [];
-    if (added > 0) parts.push(`+${added}`);
-    if (removed > 0) parts.push(`-${removed}`);
-    
-    return parts.join(' ') || 'No changes';
-  }
-
-  /**
-   * Check if changes are significant
-   */
-  static isSignificant(oldContent: string, newContent: string, threshold: number = 0.1): boolean {
-    if (!oldContent && !newContent) return false;
-    if (!oldContent || !newContent) return true;
-    
-    const oldLines = oldContent.split('\n').length;
-    const newLines = newContent.split('\n').length;
-    
-    const changeRatio = Math.abs(newLines - oldLines) / oldLines;
-    return changeRatio > threshold;
-  }
-}
-
-interface DiffChunk {
-  type: 'added' | 'removed' | 'unchanged';
-  content: string;
-}

package/src/utils/index.ts

@@ -1,8 +0,0 @@
-/**
- * Utils Module
- * Utility functions for diff, project context, and memory
- */
-
-export { DiffPreview, type DiffResult } from './diff-preview.js';
-export { ProjectContext, type ProjectInfo, type PackageJson } from './project-context.js';
-export { SessionMemory, type MemoryEntry } from './memory.js';