thatgfsj-code 0.3.0

package/src/tools/index.ts

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

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

package/src/tools/shell.ts

@@ -0,0 +1,136 @@
+/**
+ * Shell Tool - Execute shell commands with security checks
+ * Migrated from old src/tools/shell.ts (permission logic inlined)
+ */
+
+import type { Tool, ToolResult, ToolContext } from './types.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+// Dangerous command patterns - blocked immediately
+const DANGEROUS_PATTERNS = [
+  /^rm\s+-rf\s+\//i,
+  /^del\s+\/f\s+\/s\s+\/q/i,
+  /^format\s+[a-z]:/i,
+  /^mkfs/i,
+  /^dd\s+if=/i,
+  /^shred/i,
+  /^cat\s+\/dev\/null\s*>/i,
+  />\s*\/dev\/sda/i,
+  /^rm\s+-rf\s+\$HOME/i,
+  /^rm\s+-rf\s+%USERPROFILE%/i,
+  /^curl\s+.*\|.*sh/i,
+  /^wget\s+.*\|.*sh/i,
+  /^eval\s+/i,
+  /base64\s+-d\s+.*\|/i,
+];
+
+// Commands that need user confirmation
+const CONFIRM_REQUIRED = [
+  'rm -rf',
+  'rmdir',
+  'del /s /q',
+  'format',
+  'mkfs',
+  'dd',
+  'shutdown',
+  'reboot',
+  'pkill',
+  'killall',
+  'git push --force',
+  'git push -f',
+];
+
+export class ShellTool implements Tool {
+  name = 'shell';
+  description = 'Execute shell commands and scripts. Some commands require user confirmation.';
+
+  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'],
+  };
+
+  metadata = {
+    permissions: ['execute', 'write', 'network'] as ('read' | 'write' | 'execute' | 'network')[],
+    tags: ['shell', 'system', 'dangerous'],
+    maxDuration: 120000,
+    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 matches dangerous patterns
+   */
+  private isDangerous(command: string): boolean {
+    return DANGEROUS_PATTERNS.some(pattern => pattern.test(command.trim()));
+  }
+
+  /**
+   * Check if command needs user confirmation
+   */
+  private needsConfirmation(command: string): boolean {
+    const lower = command.toLowerCase();
+    return CONFIRM_REQUIRED.some(cmd => lower.includes(cmd.toLowerCase()));
+  }
+
+  async execute(params: Record<string, any>, ctx?: ToolContext): Promise<ToolResult> {
+    const { command, cwd, timeout = 30 } = params;
+
+    if (!command || typeof command !== 'string') {
+      return { success: false, error: 'Command is required and must be a string' };
+    }
+
+    const trimmed = command.trim();
+
+    // Block dangerous commands
+    if (this.isDangerous(trimmed)) {
+      return { success: false, error: `Blocked: dangerous command "${trimmed.substring(0, 50)}..."` };
+    }
+
+    if (trimmed.length > 10000) {
+      return { success: false, error: 'Command too long (max 10000 characters)' };
+    }
+
+    // Ask for confirmation on risky commands
+    if (ctx?.confirmAction && this.needsConfirmation(trimmed)) {
+      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' };
+      }
+    }
+
+    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() || '';
+      const output = stdoutStr + (stderrStr ? `\n[stderr]: ${stderrStr}` : '');
+
+      return { success: true, output: output.trim() || '(command executed successfully with no output)' };
+    } catch (error: any) {
+      if (error.killed) {
+        return { success: false, error: 'Command timed out' };
+      }
+      return { success: false, error: error.message || 'Command execution failed' };
+    }
+  }
+}

package/src/tools/types.ts

