thatgfsj-code 0.3.0 → 0.4.1

package/src/llm/provider.ts

@@ -3,32 +3,28 @@
  * All providers implement this interface
  */
 
-import type { ChatMessage, ChatResponse, ChatOptions } from '../types.js';
+import type { ChatMessage, ChatResponse, ChatOptions, ToolCall } from '../types.js';
 import type { Tool } from '../tools/types.js';
 
+export interface StreamChunk {
+  type: 'text' | 'tool_calls';
+  content?: string;
+  toolCalls?: ToolCall[];
+}
+
 export interface LLMProvider {
-  /** Provider name for logging */
   readonly name: string;
 
-  /**
-   * Non-streaming chat completion
-   */
-  chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResponse>;
+  /** Non-streaming chat with optional tools */
+  chat(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]): Promise<ChatResponse>;
 
-  /**
-   * Streaming chat completion - yields text chunks
-   */
-  chatStream(messages: ChatMessage[], options?: ChatOptions): AsyncGenerator<string, ChatResponse>;
+  /** Streaming chat with optional tools - yields StreamChunks */
+  chatStream(messages: ChatMessage[], options?: ChatOptions, tools?: Tool[]): AsyncGenerator<StreamChunk, ChatResponse>;
 
-  /**
-   * Convert Tool[] to provider-specific format
-   */
+  /** Convert Tool[] to provider-specific format */
   buildTools(tools: Tool[]): any[];
 }
 
-/**
- * Provider configuration passed to each provider
- */
 export interface ProviderConfig {
   apiKey: string;
   model: string;

package/src/tui/input.ts

@@ -1,6 +1,5 @@
 /**
  * REPL Input Handler
- * Migrated from old src/repl/input.ts
  */
 
 import readline from 'readline';
@@ -20,13 +19,11 @@ export class REPLInput {
       tabSize: 4,
     });
 
-    // Handle Ctrl+C
     this.rl.on('SIGINT', () => {
-      process.stdout.write(chalk.gray('\n\n👋 Exiting...\n'));
+      process.stdout.write(chalk.gray('\n  Goodbye! 👋\n'));
       process.exit(0);
     });
 
