@nils.del/supergrok 1.0.0

package/src/ui/readline-ui.ts

@@ -0,0 +1,294 @@
+import * as readline from 'readline';
+import chalk from 'chalk';
+import { GrokAgent, StreamChunk, ChatEntry } from '../agent/index.js';
+import { getMCPManager } from '../mcp/client.js';
+
+/**
+ * A readline-based UI that doesn't have the Ink flickering issues.
+ *
+ * Key differences from Ink-based UI:
+ * 1. Uses Node.js readline which has proper terminal handling on Linux
+ * 2. Line-based output instead of full-screen rendering
+ * 3. Input is captured properly even during MCP operations
+ * 4. No React rendering overhead
+ */
+export class ReadlineUI {
+  private agent: GrokAgent;
+  private rl: readline.Interface;
+  private isProcessing = false;
+  private currentSpinner: NodeJS.Timeout | null = null;
+  private spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  private spinnerIndex = 0;
+
+  constructor(agent: GrokAgent) {
+    this.agent = agent;
+
+    // Create readline interface with proper configuration for raw mode
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+      historySize: 100,
+      prompt: chalk.cyan('❯ ')
+    });
+
+    // Handle Ctrl+C gracefully
+    this.rl.on('close', () => {
+      this.cleanup();
+      process.exit(0);
+    });
+
+    // Handle SIGINT (Ctrl+C)
+    process.on('SIGINT', () => {
+      if (this.isProcessing) {
+        this.agent.abortCurrentOperation();
+        this.stopSpinner();
+        console.log(chalk.yellow('\n[Aborted]'));
+        this.isProcessing = false;
+        this.prompt();
+      } else {
+        console.log(chalk.gray('\nGoodbye!'));
+        this.cleanup();
+        process.exit(0);
+      }
+    });
+  }
+
+  private cleanup(): void {
+    this.stopSpinner();
+    this.rl.close();
+  }
+
+  private startSpinner(message: string): void {
+    this.spinnerIndex = 0;
+    process.stdout.write(`\r${chalk.yellow(this.spinnerFrames[0])} ${message}`);
+
+    this.currentSpinner = setInterval(() => {
+      this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
+      process.stdout.write(`\r${chalk.yellow(this.spinnerFrames[this.spinnerIndex])} ${message}`);
+    }, 80);
+  }
+
+  private stopSpinner(): void {
+    if (this.currentSpinner) {
+      clearInterval(this.currentSpinner);
+      this.currentSpinner = null;
+      process.stdout.write('\r\x1b[K'); // Clear the line
+    }
+  }
+
+  private prompt(): void {
+    this.rl.prompt();
+  }
+
+  private printHeader(): void {
+    console.log();
+    console.log(chalk.magenta.bold('  ╔═══════════════════════════════════════════╗'));
+    console.log(chalk.magenta.bold('  ║') + chalk.cyan.bold('         GROK CLI (Fixed Edition)         ') + chalk.magenta.bold('║'));
+    console.log(chalk.magenta.bold('  ║') + chalk.gray('   No Ink flickering • Works with MCP     ') + chalk.magenta.bold('║'));
+    console.log(chalk.magenta.bold('  ╚═══════════════════════════════════════════╝'));
+    console.log();
+    console.log(chalk.gray('  Type your message and press Enter. Commands:'));
+    console.log(chalk.gray('  /help - Show help  /clear - Clear history  /exit - Quit'));
+    console.log(chalk.gray('  Ctrl+C - Cancel operation or exit'));
+    console.log();
+  }
+
+  private async showMCPStatus(): Promise<void> {
+    const mcpManager = getMCPManager();
+    await mcpManager.ensureServersInitialized();
+
+    const servers = mcpManager.getServers();
+    const tools = mcpManager.getTools();
+
+    if (servers.length > 0) {
+      console.log(chalk.green(`  ✓ MCP: ${servers.length} server(s), ${tools.length} tool(s)`));
+      servers.forEach(server => {
+        const serverTools = tools.filter(t => t.serverName === server);
+        console.log(chalk.gray(`    • ${server}: ${serverTools.length} tools`));
+      });
+      console.log();
+    }
+  }
+
+  private printToolCall(name: string, args: string): void {
+    const shortArgs = args.length > 100 ? args.substring(0, 100) + '...' : args;
+    console.log(chalk.blue(`  ⚡ ${name}`));
+    console.log(chalk.gray(`     ${shortArgs}`));
+  }
+
+  private printToolResult(result: { success: boolean; output?: string; error?: string }): void {
+    if (result.success) {
+      const output = result.output || 'Success';
+      const lines = output.split('\n');
+      const displayLines = lines.length > 10 ? [...lines.slice(0, 10), `... (${lines.length - 10} more lines)`] : lines;
+      console.log(chalk.green('  ✓ ') + chalk.gray(displayLines.join('\n    ')));
+    } else {
+      console.log(chalk.red('  ✗ ') + chalk.red(result.error || 'Error'));
+    }
+  }
+
+  private handleCommand(input: string): boolean {
+    const command = input.trim().toLowerCase();
+
+    switch (command) {
+      case '/help':
+        console.log();
+        console.log(chalk.cyan('Available Commands:'));
+        console.log(chalk.gray('  /help     - Show this help message'));
+        console.log(chalk.gray('  /clear    - Clear conversation history'));
+        console.log(chalk.gray('  /model    - Show current model'));
+        console.log(chalk.gray('  /mcp      - Show MCP server status'));
+        console.log(chalk.gray('  /exit     - Exit the application'));
+        console.log();
+        console.log(chalk.cyan('Keyboard Shortcuts:'));
+        console.log(chalk.gray('  Ctrl+C    - Cancel current operation or exit'));
+        console.log(chalk.gray('  Up/Down   - Navigate command history'));
+        console.log();
+        return true;
+
+      case '/clear':
+        this.agent.clearHistory();
+        console.clear();
+        this.printHeader();
+        console.log(chalk.green('  ✓ Conversation cleared'));
+        console.log();
+        return true;
+
+      case '/model':
+        console.log(chalk.cyan(`  Current model: ${this.agent.getCurrentModel()}`));
+        console.log();
+        return true;
+
+      case '/mcp':
+        this.showMCPStatus();
+        return true;
+
+      case '/exit':
+      case 'exit':
+      case 'quit':
+        console.log(chalk.gray('Goodbye!'));
+        this.cleanup();
+        process.exit(0);
+        return true;
+
+      default:
+        if (input.startsWith('/')) {
+          console.log(chalk.red(`  Unknown command: ${input}`));
+          console.log(chalk.gray('  Type /help for available commands'));
+          console.log();
+          return true;
+        }
+        return false;
+    }
+  }
+
+  private async processMessage(input: string): Promise<void> {
+    this.isProcessing = true;
+    console.log();
+
+    try {
+      let lastContent = '';
+      let isFirstContent = true;
+      let toolCount = 0;
+
+      for await (const chunk of this.agent.processUserMessageStream(input)) {
+        switch (chunk.type) {
+          case 'content':
+            if (chunk.content) {
+              if (isFirstContent) {
+                process.stdout.write(chalk.white('  '));
+                isFirstContent = false;
+              }
+              process.stdout.write(chunk.content);
+              lastContent += chunk.content;
+            }
+            break;
+
+          case 'tool_calls':
+            if (lastContent) {
+              console.log();
+              lastContent = '';
+            }
+            console.log();
+
+            if (chunk.toolCalls) {
+              for (const tc of chunk.toolCalls) {
+                toolCount++;
+                this.printToolCall(tc.function.name, tc.function.arguments);
+                this.startSpinner(`Executing tool ${toolCount}...`);
+              }
+            }
+            isFirstContent = true;
+            break;
+
+          case 'tool_result':
+            this.stopSpinner();
+            if (chunk.toolResult) {
+              this.printToolResult(chunk.toolResult);
+            }
+            console.log();
+            break;
+
+          case 'done':
+            if (lastContent && !lastContent.endsWith('\n')) {
+              console.log();
+            }
+            break;
+        }
+      }
+    } catch (error: any) {
+      this.stopSpinner();
+      console.log(chalk.red(`\n  Error: ${error.message}`));
+    }
+
+    console.log();
+    this.isProcessing = false;
+  }
+
+  async start(initialMessage?: string): Promise<void> {
+    // Clear screen and print header
+    console.clear();
+    this.printHeader();
+
+    // Show MCP status
+    await this.showMCPStatus();
+
+    // Show current model
+    console.log(chalk.yellow(`  Model: ${this.agent.getCurrentModel()}`));
+    console.log();
+
+    // Process initial message if provided
+    if (initialMessage) {
+      console.log(chalk.cyan('❯ ') + initialMessage);
+      await this.processMessage(initialMessage);
+    }
+
+    // Main input loop
+    this.rl.on('line', async (input) => {
+      const trimmed = input.trim();
+
+      if (!trimmed) {
+        this.prompt();
+        return;
+      }
+
+      // Check for commands
+      if (this.handleCommand(trimmed)) {
+        this.prompt();
+        return;
+      }
+
+      // Process as a message to the AI
+      await this.processMessage(trimmed);
+      this.prompt();
+    });
+
+    this.prompt();
+  }
+}
+
+export async function runReadlineUI(agent: GrokAgent, initialMessage?: string): Promise<void> {
+  const ui = new ReadlineUI(agent);
+  await ui.start(initialMessage);
+}

