thatgfsj-code 0.2.1

package/src/tools/search.ts

@@ -0,0 +1,263 @@
+/**
+ * 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

@@ -0,0 +1,181 @@
+/**
+ * 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

@@ -0,0 +1,202 @@
+/**
+ * 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

@@ -0,0 +1,8 @@
+/**
+ * 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';