nova-terminal-assistant 0.1.0

package/src/cli/utils/CompletionHelper.ts

@@ -0,0 +1,388 @@
+// ============================================================================
+// Completion Helper - 命令自动补全助手
+// ============================================================================
+
+import { CliUI, Colors } from './CliUI.js';
+
+/**
+ * 补全项
+ */
+export interface CompletionItem {
+  text: string;
+  description?: string;
+  type?: 'command' | 'argument' | 'option' | 'file' | 'directory';
+}
+
+/**
+ * 补全上下文
+ */
+export interface CompletionContext {
+  command?: string;
+  subcommand?: string;
+  args: string[];
+  currentArg: string;
+  argIndex: number;
+}
+
+/**
+ * 命令定义
+ */
+interface CommandDefinition {
+  name: string;
+  description: string;
+  subcommands?: Record<string, SubcommandDefinition>;
+  options?: OptionDefinition[];
+  args?: ArgumentDefinition[];
+}
+
+/**
+ * 子命令定义
+ */
+interface SubcommandDefinition {
+  name: string;
+  description: string;
+  options?: OptionDefinition[];
+  args?: ArgumentDefinition[];
+}
+
+/**
+ * 选项定义
+ */
+interface OptionDefinition {
+  name: string;
+  short?: string;
+  description: string;
+  type?: 'string' | 'number' | 'boolean';
+  requiresValue?: boolean;
+}
+
+/**
+ * 参数定义
+ */
+interface ArgumentDefinition {
+  name: string;
+  description: string;
+  type?: 'string' | 'number' | 'file' | 'directory';
+}
+
+/**
+ * 命令自动补全助手
+ */
+export class CompletionHelper {
+  private static commands: Map<string, CommandDefinition> = new Map();
+  private static initialized = false;
+
+  /**
+   * 初始化命令定义
+   */
+  private static initialize(): void {
+    if (this.initialized) return;
+
+    // 核心命令
+    this.registerCommand({
+      name: 'config',
+      description: 'Manage configuration',
+      subcommands: {
+        show: { name: 'show', description: 'Show current configuration' },
+        edit: { name: 'edit', description: 'Open config file in editor' },
+      },
+    });
+
+    this.registerCommand({
+      name: 'auth',
+      description: 'Manage API credentials',
+      subcommands: {
+        set: {
+          name: 'set',
+          description: 'Set API key for a provider',
+          args: [{ name: 'provider', description: 'Provider name (anthropic, openai, etc.)' }],
+          options: [
+            { name: '--key', description: 'API key' },
+            { name: '--base-url', description: 'Base URL' },
+          ],
+        },
+        remove: {
+          name: 'remove',
+          description: 'Remove credentials for a provider',
+          args: [{ name: 'provider', description: 'Provider name' }],
+        },
+        status: { name: 'status', description: 'Show credential status' },
+      },
+    });
+
+    this.registerCommand({
+      name: 'model',
+      description: 'Manage AI models',
+      subcommands: {
+        list: { name: 'list', description: 'List available models' },
+        switch: { name: 'switch', description: 'Switch to a model', args: [{ name: 'model-id', description: 'Model ID' }] },
+      },
+    });
+
+    this.registerCommand({
+      name: 'provider',
+      description: 'Manage custom providers',
+      subcommands: {
+        add: { name: 'add', description: 'Add a custom provider' },
+        'add-model': { name: 'add-model', description: 'Add a model to a provider' },
+        remove: { name: 'remove', description: 'Remove a provider' },
+        list: { name: 'list', description: 'List all providers' },
+      },
+    });
+
+    this.registerCommand({
+      name: 'mcp',
+      description: 'Manage MCP servers',
+      subcommands: {
+        status: { name: 'status', description: 'Show MCP server status' },
+        list: { name: 'list', description: 'List MCP servers' },
+      },
+    });
+
+    this.registerCommand({
+      name: 'skills',
+      description: 'Manage skills',
+      subcommands: {
+        list: { name: 'list', description: 'List available skills' },
+      },
+    });
+
+    this.registerCommand({
+      name: 'coding-plan',
+      description: 'Manage Coding Plan providers',
+      subcommands: {
+        list: { name: 'list', description: 'List Coding Plan platforms' },
+        add: { name: 'add', description: 'Add a Coding Plan provider' },
+      },
+    });
+
+    this.registerCommand({
+      name: 'ollama',
+      description: 'Manage Ollama',
+      subcommands: {
+        list: { name: 'list', description: 'List local models' },
+        pull: { name: 'pull', description: 'Pull a model' },
+        rm: { name: 'rm', description: 'Remove a model' },
+        info: { name: 'info', description: 'Show model info' },
+        run: { name: 'run', description: 'Run a model' },
+      },
+    });
+
+    this.initialized = true;
+  }
+
+  /**
+   * 注册命令
+   */
+  static registerCommand(cmd: CommandDefinition): void {
+    this.commands.set(cmd.name, cmd);
+  }
+
+  /**
+   * 获取补全建议
+   */
+  static getCompletions(context: CompletionContext): CompletionItem[] {
+    this.initialize();
+
+    const completions: CompletionItem[] = [];
+
+    // 如果没有命令,补全命令
+    if (!context.command) {
+      return this.getCommandCompletions();
+    }
+
+    const command = this.commands.get(context.command);
+    if (!command) {
+      return [];
+    }
+
+    // 如果有子命令但没有输入子命令,补全子命令
+    if (command.subcommands && !context.subcommand) {
+      return this.getSubcommandCompletions(command.subcommands);
+    }
+
+    // 补全选项
+    const options = this.getOptionsForContext(command, context.subcommand);
+    completions.push(...this.getOptionCompletions(options));
+
+    // 补全参数
+    const args = this.getArgsForContext(command, context.subcommand);
+    completions.push(...this.getArgCompletions(args, context));
+
+    return completions;
+  }
+
+  /**
+   * 获取命令补全
+   */
+  private static getCommandCompletions(): CompletionItem[] {
+    return Array.from(this.commands.values()).map(cmd => ({
+      text: cmd.name,
+      description: cmd.description,
+      type: 'command',
+    }));
+  }
+
+  /**
+   * 获取子命令补全
+   */
+  private static getSubcommandCompletions(subcommands: Record<string, SubcommandDefinition>): CompletionItem[] {
+    return Object.values(subcommands).map(sub => ({
+      text: sub.name,
+      description: sub.description,
+      type: 'command',
+    }));
+  }
+
+  /**
+   * 获取选项补全
+   */
+  private static getOptionCompletions(options: OptionDefinition[]): CompletionItem[] {
+    return options.map(opt => {
+      const texts = [];
+      if (opt.short) texts.push(opt.short);
+      texts.push(opt.name);
+
+      return {
+        text: texts[0],
+        description: opt.description || texts.join(', '),
+        type: 'option',
+      };
+    });
+  }
+
+  /**
+   * 获取参数补全
+   */
+  private static getArgCompletions(args: ArgumentDefinition[], context: CompletionContext): CompletionItem[] {
+    const currentArgIndex = context.argIndex;
+
+    if (currentArgIndex >= args.length) {
+      return [];
+    }
+
+    const arg = args[currentArgIndex];
+    if (!arg) {
+      return [];
+    }
+
+    // 如果是文件或目录类型,可以添加文件/目录补全
+    if (arg.type === 'file' || arg.type === 'directory') {
+      return [{
+        text: context.currentArg,
+        description: arg.description,
+        type: arg.type as 'file' | 'directory',
+      }];
+    }
+
+    return [{
+      text: arg.name,
+      description: arg.description,
+      type: 'argument',
+    }];
+  }
+
+  /**
+   * 获取上下文的选项
+   */
+  private static getOptionsForContext(command: CommandDefinition, subcommand?: string): OptionDefinition[] {
+    if (!subcommand) {
+      return command.options || [];
+    }
+
+    const sub = command.subcommands?.[subcommand];
+    return sub?.options || [];
+  }
+
+  /**
+   * 获取上下文的参数
+   */
+  private static getArgsForContext(command: CommandDefinition, subcommand?: string): ArgumentDefinition[] {
+    if (!subcommand) {
+      return command.args || [];
+    }
+
+    const sub = command.subcommands?.[subcommand];
+    return sub?.args || [];
+  }
+
+  /**
+   * 显示补全提示
+   */
+  static showCompletionTip(context: CompletionContext): void {
+    const completions = this.getCompletions(context);
+
+    if (completions.length === 0) {
+      return;
+    }
+
+    // 过滤匹配的补全
+    const filtered = completions.filter(c =>
+      c.text.toLowerCase().startsWith(context.currentArg.toLowerCase())
+    );
+
+    if (filtered.length === 0) {
+      return;
+    }
+
+    console.log('');
+    console.log(`${Colors.info}  Available completions:${Colors.reset}`);
+    console.log('');
+
+    const maxTextLength = Math.max(...filtered.map(c => c.text.length));
+    filtered.forEach(c => {
+      const typeIcon = this.getTypeIcon(c.type);
+      const text = c.text.padEnd(maxTextLength + 2);
+      const desc = c.description || '';
+      console.log(`  ${typeIcon} ${Colors.primary}${text}${Colors.reset}${Colors.dim}${desc}${Colors.reset}`);
+    });
+
+    console.log('');
+  }
+
+  /**
+   * 获取类型图标
+   */
+  private static getTypeIcon(type?: string): string {
+    const icons: Record<string, string> = {
+      command: '⌘',
+      argument: '◇',
+      option: '⚙',
+      file: '📄',
+      directory: '📁',
+    };
+    return icons[type || ''] || icons['•'];
+  }
+
+  /**
+   * 智能提示
+   */
+  static showSmartHint(input: string): void {
+    const trimmed = input.trim();
+
+    // 如果输入以 - 开头,可能是选项
+    if (trimmed.startsWith('-')) {
+      console.log(`${Colors.dim}  💡 Tip: Use ${Colors.info}--help${Colors.dim} to see all options${Colors.reset}`);
+      return;
+    }
+
+    // 如果输入是已知命令
+    if (this.commands.has(trimmed)) {
+      const cmd = this.commands.get(trimmed);
+      if (cmd?.subcommands && Object.keys(cmd.subcommands).length > 0) {
+        const subcommands = Object.keys(cmd.subcommands).join(', ');
+        console.log(`${Colors.dim}  💡 Tip: ${Colors.primary}${trimmed}${Colors.dim} has subcommands: ${Colors.info}${subcommands}${Colors.reset}`);
+      }
+      return;
+    }
+
+    // 模糊匹配
+    const matches = Array.from(this.commands.keys()).filter(cmd =>
+      cmd.includes(trimmed.toLowerCase()) || trimmed.toLowerCase().includes(cmd)
+    );
+
+    if (matches.length > 0 && matches.length < 5) {
+      console.log(`${Colors.dim}  💡 Did you mean: ${matches.map(m => Colors.info + m + Colors.dim).join(', ')}?${Colors.reset}`);
+    }
+  }
+}