package/src/utils/settings.ts

@@ -0,0 +1,129 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export interface UserSettings {
+  apiKey?: string;
+  baseURL?: string;
+  defaultModel?: string;
+  models?: string[];
+}
+
+export interface ProjectSettings {
+  model?: string;
+  mcpServers?: Record<string, any>;
+}
+
+function getUserSettingsPath(): string {
+  return path.join(os.homedir(), '.grok', 'user-settings.json');
+}
+
+function getProjectSettingsPath(): string {
+  return path.join(process.cwd(), '.grok', 'settings.json');
+}
+
+export function loadUserSettings(): UserSettings {
+  const settingsPath = getUserSettingsPath();
+
+  if (!fs.existsSync(settingsPath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+  } catch (error) {
+    return {};
+  }
+}
+
+export function loadProjectSettings(): ProjectSettings {
+  const settingsPath = getProjectSettingsPath();
+
+  if (!fs.existsSync(settingsPath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+  } catch (error) {
+    return {};
+  }
+}
+
+export function saveUserSettings(settings: UserSettings): void {
+  const settingsPath = getUserSettingsPath();
+  const settingsDir = path.dirname(settingsPath);
+
+  if (!fs.existsSync(settingsDir)) {
+    fs.mkdirSync(settingsDir, { recursive: true });
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+
+export function saveProjectSettings(settings: ProjectSettings): void {
+  const settingsPath = getProjectSettingsPath();
+  const settingsDir = path.dirname(settingsPath);
+
+  if (!fs.existsSync(settingsDir)) {
+    fs.mkdirSync(settingsDir, { recursive: true });
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+
+export function getApiKey(): string | undefined {
+  return process.env.GROK_API_KEY || loadUserSettings().apiKey;
+}
+
+export function getBaseURL(): string {
+  return process.env.GROK_BASE_URL || loadUserSettings().baseURL || 'https://api.x.ai/v1';
+}
+
+export function getCurrentModel(): string {
+  const envModel = process.env.GROK_MODEL;
+  if (envModel) return envModel;
+
+  const projectSettings = loadProjectSettings();
+  if (projectSettings.model) return projectSettings.model;
+
+  const userSettings = loadUserSettings();
+  if (userSettings.defaultModel) return userSettings.defaultModel;
+
+  return 'grok-3-fast';
+}
+
+export function getAvailableModels(): string[] {
+  const userSettings = loadUserSettings();
+  return userSettings.models || [
+    'grok-code-fast-1',
+    'grok-4-latest',
+    'grok-3-latest',
+    'grok-3-fast',
+    'grok-3-mini-fast'
+  ];
+}
+
+export function loadCustomInstructions(): string | null {
+  // Check project-level instructions first
+  const projectPath = path.join(process.cwd(), '.grok', 'GROK.md');
+  if (fs.existsSync(projectPath)) {
+    try {
+      return fs.readFileSync(projectPath, 'utf-8');
+    } catch (error) {
+      // Ignore errors
+    }
+  }
+
+  // Fall back to global instructions
+  const globalPath = path.join(os.homedir(), '.grok', 'GROK.md');
+  if (fs.existsSync(globalPath)) {
+    try {
+      return fs.readFileSync(globalPath, 'utf-8');
+    } catch (error) {
+      // Ignore errors
+    }
+  }
+
+  return null;
+}

package/tsconfig.json

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