thatgfsj-code 0.3.0

package/src/tui/output.ts

@@ -0,0 +1,83 @@
+/**
+ * REPL Output Handler
+ * Migrated from old src/repl/output.ts
+ */
+
+import chalk from 'chalk';
+import ora, { Ora } from 'ora';
+
+export class REPLOutput {
+  private spinner: Ora | null = null;
+
+  printError(error: string): void {
+    console.error(chalk.red(`\n❌ Error: ${error}`));
+  }
+
+  printWarning(warning: string): void {
+    console.warn(chalk.yellow(`\n⚠️  ${warning}`));
+  }
+
+  printSuccess(message: string): void {
+    console.log(chalk.green(`\n✅ ${message}`));
+  }
+
+  printInfo(message: string): void {
+    console.log(chalk.gray(message));
+  }
+
+  printDivider(char = '─', length = 40): void {
+    console.log(chalk.gray(char.repeat(length)));
+  }
+
+  printHeader(text: string): void {
+    this.printDivider();
+    console.log(chalk.cyan(text));
+    this.printDivider();
+  }
+
+  startSpinner(text: string): void {
+    this.spinner = ora({ text, color: 'cyan', spinner: 'dots' }).start();
+  }
+
+  stopSpinner(): void {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+
+  stopSpinnerFail(text?: string): void {
+    if (this.spinner) {
+      this.spinner.fail(text || this.spinner.text);
+      this.spinner = null;
+    }
+  }
+
+  clear(): void {
+    console.clear();
+  }
+
+  printBanner(): void {
+    console.log(chalk.cyan(`
+╔═══════════════════════════════════════╗
+║     🤖 Thatgfsj Code v0.3.0        ║
+║     AI Coding Assistant              ║
+╚═══════════════════════════════════════╝
+    `));
+  }
+
+  printHelp(): void {
+    console.log(`
+${chalk.cyan('Commands:')}
+  ${chalk.gray('exit, Ctrl+C')}  - Exit
+  ${chalk.gray('clear')}           - Clear screen
+  ${chalk.gray('help')}            - Show this help
+  ${chalk.gray('tools')}            - List available tools
+  ${chalk.gray('model')}            - Show current model
+
+${chalk.cyan('Tips:')}
+  • Use ${chalk.gray('↑/↓')} for command history
+  • Use ${chalk.gray('Tab')} for auto-complete
+    `);
+  }
+}

package/src/tui/repl.ts

@@ -0,0 +1,131 @@
+/**
+ * REPL - Main interactive loop
+ * Migrated from old src/repl/loop.ts + src/index.ts interactive mode
+ */
+
+import chalk from 'chalk';
+import { REPLInput } from './input.js';
+import { REPLOutput } from './output.js';
+import { App } from '../app/index.js';
+import { ProjectContext } from '../utils/project.js';
+
+export class REPL {
+  private input: REPLInput;
+  private output: REPLOutput;
+  private app: App;
+  private running = false;
+
+  constructor(app: App) {
+    this.input = new REPLInput();
+    this.output = new REPLOutput();
+    this.app = app;
+  }
+
+  /**
+   * Start the REPL
+   */
+  async start(): Promise<void> {
+    this.running = true;
+
+    // Show banner
+    this.output.clear();
+    this.output.printBanner();
+    this.output.printInfo('Type "help" for available commands\n');
+    this.output.printDivider();
+
+    // Show project context
+    console.log(chalk.gray(ProjectContext.getSummary()));
+    this.output.printDivider();
+    console.log();
+
+    // Main loop
+    while (this.running) {
+      try {
+        const userInput = await this.input.prompt();
+
+        if (!userInput.trim()) continue;
+
+        // Handle commands
+        const handled = await this.handleCommand(userInput.trim());
+        if (handled) continue;
+
+        // Process with AI
+        await this.processInput(userInput.trim());
+      } catch (error: any) {
+        if (error.message === 'SIGINT') continue;
+        this.output.printError(error.message);
+      }
+    }
+  }
+
+  /**
+   * Handle built-in commands
+   */
+  private async handleCommand(input: string): Promise<boolean> {
+    const cmd = input.toLowerCase();
+
+    switch (cmd) {
+      case 'exit':
+      case 'quit':
+        this.output.printInfo('\n👋 Goodbye!');
+        this.running = false;
+        this.input.close();
+        return true;
+
+      case 'clear':
+        this.output.clear();
+        this.output.printBanner();
+        return true;
+
+      case 'help':
+        this.output.printHelp();
+        return true;
+
+      case 'tools':
+        this.output.printHeader('🔧 Available Tools');
+        for (const tool of this.app.tools.list()) {
+          this.output.printInfo(`  ${tool.name} - ${tool.description}`);
+        }
+        console.log();
+        return true;
+
+      case 'model':
+        this.output.printHeader('🤖 Current Model');
+        const cfg = this.app.config.get();
+        this.output.printInfo(`  Provider: ${cfg.provider}`);
+        this.output.printInfo(`  Model: ${cfg.model}`);
+        this.output.printInfo(`  Base URL: ${cfg.baseUrl || 'default'}`);
+        console.log();
+        return true;
+
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Process user input with AI
+   */
+  private async processInput(input: string): Promise<void> {
+    this.app.session.addMessage('user', input);
+
+    this.output.startSpinner('Thinking...');
+    let fullResponse = '';
+
+    try {
+      const stream = this.app.getAgent().run(this.app.session.getMessages());
+      for await (const chunk of stream) {
+        this.output.stopSpinner();
+        process.stdout.write(chunk);
+        fullResponse += chunk;
+      }
+
+      console.log(); // newline
+
+      this.app.session.addMessage('assistant', fullResponse);
+      this.app.session.truncate();
+    } catch (error: any) {
+      this.output.stopSpinnerFail(chalk.red(`Error: ${error.message}`));
+    }
+  }
+}

package/src/tui/welcome.ts

@@ -0,0 +1,101 @@
+/**
+ * Welcome / Setup Wizard
+ * Migrated and simplified from old src/repl/welcome.ts
+ */
+
+import chalk from 'chalk';
+import readline from 'readline';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { PROVIDERS, getModelsForProvider, listProviders } from '../config/providers.js';
+import type { ProviderName } from '../config/types.js';
+
+export class WelcomeScreen {
+  /**
+   * Show welcome if no API key is configured
+   */
+  static show(hasApiKey: boolean): void {
+    if (hasApiKey) return;
+
+    const w = 62;
+    console.log(chalk.cyan('+') + chalk.white.bold(' Thatgfsj Code ') + chalk.cyan('-'.repeat(w - 16)) + '+');
+    console.log(chalk.cyan('|') + chalk.yellow(' 快速开始指南').padEnd(w) + chalk.cyan('|'));
+    console.log(chalk.cyan('|') + ' '.repeat(w) + chalk.cyan('|'));
+    console.log(chalk.cyan('|') + chalk.gray(' 运行 gfcode init 配置你的 API Key').padEnd(w) + chalk.cyan('|'));
+    console.log(chalk.cyan('|') + chalk.gray(' 或设置环境变量: OPENAI_API_KEY, SILICONFLOW_API_KEY 等').padEnd(w) + chalk.cyan('|'));
+    console.log(chalk.cyan('+') + '-'.repeat(w) + '+');
+    console.log();
+  }
+
+  /**
+   * Interactive setup wizard
+   */
+  static async interactiveSetup(): Promise<void> {
+    console.clear();
+    console.log(chalk.cyan('\n  🤖 Thatgfsj Code 配置向导\n'));
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    const question = (prompt: string): Promise<string> =>
+      new Promise(resolve => rl.question(prompt, answer => resolve(answer.trim())));
+
+    try {
+      // Step 1: Choose provider
+      console.log(chalk.white('  步骤 1/3: 选择 AI 提供商\n'));
+      const providers = listProviders();
+      providers.forEach((p, i) => {
+        console.log(chalk.green(`  ${i + 1}. ${p.name}`));
+      });
+      console.log();
+
+      const choice = await question(chalk.green('  请选择 (1-' + providers.length + '): '));
+      const selected = providers[parseInt(choice) - 1] || providers[0];
+      const providerName = selected.key;
+
+      // Step 2: Enter API Key
+      console.log(chalk.white('\n  步骤 2/3: 输入 API Key\n'));
+      console.log(chalk.gray(`  获取地址: ${PROVIDERS[providerName].baseUrl.replace('/v1', '').replace('/v1beta', '')}`));
+      const apiKey = await question(chalk.green('  请输入 API Key: '));
+
+      // Step 3: Choose model
+      console.log(chalk.white('\n  步骤 3/3: 选择模型\n'));
+      const models = getModelsForProvider(providerName);
+      models.forEach((m, i) => {
+        console.log(chalk.green(`  ${i + 1}. ${m.name}`) + chalk.gray(` - ${m.desc}`));
+      });
+      console.log();
+
+      const modelChoice = await question(chalk.green('  请选择模型 (1-' + models.length + '): '));
+      const selectedModel = models[parseInt(modelChoice) - 1] || models[0];
+
+      // Save config
+      const configDir = join(homedir(), '.thatgfsj');
+      const configPath = join(configDir, 'config.json');
+
+      if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+      }
+
+      writeFileSync(configPath, JSON.stringify({
+        provider: providerName,
+        model: selectedModel.id,
+        apiKey,
+        temperature: 0.7,
+        maxTokens: 4096,
+      }, null, 2));
+
+      console.log(chalk.green('\n  ✅ 配置已保存!'));
+      console.log(chalk.gray(`  提供商: ${providerName}`));
+      console.log(chalk.gray(`  模型: ${selectedModel.name}`));
+      console.log(chalk.gray(`  配置文件: ${configPath}`));
+      console.log(chalk.cyan('\n  运行 gfcode 开始使用\n'));
+
+    } finally {
+      rl.close();
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,42 @@
+/**
+ * Global shared types for Thatgfsj Code
+ * Only the most fundamental types used across modules
+ */
+
+export type Role = 'system' | 'user' | 'assistant' | 'tool';
+
+export interface ChatMessage {
+  role: Role;
+  content: string;
+  name?: string;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+  reasoning_content?: string;
+}
+
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface ChatResponse {
+  content: string;
+  role: 'assistant';
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+  tool_calls?: ToolCall[];
+  reasoning_content?: string;
+}
+
+export interface ChatOptions {
+  temperature?: number;
+  maxTokens?: number;
+  stream?: boolean;
+}

package/src/utils/diff.ts

@@ -0,0 +1,71 @@
+/**
+ * Diff Preview - Show file changes in a readable format
+ * Migrated from old src/utils/diff-preview.ts
+ */
+
+export interface DiffResult {
+  original: string;
+  modified: string;
+  diff: string;
+  added: number;
+  removed: number;
+}
+
+export class DiffPreview {
+  /**
+   * Generate a simple line-by-line diff
+   */
+  static diff(original: string, modified: string): DiffResult {
+    const originalLines = original.split('\n');
+    const modifiedLines = modified.split('\n');
+    const diffLines: string[] = [];
+    let added = 0;
+    let removed = 0;
+
+    // Simple diff: show removed (-) and added (+) lines
+    const maxLen = Math.max(originalLines.length, modifiedLines.length);
+
+    for (let i = 0; i < maxLen; i++) {
+      const orig = originalLines[i];
+      const mod = modifiedLines[i];
+
+      if (orig === mod) {
+        diffLines.push(`  ${orig}`);
+      } else {
+        if (orig !== undefined) {
+          diffLines.push(`- ${orig}`);
+          removed++;
+        }
+        if (mod !== undefined) {
+          diffLines.push(`+ ${mod}`);
+          added++;
+        }
+      }
+    }
+
+    return {
+      original,
+      modified,
+      diff: diffLines.join('\n'),
+      added,
+      removed,
+    };
+  }
+
+  /**
+   * Format diff for display
+   */
+  static format(result: DiffResult): string {
+    const lines = result.diff.split('\n').map(line => {
+      if (line.startsWith('+')) return `\x1b[32m${line}\x1b[0m`;
+      if (line.startsWith('-')) return `\x1b[31m${line}\x1b[0m`;
+      return line;
+    });
+
+    return [
+      `\x1b[36m--- Changes: -${result.removed} / +${result.added} ---\x1b[0m`,
+      ...lines,
+      `\x1b[36m--- End ---\x1b[0m`,
+    ].join('\n');
+  }
+}

package/src/utils/project.ts

@@ -0,0 +1,99 @@
+/**
+ * Project Context - Detect project type and gather info
+ * Migrated from old src/utils/project-context.ts + getProjectContext() from index.ts
+ */
+
+import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+export interface ProjectInfo {
+  type: string;
+  name: string;
+  path: string;
+  fileCount: number;
+  dependencies: number;
+}
+
+export interface PackageJson {
+  name?: string;
+  version?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+}
+
+export class ProjectContext {
+  /**
+   * Get project context string for display
+   */
+  static getSummary(cwd: string = process.cwd()): string {
+    const info: string[] = [];
+
+    try {
+      const pkgPath = join(cwd, 'package.json');
+      if (existsSync(pkgPath)) {
+        const pkg: PackageJson = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        info.push(`📦 Project: ${cwd}`);
+        info.push(`   Name: ${pkg.name || 'unknown'}`);
+        const depCount = Object.keys(pkg.dependencies || {}).length;
+        if (depCount > 0) info.push(`   Deps: ${depCount} packages`);
+      } else {
+        info.push(`📁 Working dir: ${cwd}`);
+      }
+
+      const fileCount = ProjectContext.countCodeFiles(cwd);
+      if (fileCount > 0) {
+        info.push(`   Files: ${fileCount} code files`);
+      }
+    } catch {
+      info.push(`📁 Working dir: ${cwd}`);
+    }
+
+    return info.join('\n');
+  }
+
+  /**
+   * Count code files in directory (skipping node_modules, .git, etc.)
+   */
+  static countCodeFiles(dir: string, maxDepth = 3): number {
+    let count = 0;
+    const codeExts = /\.(ts|js|py|go|rs|java|cpp|c|h|tsx|jsx|vue|svelte)$/;
+
+    const walk = (d: string, depth: number) => {
+      if (depth > maxDepth) return;
+      try {
+        const items = readdirSync(d);
+        for (const item of items) {
+          if (['node_modules', '.git', 'dist', 'build', '__pycache__'].includes(item)) continue;
+          const fullPath = join(d, item);
+          try {
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+              walk(fullPath, depth + 1);
+            } else if (codeExts.test(item)) {
+              count++;
+            }
+          } catch {
+            // Skip inaccessible files
+          }
+        }
+      } catch {
+        // Skip inaccessible directories
+      }
+    };
+
+    walk(dir, 0);
+    return count;
+  }
+
+  /**
+   * Detect project type from files
+   */
+  static detectType(cwd: string = process.cwd()): string {
+    if (existsSync(join(cwd, 'package.json'))) return 'node';
+    if (existsSync(join(cwd, 'Cargo.toml'))) return 'rust';
+    if (existsSync(join(cwd, 'go.mod'))) return 'go';
+    if (existsSync(join(cwd, 'pyproject.toml')) || existsSync(join(cwd, 'requirements.txt'))) return 'python';
+    if (existsSync(join(cwd, 'build.gradle'))) return 'java';
+    return 'unknown';
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}