package/src/cli/utils/EnhancedCompleter.test.ts

@@ -0,0 +1,226 @@
+// ============================================================================
+// EnhancedCompleter Tests
+// ============================================================================
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { EnhancedCompleter } from './EnhancedCompleter.js';
+import type { ConfigManager } from '../core/config/ConfigManager.js';
+
+// Mock ConfigManager
+function createMockConfigManager(): ConfigManager {
+  return {
+    getConfig: vi.fn(() => ({
+      core: {
+        defaultModel: 'test-model',
+        maxTokens: 4096,
+        temperature: 0.7,
+      },
+      models: {
+        providers: {
+          'test-provider': {
+            type: 'openai-compatible',
+            baseUrl: 'https://api.test.com',
+            models: {
+              'test-model-1': {
+                name: 'test-model-1',
+                contextWindow: 4096,
+                maxOutput: 2048,
+                pricing: { input: 0.001, output: 0.002 },
+              },
+              'test-model-2': {
+                name: 'test-model-2',
+                contextWindow: 8192,
+                maxOutput: 4096,
+                pricing: { input: 0.002, output: 0.004 },
+              },
+            },
+          },
+          'ollama': {
+            type: 'ollama',
+            baseUrl: 'http://localhost:11434',
+            models: {
+              'llama3.2': {
+                name: 'llama3.2',
+                contextWindow: 128000,
+                maxOutput: 4096,
+                pricing: { input: 0, output: 0 },
+              },
+            },
+          },
+        },
+        aliases: {
+          'alias-model': 'test-model-1',
+        },
+      },
+    })),
+    load: vi.fn(),
+    save: vi.fn(),
+    getModelConfig: vi.fn(),
+  } as unknown as ConfigManager;
+}
+
+describe('EnhancedCompleter', () => {
+  let completer: EnhancedCompleter;
+  let mockConfigManager: ConfigManager;
+
+  beforeEach(() => {
+    mockConfigManager = createMockConfigManager();
+    completer = new EnhancedCompleter({
+      configManager: mockConfigManager,
+      cwd: '/test/workspace',
+      history: ['/help', '/model test-model-1', 'hello world', 'previous query'],
+      skills: ['pdf', 'xlsx', 'browser'],
+      mcpServers: [
+        { name: 'playwright', status: 'running' },
+        { name: 'filesystem', status: 'stopped' },
+      ],
+    });
+  });
+
+  describe('getCompletions()', () => {
+    describe('empty input', () => {
+      it('should return all commands for empty input', () => {
+        const completions = completer.getCompletions('');
+        expect(completions.length).toBeGreaterThan(0);
+        expect(completions[0].type).toBe('command');
+      });
+    });
+
+    describe('command completions', () => {
+      it('should complete /help command', () => {
+        const completions = completer.getCompletions('/hel');
+        expect(completions.some(c => c.text === '/help')).toBe(true);
+      });
+
+      it('should complete /model command', () => {
+        const completions = completer.getCompletions('/mod');
+        expect(completions.some(c => c.text === '/model')).toBe(true);
+      });
+
+      it('should show all commands starting with /', () => {
+        const completions = completer.getCompletions('/');
+        expect(completions.length).toBeGreaterThan(5);
+        completions.forEach(c => {
+          expect(c.text.startsWith('/')).toBe(true);
+        });
+      });
+    });
+
+    describe('model completions', () => {
+      it('should show all models after /model ', () => {
+        const completions = completer.getCompletions('/model ');
+        expect(completions.length).toBeGreaterThan(0);
+        expect(completions[0].type).toBe('model');
+      });
+
+      it('should filter models by prefix', () => {
+        const completions = completer.getCompletions('/model test');
+        expect(completions.every(c => c.text.toLowerCase().includes('test'))).toBe(true);
+      });
+    });
+
+    describe('subcommand completions', () => {
+      it('should show subcommands for /skills ', () => {
+        const completions = completer.getCompletions('/skills ');
+        expect(completions.some(c => c.text === 'list')).toBe(true);
+        expect(completions.some(c => c.text === 'use')).toBe(true);
+      });
+
+      it('should show subcommands for /mcp ', () => {
+        const completions = completer.getCompletions('/mcp ');
+        expect(completions.some(c => c.text === 'status')).toBe(true);
+        expect(completions.some(c => c.text === 'list')).toBe(true);
+      });
+
+      it('should filter subcommands by prefix', () => {
+        const completions = completer.getCompletions('/skills us');
+        expect(completions.some(c => c.text === 'use')).toBe(true);
+        expect(completions.some(c => c.text === 'list')).toBe(false);
+      });
+    });
+
+    describe('skill completions', () => {
+      it('should show skills after /skills use ', () => {
+        const completions = completer.getCompletions('/skills use ');
+        expect(completions.some(c => c.text === 'pdf')).toBe(true);
+        expect(completions.some(c => c.text === 'xlsx')).toBe(true);
+      });
+    });
+
+    describe('history completions', () => {
+      it('should match history for partial input', () => {
+        const completions = completer.getCompletions('hel');
+        expect(completions.some(c => c.text === 'hello world')).toBe(true);
+      });
+
+      it('should not match slash commands as history', () => {
+        const completions = completer.getCompletions('/hel');
+        // Should return command type, not history
+        expect(completions.every(c => c.type === 'command')).toBe(true);
+      });
+    });
+
+    describe('file completions', () => {
+      it('should trigger file completion for @', () => {
+        // This will depend on actual filesystem, so just check type
+        const completions = completer.getCompletions('@');
+        expect(completions.every(c => c.type === 'file' || c.type === 'directory')).toBe(true);
+      });
+    });
+
+    describe('shell completions', () => {
+      it('should suggest common commands for !', () => {
+        const completions = completer.getCompletions('!gi');
+        expect(completions.some(c => c.text === 'git')).toBe(true);
+      });
+    });
+  });
+
+  describe('updateHistory()', () => {
+    it('should update history for completions', () => {
+      completer.updateHistory(['new', 'history']);
+      const completions = completer.getCompletions('new');
+      expect(completions.some(c => c.text === 'new')).toBe(true);
+    });
+  });
+
+  describe('updateSkills()', () => {
+    it('should update skills for completions', () => {
+      completer.updateSkills(['new-skill']);
+      const completions = completer.getCompletions('/skills use ');
+      expect(completions.some(c => c.text === 'new-skill')).toBe(true);
+    });
+  });
+
+  describe('updateMcpServers()', () => {
+    it('should update MCP servers for completions', () => {
+      completer.updateMcpServers([{ name: 'new-server', status: 'running' }]);
+      // MCP server completions are for /mcp tools command
+      const completions = completer.getCompletions('/mcp tools ');
+      expect(completions.some(c => c.text === 'new-server')).toBe(true);
+    });
+  });
+
+  describe('applyCompletion()', () => {
+    it('should apply completion to input', () => {
+      const result = completer.applyCompletion('/mod', { text: '/model ', displayText: '/model', description: '', type: 'command', priority: 100 }, 4);
+      expect(result.text).toBe('/model ');
+      expect(result.cursorPos).toBe(7);
+    });
+  });
+
+  describe('formatCompletion()', () => {
+    it('should format completion with icon', () => {
+      const formatted = completer.formatCompletion({
+        text: 'test',
+        displayText: 'test',
+        description: 'Test description',
+        type: 'command',
+        priority: 100,
+      }, 40);
+
+      expect(formatted).toContain('test');
+      expect(formatted).toContain('Test description');
+    });
+  });
+});