-    // Track history
     this.rl.on('line', (line) => {
       if (line.trim()) {
         this.history.push(line);
@@ -36,7 +33,7 @@ export class REPLInput {
     });
   }
 
-  async prompt(prefix: string = chalk.green('\n> ')): Promise<string> {
+  async prompt(prefix: string = chalk.cyan('❯ ')): Promise<string> {
     return new Promise((resolve) => {
       this.rl.question(prefix, (answer) => {
         resolve(answer);

package/src/tui/output.ts

@@ -1,6 +1,5 @@
 /**
- * REPL Output Handler
- * Migrated from old src/repl/output.ts
+ * REPL Output - Beautiful terminal UI
  */
 
 import chalk from 'chalk';
@@ -8,76 +7,230 @@ import ora, { Ora } from 'ora';
 
 export class REPLOutput {
   private spinner: Ora | null = null;
+  private inAssistantBlock = false;
+  private currentLineHasContent = false;
 
-  printError(error: string): void {
-    console.error(chalk.red(`\n❌ Error: ${error}`));
+  // ── Banner ──────────────────────────────────────────────
+
+  printBanner(): void {
+    console.log();
+    console.log(chalk.cyan.bold('  ⚡ Thatgfsj Code') + chalk.gray(' v0.4.1'));
+    console.log(chalk.gray('  AI Coding Assistant'));
+    console.log(chalk.gray('  ' + '─'.repeat(52)));
+    console.log();
   }
 
-  printWarning(warning: string): void {
-    console.warn(chalk.yellow(`\n⚠️  ${warning}`));
+  // ── Prompt ──────────────────────────────────────────────
+
+  getPrompt(): string {
+    return chalk.cyan.bold('❯ ');
   }
 
-  printSuccess(message: string): void {
-    console.log(chalk.green(`\n✅ ${message}`));
+  // ── User Input ──────────────────────────────────────────
+
+  printUserInput(input: string): void {
+    console.log();
+    console.log(chalk.gray('  ┌─ ') + chalk.bold('You'));
+    for (const line of input.split('\n')) {
+      console.log(chalk.gray('  │ ') + line);
+    }
+    console.log(chalk.gray('  └─'));
   }
 
-  printInfo(message: string): void {
-    console.log(chalk.gray(message));
+  // ── Assistant Streaming ─────────────────────────────────
+
+  beginAssistant(): void {
+    if (this.inAssistantBlock) return;
+    this.inAssistantBlock = true;
+    this.currentLineHasContent = false;
+    console.log();
+    process.stdout.write(chalk.cyan('  ┌─ ') + chalk.bold('AI') + '\n' + chalk.cyan('  │ '));
   }
 
-  printDivider(char = '─', length = 40): void {
-    console.log(chalk.gray(char.repeat(length)));
+  writeChunk(chunk: string): void {
+    if (!this.inAssistantBlock) this.beginAssistant();
+
+    for (const char of chunk) {
+      if (char === '\n') {
+        process.stdout.write('\n' + chalk.cyan('  │ '));
+        this.currentLineHasContent = false;
+      } else {
+        process.stdout.write(char);
+        this.currentLineHasContent = true;
+      }
+    }
   }
 
-  printHeader(text: string): void {
-    this.printDivider();
-    console.log(chalk.cyan(text));
-    this.printDivider();
+  endAssistant(): void {
+    if (!this.inAssistantBlock) return;
+    if (this.currentLineHasContent) {
+      process.stdout.write('\n');
+    }
+    process.stdout.write(chalk.cyan('  └─') + '\n\n');
+    this.inAssistantBlock = false;
+    this.currentLineHasContent = false;
   }
 
-  startSpinner(text: string): void {
-    this.spinner = ora({ text, color: 'cyan', spinner: 'dots' }).start();
+  // ── Tool Calls ──────────────────────────────────────────
+
+  printToolCall(name: string, args: string): void {
+    if (this.inAssistantBlock) this.endAssistant();
+
+    console.log();
+    console.log(chalk.yellow('  ⚙ ') + chalk.bold(name) + chalk.gray(' ─────────────────────────'));
+
+    if (args) {
+      try {
+        const obj = JSON.parse(args);
+        for (const [key, val] of Object.entries(obj)) {
+          let display: string;
+          if (typeof val === 'string') {
+            display = val.length > 120 ? val.slice(0, 120) + '...' : val;
+          } else {
+            display = JSON.stringify(val);
+            if (display.length > 120) display = display.slice(0, 120) + '...';
+          }
+          console.log(chalk.gray('    ' + key + ': ') + chalk.white(display));
+        }
+      } catch {
+        const display = args.length > 150 ? args.slice(0, 150) + '...' : args;
+        console.log(chalk.gray('    ') + display);
+      }
+    }
+  }
+
+  printToolResult(output: string, isError = false): void {
+    if (!output) return;
+
+    const lines = output.split('\n');
+    const maxLines = 25;
+    const display = lines.slice(0, maxLines);
+
+    for (const line of display) {
+      if (isError) {
+        console.log(chalk.red('    ✖ ') + line);
+      } else {
+        console.log(chalk.gray('    │ ') + line);
+      }
+    }
+
+    if (lines.length > maxLines) {
+      console.log(chalk.gray('    │ ') + chalk.dim(`... +${lines.length - maxLines} more lines`));
+    }
+  }
+
+  printToolEnd(): void {
+    console.log(chalk.yellow('  ────────────────────────────────────'));
+  }
+
+  // ── Thinking ────────────────────────────────────────────
+
+  startThinking(): void {
+    this.spinner = ora({
+      text: chalk.gray('Thinking'),
+      color: 'cyan',
+      spinner: 'dots',
+    }).start();
   }
 
-  stopSpinner(): void {
+  startExecuting(toolName: string): void {
+    this.spinner = ora({
+      text: chalk.gray(`Executing ${chalk.yellow(toolName)}`),
+      color: 'cyan',
+      spinner: 'dots',
+    }).start();
+  }
+
+  stopThinking(): void {
     if (this.spinner) {
       this.spinner.stop();
       this.spinner = null;
     }
   }
 
-  stopSpinnerFail(text?: string): void {
+  stopThinkingFail(msg: string): void {
     if (this.spinner) {
-      this.spinner.fail(text || this.spinner.text);
+      this.spinner.fail(chalk.red(msg));
       this.spinner = null;
     }
   }
 
+  // ── Messages ────────────────────────────────────────────
+
+  info(msg: string): void {
+    console.log(chalk.gray('  ') + msg);
+  }
+
+  success(msg: string): void {
+    console.log(chalk.green('  ✅ ') + msg);
+  }
+
+  error(msg: string): void {
+    console.log();
+    console.log(chalk.red('  ┌─ Error'));
+    for (const line of msg.split('\n')) {
+      console.log(chalk.red('  │ ') + line);
+    }
+    console.log(chalk.red('  └─'));
+    console.log();
+  }
+
+  warning(msg: string): void {
+    console.log(chalk.yellow('  ⚠  ') + msg);
+  }
+
+  dim(msg: string): void {
+    console.log(chalk.dim('  ' + msg));
+  }
+
+  // ── Layout ──────────────────────────────────────────────
+
+  divider(): void {
+    console.log(chalk.gray('  ' + '─'.repeat(52)));
+  }
+
+  spacer(): void {
+    console.log();
+  }
+
   clear(): void {
     console.clear();
   }
 
-  printBanner(): void {
-    console.log(chalk.cyan(`
-╔═══════════════════════════════════════╗
-║     🤖 Thatgfsj Code v0.3.0        ║
-║     AI Coding Assistant              ║
-╚═══════════════════════════════════════╝
-    `));
+  // ── Sections ────────────────────────────────────────────
+
+  section(title: string, items: Array<{ label: string; value: string }>): void {
+    console.log();
+    console.log(chalk.bold('  ' + title));
+    this.divider();
+    for (const item of items) {
+      console.log('  ' + chalk.gray(item.label.padEnd(14)) + chalk.white(item.value));
+    }
+    console.log();
   }
 
+  // ── Help ────────────────────────────────────────────────
+
   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
-    `);
+    console.log();
+    console.log(chalk.bold('  Commands'));
+    this.divider();
+    const cmds: [string, string][] = [
+      ['help', 'Show this help'],
+      ['tools', 'List available tools'],
+      ['model', 'Show current model info'],
+      ['clear', 'Clear screen'],
+      ['exit', 'Exit'],
+    ];
+    for (const [cmd, desc] of cmds) {
+      console.log('  ' + chalk.cyan(cmd.padEnd(14)) + chalk.gray(desc));
+    }
+    console.log();
+    console.log(chalk.bold('  Keyboard'));
+    this.divider();
+    console.log('  ' + chalk.cyan('↑ / ↓'.padEnd(14)) + chalk.gray('Browse command history'));
+    console.log('  ' + chalk.cyan('Tab'.padEnd(14)) + chalk.gray('Auto-complete'));
+    console.log('  ' + chalk.cyan('Ctrl+C'.padEnd(14)) + chalk.gray('Exit'));
+    console.log();
   }
 }

package/src/tui/repl.ts

@@ -1,6 +1,5 @@
 /**
  * REPL - Main interactive loop
- * Migrated from old src/repl/loop.ts + src/index.ts interactive mode
  */
 
 import chalk from 'chalk';
@@ -21,53 +20,45 @@ export class REPL {
     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();
+    const cfg = this.app.config.get();
+    this.output.section('Session', [
+      { label: 'Provider', value: cfg.provider },
+      { label: 'Model', value: cfg.model },
+      { label: 'Project', value: ProjectContext.detectType() },
+    ]);
+
+    this.output.info('Type ' + chalk.cyan('help') + ' for commands');
+    this.output.spacer();
 
-    // Main loop
     while (this.running) {
       try {
-        const userInput = await this.input.prompt();
-
+        const userInput = await this.input.prompt(this.output.getPrompt());
         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);
+        this.output.error(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.output.dim('Goodbye! 👋');
         this.running = false;
         this.input.close();
         return true;
@@ -82,50 +73,98 @@ export class REPL {
         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();
+        this.output.section('Available Tools',
+          this.app.tools.list().map(t => ({
+            label: t.name,
+            value: t.description,
+          }))
+        );
         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();
+      case 'model': {
+        const c = this.app.config.get();
+        this.output.section('Current Model', [
+          { label: 'Provider', value: c.provider },
+          { label: 'Model', value: c.model },
+          { label: 'Base URL', value: c.baseUrl || 'default' },
+          { label: 'API Key', value: c.apiKey ? '••••' + c.apiKey.slice(-4) : 'not set' },
+        ]);
         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.printUserInput(input);
+    this.output.startThinking();
 
-    this.output.startSpinner('Thinking...');
     let fullResponse = '';
+    let hasStartedOutput = false;
 
     try {
       const stream = this.app.getAgent().run(this.app.session.getMessages());
+
       for await (const chunk of stream) {
-        this.output.stopSpinner();
-        process.stdout.write(chunk);
+        this.output.stopThinking();
+
+        const parts = chunk.split('\n');
+        for (const part of parts) {
+          // Tool message: @@TOOL@@{json}
+          if (part.startsWith('@@TOOL@@')) {
+            try {
+              const data = JSON.parse(part.slice(8));
+              if (data.action === 'call') {
+                if (hasStartedOutput) {
+                  this.output.endAssistant();
+                  hasStartedOutput = false;
+                }
+                this.output.printToolCall(data.name, data.args || '');
+                // Show executing state
+                this.output.startExecuting(data.name);
+              } else if (data.action === 'result') {
+                this.output.stopThinking();
+                this.output.printToolResult(data.output || data.error || '', !!data.error);
+                this.output.printToolEnd();
+              }
+            } catch {
+              this.output.writeChunk(part + '\n');
+            }
+            continue;
+          }
+
+          // Regular text
+          if (part) {
+            if (!hasStartedOutput) {
+              this.output.beginAssistant();
+              hasStartedOutput = true;
+            }
+            this.output.writeChunk(part + '\n');
+          }
+        }
+
         fullResponse += chunk;
       }
 
-      console.log(); // newline
+      if (hasStartedOutput) {
+        this.output.endAssistant();
+      }
+
+      // Don't save empty responses
+      if (fullResponse.trim()) {
+        this.app.session.addMessage('assistant', fullResponse);
+        this.app.session.truncate();
+      }
 
-      this.app.session.addMessage('assistant', fullResponse);
-      this.app.session.truncate();
     } catch (error: any) {
-      this.output.stopSpinnerFail(chalk.red(`Error: ${error.message}`));
+      if (hasStartedOutput) {
+        this.output.endAssistant();
+      }
+      this.output.stopThinkingFail(error.message);
+      this.output.error(error.message);
     }
   }
 }