thatgfsj-code 0.3.0

package/install.sh

@@ -0,0 +1,113 @@
+#!/bin/bash
+# Thatgfsj Code Installer for macOS/Linux
+# Usage: curl -sL https://raw.githubusercontent.com/Thatgfsj/thatgfsj-code/main/install.sh | bash
+
+set -e
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+echo ""
+echo -e "${CYAN}  Thatgfsj Code 安装向导${NC}"
+echo -e "${CYAN}  =======================${NC}"
+echo ""
+
+# ============== Step 1: Check Node.js ==============
+echo -e "${YELLOW}[*] 检查 Node.js...${NC}"
+
+if command -v node &> /dev/null; then
+    NODE_VERSION=$(node --version)
+    MAJOR_VERSION=$(echo $NODE_VERSION | cut -d'v' -f2 | cut -d'.' -f1)
+    if [ "$MAJOR_VERSION" -ge 18 ]; then
+        echo -e "${GREEN}[✓] Node.js $NODE_VERSION 已安装${NC}"
+    else
+        echo -e "${RED}[✗] Node.js 版本过低，需要 v18+${NC}"
+        echo "    请访问 https://nodejs.org 升级"
+        exit 1
+    fi
+else
+    echo -e "${YELLOW}[*] 未检测到 Node.js，开始安装...${NC}"
+    
+    # Try Homebrew (macOS)
+    if command -v brew &> /dev/null; then
+        echo -e "${YELLOW}[*] 使用 Homebrew 安装...${NC}"
+        brew install node
+    # Try apt (Ubuntu/Debian)
+    elif command -v apt-get &> /dev/null; then
+        echo -e "${YELLOW}[*] 使用 apt 安装...${NC}"
+        curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
+        sudo apt-get install -y nodejs
+    # Try yum (CentOS/RHEL)
+    elif command -v yum &> /dev/null; then
+        echo -e "${YELLOW}[*] 使用 yum 安装...${NC}"
+        curl -fsSL https://rpm.nodesource.com/setup_20.x | sudo bash -
+        sudo yum install -y nodejs
+    else
+        echo -e "${RED}[✗] 未找到包管理器${NC}"
+        echo "    请手动安装: https://nodejs.org"
+        exit 1
+    fi
+fi
+
+# ============== Step 2: Clone/Update ==============
+echo -e "${YELLOW}[*] 准备安装 Thatgfsj Code...${NC}"
+
+INSTALL_DIR="$HOME/thatgfsj-code"
+
+if [ -d "$INSTALL_DIR" ]; then
+    echo -e "${YELLOW}[*] 检测到已有安装，正在更新...${NC}"
+    cd "$INSTALL_DIR"
+    git pull origin main 2>/dev/null || {
+        echo -e "${YELLOW}[*] 更新失败，重新克隆...${NC}"
+        rm -rf "$INSTALL_DIR"
+    }
+fi
+
+if [ ! -d "$INSTALL_DIR" ]; then
+    echo -e "${YELLOW}[*] 克隆仓库...${NC}"
+    git clone https://github.com/Thatgfsj/thatgfsj-code.git "$INSTALL_DIR"
+fi
+
+cd "$INSTALL_DIR"
+
+if [ ! -f "package.json" ]; then
+    echo -e "${RED}[✗] 安装目录无效${NC}"
+    exit 1
+fi
+
+echo -e "${GREEN}[✓] 代码准备完成: $INSTALL_DIR${NC}"
+
+# ============== Step 3: Install Dependencies ==============
+echo -e "${YELLOW}[*] 安装依赖...${NC}"
+
+npm install
+npm run build
+
+echo -e "${GREEN}[✓] 依赖安装完成${NC}"
+
+# ============== Step 4: Link Command ==============
+echo -e "${YELLOW}[*] 设置命令...${NC}"
+
+npm link
+
+echo -e "${GREEN}[✓] 命令 'gfcode' 已可用${NC}"
+
+# ============== Done ==============
+echo ""
+echo -e "${CYAN}  ======================================${NC}"
+echo -e "${GREEN}  安装完成!${NC}"
+echo -e "${CYAN}  ======================================${NC}"
+echo ""
+echo -e "  ${WHITE}使用方法:${NC}"
+echo -e "    gfcode init          - 重新配置"
+echo -e "    gfcode               - 启动交互模式"
+echo -e "    gfcode '你的问题'    - 直接提问"
+echo -e "    gfcode explain '代码' - 解释代码"
+echo -e "    gfcode debug '代码'   - 调试代码"
+echo ""
+echo -e "  文档: ${CYAN}https://github.com/Thatgfsj/thatgfsj-code${NC}"
+echo ""

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "thatgfsj-code",
+  "version": "0.3.0",
+  "description": "Thatgfsj Code - AI Coding Assistant",
+  "main": "dist/cmd/index.js",
+  "type": "module",
+  "bin": {
+    "thatgfsj": "./dist/cmd/index.js",
+    "gfcode": "./dist/cmd/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/cmd/index.js",
+    "dev": "tsc && node dist/cmd/index.js",
+    "link": "npm link"
+  },
+  "keywords": [
+    "ai",
+    "cli",
+    "coding",
+    "assistant"
+  ],
+  "author": "Thatgfsj",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "inquirer": "^13.3.2",
+    "ora": "^7.0.1",
+    "readline": "^1.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  }
+}