@@ -0,0 +1,122 @@
+/**
+ * Tool interface definitions
+ * Extracted from old src/core/types.ts
+ */
+
+// ==================== Tool Parameter & Schema ====================
+
+export interface ToolParameter {
+  name: string;
+  type: string;
+  description: string;
+  required: boolean;
+  default?: any;
+  enum?: string[];
+}
+
+export interface ToolInputSchema {
+  type: 'object';
+  properties: Record<string, {
+    type: string;
+    description: string;
+    default?: any;
+    enum?: string[];
+  }>;
+  required?: string[];
+}
+
+export interface ToolMetadata {
+  permissions?: ('read' | 'write' | 'execute' | 'network')[];
+  maxDuration?: number;
+  tags?: string[];
+  version?: string;
+  deprecated?: string;
+}
+
+// ==================== Tool Interface ====================
+
+export interface ToolContext {
+  sessionId?: string;
+  workingDirectory?: string;
+  confirmAction?: (msg: string) => Promise<boolean>;
+  signal?: AbortSignal;
+  toolCallId?: string;
+}
+
+export interface ToolResult {
+  success: boolean;
+  output?: string;
+  error?: string;
+  data?: any;
+}
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: ToolParameter[];
+  inputSchema?: ToolInputSchema;
+  metadata?: ToolMetadata;
+  execute(params: Record<string, any>, ctx?: ToolContext): Promise<ToolResult>;
+}
+
+// ==================== Tool Builder ====================
+
+export class ToolBuilder {
+  private _name = '';
+  private _description = '';
+  private _parameters: ToolParameter[] = [];
+  private _inputSchema: ToolInputSchema = { type: 'object', properties: {} };
+  private _metadata: ToolMetadata = {};
+  private _fn?: (params: Record<string, any>, ctx: ToolContext) => Promise<ToolResult>;
+
+  name(n: string): this { this._name = n; return this; }
+  description(d: string): this { this._description = d; return this; }
+
+  param(p: ToolParameter): this {
+    this._parameters.push(p);
+    this._inputSchema.properties[p.name] = {
+      type: p.type,
+      description: p.description,
+      default: p.default,
+      enum: p.enum,
+    };
+    return this;
+  }
+
+  stringParam(name: string, description: string, required = true, defaultVal?: string): this {
+    return this.param({ name, type: 'string', description, required, default: defaultVal });
+  }
+
+  booleanParam(name: string, description: string, required = false, defaultVal?: boolean): this {
+    return this.param({ name, type: 'boolean', description, required, default: defaultVal });
+  }
+
+  permissions(...perms: ('read' | 'write' | 'execute' | 'network')[]): this {
+    this._metadata.permissions = perms;
+    return this;
+  }
+
+  tags(...t: string[]): this {
+    this._metadata.tags = t;
+    return this;
+  }
+
+  handle(fn: (params: Record<string, any>, ctx: ToolContext) => Promise<ToolResult>): this {
+    this._fn = fn;
+    return this;
+  }
+
+  build(): Tool {
+    if (!this._name || !this._fn) {
+      throw new Error('Tool name and handler are required');
+    }
+    return {
+      name: this._name,
+      description: this._description,
+      parameters: this._parameters,
+      inputSchema: this._inputSchema,
+      metadata: this._metadata,
+      execute: this._fn,
+    };
+  }
+}

package/src/tui/index.ts

@@ -0,0 +1,8 @@
+/**
+ * TUI Module - Terminal User Interface
+ */
+
+export { REPL } from './repl.js';
+export { REPLInput } from './input.js';
+export { REPLOutput } from './output.js';
+export { WelcomeScreen } from './welcome.js';

package/src/tui/input.ts

@@ -0,0 +1,56 @@
+/**
+ * REPL Input Handler
+ * Migrated from old src/repl/input.ts
+ */
+
+import readline from 'readline';
+import chalk from 'chalk';
+
+export class REPLInput {
+  private rl: readline.Interface;
+  private history: string[] = [];
+  private historyIndex: number = -1;
+
+  constructor() {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      completer: this.completer.bind(this),
+      historySize: 100,
+      tabSize: 4,
+    });
+
+    // Handle Ctrl+C
+    this.rl.on('SIGINT', () => {
+      process.stdout.write(chalk.gray('\n\n👋 Exiting...\n'));
+      process.exit(0);
+    });
+
+    // Track history
+    this.rl.on('line', (line) => {
+      if (line.trim()) {
+        this.history.push(line);
+        if (this.history.length > 100) this.history.shift();
+      }
+      this.historyIndex = this.history.length;
+    });
+  }
+
+  async prompt(prefix: string = chalk.green('\n> ')): Promise<string> {
+    return new Promise((resolve) => {
+      this.rl.question(prefix, (answer) => {
+        resolve(answer);
+      });
+    });
+  }
+
+  close(): void {
+    this.rl.close();
+  }
+
+  private completer(line: string): [string[], string] {
+    const commands = ['exit', 'quit', 'clear', 'help', 'tools', 'model'];
+    const hits = commands.filter(c => c.startsWith(line.toLowerCase()));
+    return [hits.length ? hits : [], line];
+  }
+}