thatgfsj-code 3.0.3 → 3.0.6

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);
-  }
-}

package/src/tools/shell.ts

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

@@ -1,122 +0,0 @@
-/**
- * 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/app.tsx

@@ -1,159 +0,0 @@
-/** @jsxImportSource react */
-import React, { useState, useCallback, useEffect } from 'react';
-import { Box, Text, useStdout } from 'ink';
-import { Header } from './components/Header.js';
-import { ChatList } from './components/ChatList.js';
-import { Thinking } from './components/Thinking.js';
-import { UserInput } from './components/UserInput.js';
-import { StatusBar } from './components/StatusBar.js';
-import { ModelSelector } from './components/ModelSelector.js';
-import { InitWizard } from './components/InitWizard.js';
-import { useChat } from './hooks/useChat.js';
-import { useCommands } from './hooks/useCommands.js';
-import type { App } from '../app/index.js';
-import type { MessageData } from './components/ChatMessage.js';
-import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-
-interface Props {
-  app: App;
-}
-
-function saveModelToHistory(model: string) {
-  const dir = join(homedir(), '.thatgfsj');
-  const path = join(dir, 'models.json');
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  let history: string[] = [];
-  if (existsSync(path)) {
-    try { history = JSON.parse(readFileSync(path, 'utf-8')); } catch {}
-  }
-  if (!history.includes(model)) {
-    history.push(model);
-    writeFileSync(path, JSON.stringify(history, null, 2));
-  }
-}
-
-type ViewMode = 'chat' | 'model_select' | 'init_wizard';
-
-export function TuiApp({ app }: Props) {
-  const { messages, isThinking, streaming, streamingToolCalls, queuedMessage, sendMessage, cancel } = useChat(app);
-  const { handleCommand } = useCommands(app);
-  const [systemMessages, setSystemMessages] = useState<MessageData[]>([]);
-  const [viewMode, setViewMode] = useState<ViewMode>('chat');
-  const { stdout } = useStdout();
-  const terminalWidth = stdout?.columns || 80;
-
-  // v3.0.0: cache stats snapshot for the Header. Re-read whenever messages
-  // change (i.e. a round just completed and recorded new usage). Polling on
-  // an interval would be wasteful; React re-render is the trigger.
-  const [cacheSnapshot, setCacheSnapshot] = useState(() => app.cacheStats.snapshot());
-  // v3.0.3: resolved TTL (sticky per session). null until first round.
-  const [resolvedTtl, setResolvedTtl] = useState<'5m' | '1h' | null>(app.resolvedTtl);
-  // The user-pinned config TTL ('auto' | '5m' | '1h') — used to render the
-  // Header chip BEFORE the first round, when resolvedTtl is still null.
-  const configTtl = (app.config.get() as any).cache?.ttl as 'auto' | '5m' | '1h' | undefined;
-  useEffect(() => {
-    setCacheSnapshot(app.cacheStats.snapshot());
-    setResolvedTtl(app.resolvedTtl);
-  }, [messages.length]);
-
-  const addMsg = useCallback((content: string) => {
-    setSystemMessages(prev => [...prev, { role: 'assistant', content }]);
-  }, []);
-
-  const onSubmit = useCallback(async (input: string) => {
-    // Model selector - ignore text input
-    if (viewMode === 'model_select') return;
-
-    // Normal command handling
-    const result = handleCommand(input);
-
-    if (result.handled) {
-      if (input.trim() === '/模型' || input.trim() === '/model') {
-        setViewMode('model_select');
-        return;
-      }
-
-      if (result.output) {
-        setSystemMessages(prev => [
-          ...prev,
-          { role: 'user', content: input },
-          { role: 'assistant', content: result.output! },
-        ]);
-      }
-
-      if (result.action === 'clear') setSystemMessages([]);
-
-      if (result.action === 'reinit') {
-        setViewMode('init_wizard');
-      }
-
-      return;
-    }
-
-    sendMessage(input);
-  }, [handleCommand, sendMessage, app, viewMode, addMsg]);
-
-  const allMessages = [...systemMessages, ...messages];
-  const activeSkills = app.skills.listActive().map(s => s.id);
-
-  return (
-    <Box flexDirection="column" paddingX={1}>
-      <Header
-        provider={app.config.get().provider}
-        model={app.config.get().model}
-        cacheHitRate={cacheSnapshot.hitRate > 0 ? cacheSnapshot.hitRate : null}
-        cacheSavingsCNY={cacheSnapshot.estimatedSavingsCNY}
-        cacheTtl={resolvedTtl ?? configTtl ?? null}
-      />
-      <ChatList
-        messages={allMessages}
-        streaming={streaming}
-        streamingToolCalls={streamingToolCalls}
-        width={terminalWidth - 4}
-      />
-      <Thinking active={isThinking} />
-      {queuedMessage && (
-        <Box paddingLeft={1}>
-          <Text color="#F59E0B">📎 已排队: </Text>
-          <Text color="#94A3B8">{queuedMessage}</Text>
-        </Box>
-      )}
-      {viewMode === 'model_select' ? (
-        <ModelSelector
-          currentModel={app.config.get().model}
-          currentProvider={app.config.get().provider}
-          onSelect={(model) => {
-            app.config.save({ model });
-            saveModelToHistory(model);
-            setViewMode('chat');
-            addMsg(`模型已切换: ${model}`);
-          }}
-          onAddNew={() => setViewMode('init_wizard')}
-        />
-      ) : viewMode === 'init_wizard' ? (
-        // v3.0.1: InitWizard is now fully self-contained — it owns its own
-        // input handling via useInput + ink-text-input. No external UserInput
-        // is rendered here, and app.tsx no longer has the text-entry
-        // viewModes (init_key / init_url / init_custom_model) because they
-        // were the broken input-handling path that left users stuck on a
-        // frozen "输入 API Key" screen with no way to type.
-        <InitWizard
-          onComplete={(provider, model, apiKey, baseUrl) => {
-            app.config.save({ provider, model, apiKey, baseUrl });
-            saveModelToHistory(model);
-            setViewMode('chat');
-            addMsg(`配置完成: ${provider} / ${model}`);
-          }}
-          onCancel={() => setViewMode('chat')}
-        />
-      ) : (
-        <Box flexDirection="column">
-          <UserInput onSubmit={onSubmit} onCancel={cancel} disabled={false} />
-        </Box>
-      )}
-      <StatusBar messageCount={allMessages.length} skills={activeSkills} />
-    </Box>
-  );
-}