package/src/app/agent.ts

@@ -0,0 +1,140 @@
+/**
+ * Agent Loop - Core agent logic with streaming and tool execution
+ * Extracted from old src/core/ai-engine.ts
+ *
+ * The agent loop: while(true) { stream response → check tool calls → execute → repeat }
+ */
+
+import chalk from 'chalk';
+import type { ChatMessage, ChatResponse } from '../types.js';
+import type { Tool } from '../tools/types.js';
+import type { HookManager } from '../hooks/index.js';
+import { LLMService } from '../llm/index.js';
+import { ToolRegistry } from '../tools/index.js';
+
+export interface AgentConfig {
+  maxIterations?: number;
+  hooks?: HookManager;
+}
+
+export class Agent {
+  private llm: LLMService;
+  private registry: ToolRegistry;
+  private hooks?: HookManager;
+  private maxIterations: number;
+
+  constructor(llm: LLMService, registry: ToolRegistry, config: AgentConfig = {}) {
+    this.llm = llm;
+    this.registry = registry;
+    this.hooks = config.hooks;
+    this.maxIterations = config.maxIterations ?? 10;
+
+    // Register tools with LLM service
+    this.llm.registerTools(registry.list());
+  }
+
+  /**
+   * Run agent loop with streaming output
+   * Returns the final response
+   */
+  async *run(messages: ChatMessage[]): AsyncGenerator<string, ChatResponse> {
+    let currentMessages = [...messages];
+    let iterations = 0;
+
+    while (iterations < this.maxIterations) {
+      iterations++;
+
+      // Hook: beforeAgentLoop
+      if (this.hooks) {
+        await this.hooks.emit('beforeAgentLoop', { messages: currentMessages, iteration: iterations });
+      }
+
+      // Stream the response
+      let fullContent = '';
+
+      for await (const chunk of this.llm.chatStream(currentMessages, { maxIterations: 1 })) {
+        fullContent += chunk;
+        yield chunk;
+      }
+
+      // Get the full response to check for tool calls
+      const response: ChatResponse = {
+        content: fullContent,
+        role: 'assistant',
+      };
+
+      // Check if the response contains tool calls
+      // For now, we rely on the LLM service to handle tool calls internally
+      // If the LLM service returned tool_calls, we need to process them
+      if (response.tool_calls && response.tool_calls.length > 0) {
+        currentMessages.push({
+          role: 'assistant',
+          content: response.content,
+          tool_calls: response.tool_calls,
+        });
+
+        for (const toolCall of response.tool_calls) {
+          // Hook: beforeToolCall
+          if (this.hooks) {
+            await this.hooks.emit('beforeToolCall', {
+              toolName: toolCall.function.name,
+              toolParams: JSON.parse(toolCall.function.arguments || '{}'),
+              toolCallId: toolCall.id,
+            });
+          }
+
+          const result = await this.registry.execute(
+            toolCall.function.name,
+            JSON.parse(toolCall.function.arguments || '{}')
+          );
+
+          // Hook: afterToolCall
+          if (this.hooks) {
+            await this.hooks.emit('afterToolCall', {
+              toolName: toolCall.function.name,
+              toolParams: JSON.parse(toolCall.function.arguments || '{}'),
+              toolResult: result,
+              toolCallId: toolCall.id,
+            });
+          }
+
+          currentMessages.push({
+            role: 'tool',
+            content: result.success ? (result.output || JSON.stringify(result.data)) : (result.error || 'Tool failed'),
+            tool_call_id: toolCall.id,
+            name: toolCall.function.name,
+          });
+
+          yield `\n${chalk.gray(`[tool: ${toolCall.function.name}]`)}`;
+        }
+
+        continue; // Next iteration
+      }
+
+      // No tool calls - done
+      if (response.content) {
+        currentMessages.push({ role: 'assistant', content: response.content });
+      }
+
+      // Hook: afterAgentLoop
+      if (this.hooks) {
+        await this.hooks.emit('afterAgentLoop', { messages: currentMessages, iteration: iterations });
+      }
+
+      return response;
+    }
+
+    return { content: '[Agent loop exceeded maximum iterations]', role: 'assistant' };
+  }
+
+  /**
+   * Non-streaming chat (convenience method)
+   */
+  async chat(messages: ChatMessage[]): Promise<ChatResponse> {
+    let fullContent = '';
+    for await (const chunk of this.run(messages)) {
+      fullContent += chunk;
+    }
+    return { content: fullContent, role: 'assistant' };
+  }
+}

package/src/app/index.ts

@@ -0,0 +1,101 @@
+/**
+ * App - Core application singleton
+ * Assembles all services: config, LLM, session, tools, hooks, prompts
+ * Replaces the scattered initialization in old src/index.ts
+ */
+
+import { ConfigManager } from '../config/index.js';
+import { LLMService } from '../llm/index.js';
+import { SessionManager } from '../session/index.js';
+import { ToolRegistry } from '../tools/index.js';
+import { HookManager } from '../hooks/index.js';
+import { SystemPromptBuilder } from '../prompts/index.js';
+import { Agent } from './agent.js';
+import type { ChatMessage } from '../types.js';
+
+export class App {
+  config: ConfigManager;
+  llm: LLMService;
+  session: SessionManager;
+  tools: ToolRegistry;
+  hooks: HookManager;
+  prompts: SystemPromptBuilder;
+  private agent: Agent;
+
+  private constructor(
+    config: ConfigManager,
+    llm: LLMService,
+    session: SessionManager,
+    tools: ToolRegistry,
+    hooks: HookManager,
+    prompts: SystemPromptBuilder,
+    agent: Agent,
+  ) {
+    this.config = config;
+    this.llm = llm;
+    this.session = session;
+    this.tools = tools;
+    this.hooks = hooks;
+    this.prompts = prompts;
+    this.agent = agent;
+  }
+
+  /**
+   * Create and initialize the App
+   */
+  static async create(): Promise<App> {
+    // Load config
+    const config = await ConfigManager.load();
+    const aiConfig = config.getAIConfig();
+
+    // Create services
+    const llm = LLMService.fromConfig(aiConfig);
+    const session = new SessionManager();
+    const tools = new ToolRegistry();
+    const hooks = new HookManager();
+    const prompts = new SystemPromptBuilder({
+      cwd: process.cwd(),
+      tools: tools.list(),
+      permissionMode: 'ask',
+    });
+
+    // Create agent
+    const agent = new Agent(llm, tools, { hooks, maxIterations: 10 });
+
+    // Set up system prompt
+    session.addMessage('system', prompts.build());
+
+    return new App(config, llm, session, tools, hooks, prompts, agent);
+  }
+
+  /**
+   * Run a single prompt (non-interactive mode)
+   */
+  async runPrompt(prompt: string): Promise<string> {
+    this.session.addMessage('user', prompt);
+
+    let fullResponse = '';
+    for await (const chunk of this.agent.run(this.session.getMessages())) {
+      process.stdout.write(chunk);
+      fullResponse += chunk;
+    }
+
+    console.log(); // newline
+    this.session.addMessage('assistant', fullResponse);
+    return fullResponse;
+  }
+
+  /**
+   * Get the agent for streaming control
+   */
+  getAgent(): Agent {
+    return this.agent;
+  }
+
+  /**
+   * Get current config
+   */
+  getConfig(): ConfigManager {
+    return this.config;
+  }
+}

package/src/cmd/index.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+/**
+ * Thatgfsj Code - CLI Entry Point
+ * Simplified from old src/index.ts (655 lines → ~60 lines)
+ *
+ * Two modes:
+ *   gfcode              → Interactive REPL
+ *   gfcode "prompt"     → Single prompt mode
+ *   gfcode init         → Setup wizard
+ */
+
+// Force UTF-8 on Windows
+if (process.platform === 'win32') {
+  try {
+    require('child_process').execSync('chcp 65001', { stdio: 'ignore', windowsHide: true });
+  } catch {}
+}
+
+import { program } from 'commander';
+import chalk from 'chalk';
+import { App } from '../app/index.js';
+import { REPL } from '../tui/repl.js';
+import { WelcomeScreen } from '../tui/welcome.js';
+import { ProjectContext } from '../utils/project.js';
+
+// ==================== Error Handling ====================
+
+process.on('uncaughtException', (error) => {
+  console.error(chalk.red('\n❌ Error:'), error.message);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  console.error(chalk.red('\n❌ Error:'), reason);
+  process.exit(1);
+});
+
+// ==================== CLI Commands ====================
+
+program
+  .name('gfcode')
+  .description('🤖 Thatgfsj Code - AI Coding Assistant')
+  .version('0.3.0')
+  .argument('[prompt]', 'Task to execute (omit to start interactive mode)')
+  .option('-m, --model <model>', 'Specify model')
+  .option('-i, --interactive', 'Force interactive mode')
+  .option('--hooks', 'Enable audit logging hooks')
+  .action(async (prompt: string | undefined, options: { model?: string; interactive?: boolean; hooks?: boolean }) => {
+    try {
+      // Initialize app
+      const app = await App.create();
+
+      // Show welcome if no API key
+      WelcomeScreen.show(app.config.hasApiKey());
+
+      // Override model if specified
+      if (options.model) {
+        await app.config.save({ model: options.model });
+      }
+
+      // Enable hooks if requested
+      if (options.hooks) {
+        const { auditLogHook } = await import('../hooks/index.js');
+        app.hooks.register('afterToolCall', auditLogHook);
+      }
+
+      if (!prompt || options.interactive) {
+        // Interactive REPL mode
+        const repl = new REPL(app);
+        await repl.start();
+      } else {
+        // Single prompt mode
+        console.log(chalk.cyan('\n🤖 Thatgfsj Code\n'));
+        console.log(chalk.gray(ProjectContext.getSummary()));
+        console.log(chalk.gray('─'.repeat(40)));
+        console.log(chalk.cyan('\n> ') + prompt + '\n');
+
+        await app.runPrompt(prompt);
+      }
+    } catch (error: any) {
+      console.error(chalk.red(`\n❌ ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+// Init command - setup wizard
+program
+  .command('init')
+  .description('配置 API Key 和模型')
+  .action(async () => {
+    await WelcomeScreen.interactiveSetup();
+  });
+
+// Parse and run
+program.parse(process.argv);

package/src/config/index.ts

@@ -0,0 +1,130 @@
+/**
+ * Config Manager - Handles configuration loading and saving
+ * Migrated from old src/core/config.ts
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import type { Config, AIConfig, ProviderName } from './types.js';
+import { PROVIDERS, getApiKeyFromEnv } from './providers.js';
+
+const DEFAULT_CONFIG: Config = {
+  model: 'Qwen/Qwen2.5-7B-Instruct',
+  apiKey: '',
+  temperature: 0.7,
+  maxTokens: 4096,
+  provider: 'siliconflow',
+};
+
+export class ConfigManager {
+  private configPath: string;
+  private config: Config;
+
+  private constructor(configPath: string, config: Config) {
+    this.configPath = configPath;
+    this.config = config;
+  }
+
+  /**
+   * Load configuration from file + environment variables
+   */
+  static async load(): Promise<ConfigManager> {
+    const configDir = join(homedir(), '.thatgfsj');
+    const configPath = join(configDir, 'config.json');
+
+    let config = { ...DEFAULT_CONFIG };
+
+    // Load from file
+    try {
+      if (existsSync(configPath)) {
+        const data = readFileSync(configPath, 'utf-8');
+        config = { ...config, ...JSON.parse(data) };
+      }
+    } catch {
+      // Use defaults if file is corrupted
+    }
+
+    // Resolve provider
+    config = ConfigManager.resolveProvider(config);
+
+    return new ConfigManager(configPath, config);
+  }
+
+  /**
+   * Resolve provider settings: API key from env, base URL, model
+   */
+  private static resolveProvider(config: Config): Config {
+    const provider = config.provider || 'siliconflow';
+    const providerConfig = PROVIDERS[provider];
+
+    if (!providerConfig) {
+      return { ...config, provider: 'siliconflow', baseUrl: PROVIDERS.siliconflow.baseUrl };
+    }
+
+    // Model: env MODEL > config > provider default
+    const model = process.env.MODEL || config.model || providerConfig.defaultModel;
+
+    // API key: env > config
+    let apiKey = config.apiKey;
+    if (provider === 'ollama') {
+      apiKey = '';
+    } else if (!apiKey) {
+      apiKey = getApiKeyFromEnv(provider);
+    }
+
+    // Base URL: config > provider default
+    const baseUrl = config.baseUrl || providerConfig.baseUrl;
+
+    return { ...config, provider, baseUrl, model, apiKey: apiKey || '' };
+  }
+
+  /**
+   * Get the current config
+   */
+  get(): Config {
+    return { ...this.config };
+  }
+
+  /**
+   * Get AIConfig for LLM providers
+   */
+  getAIConfig(): AIConfig {
+    return {
+      model: this.config.model,
+      apiKey: this.config.apiKey,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      baseUrl: this.config.baseUrl,
+      provider: this.config.provider,
+    };
+  }
+
+  /**
+   * Get provider format (openai | anthropic | gemini)
+   */
+  getProviderFormat(): 'openai' | 'anthropic' | 'gemini' {
+    return PROVIDERS[this.config.provider]?.format || 'openai';
+  }
+
+  /**
+   * Update config and save to file
+   */
+  async save(updates: Partial<Config>): Promise<void> {
+    this.config = { ...this.config, ...updates };
+
+    const dir = dirname(this.configPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+  }
+
+  /**
+   * Check if an API key is configured
+   */
+  hasApiKey(): boolean {
+    return !!this.config.apiKey;
+  }
+}