feat(mpp-vscode): add DevIns language support and status bar

Phase 5 - Status Bar:
- Add StatusBarManager with idle/thinking/streaming/error states
- Animated status icons during LLM operations
- Click to open chat command

Phase 6 - DevIns Language Support:
- Add TextMate grammar for syntax highlighting
- Support commands (/), agents (@), variables ($)
- Add language configuration (brackets, folding, etc.)
- Implement DevInsCompletionProvider with built-in completions
- Register completion triggers for /, @, $ characters

Testing:
- Add unit tests for StatusBarManager
- Add unit tests for DevInsCompletionProvider
- All 56 tests passing

Refs #31

Author: phodal

mpp-vscode/README.md

@@ -81,12 +81,12 @@ mpp-vscode/
   - [x] autodev.cancelDiff - 取消差异
   - [x] autodev.runAgent - 运行 Agent
 - [x] 快捷键绑定 (Cmd+Shift+A)
-- [ ] 状态栏集成
+- [x] 状态栏集成
 
-### Phase 6: 高级功能
-- [ ] DevIns 语言支持
-  - [ ] 语法高亮
-  - [ ] 自动补全
+### Phase 6: 高级功能 ✅
+- [x] DevIns 语言支持
+  - [x] 语法高亮 (TextMate grammar)
+  - [x] 自动补全 (/, @, $ 触发)
 - [ ] 代码索引集成
 - [ ] 领域词典支持
 - [ ] React Webview UI (替换内嵌 HTML)

mpp-vscode/package.json

@@ -101,6 +101,25 @@
         "key": "ctrl+shift+a",
         "mac": "cmd+shift+a"
       }
+    ],
+    "languages": [
+      {
+        "id": "DevIns",
+        "aliases": ["devins", "devin"],
+        "extensions": [".devins", ".devin"],
+        "configuration": "syntaxes/language-configuration.json",
+        "icon": {
+          "light": "./resources/icon.svg",
+          "dark": "./resources/icon.svg"
+        }
+      }
+    ],
+    "grammars": [
+      {
+        "language": "DevIns",
+        "scopeName": "source.devins",
+        "path": "syntaxes/DevIns.tmLanguage.json"
+      }
     ]
   },
   "scripts": {

mpp-vscode/resources/icon.svg

@@ -8,11 +8,14 @@ import * as vscode from 'vscode';
 import { IDEServer } from './services/ide-server';
 import { DiffManager, DiffContentProvider } from './services/diff-manager';
 import { ChatViewProvider } from './providers/chat-view';
+import { StatusBarManager } from './services/status-bar';
+import { registerDevInsCompletionProvider } from './providers/devins-completion';
 import { createLogger } from './utils/logger';
 
 export const DIFF_SCHEME = 'autodev-diff';
 
 let ideServer: IDEServer | undefined;
+let statusBar: StatusBarManager | undefined;
 let logger: vscode.OutputChannel;
 let log: (message: string) => void = () => {};
 
@@ -24,6 +27,10 @@ export async function activate(context: vscode.ExtensionContext) {
   log = createLogger(context, logger);
   log('AutoDev extension activated');
 
+  // Initialize Status Bar
+  statusBar = new StatusBarManager();
+  context.subscriptions.push({ dispose: () => statusBar?.dispose() });
+
   // Initialize Diff Manager
   const diffContentProvider = new DiffContentProvider();
   const diffManager = new DiffManager(log, diffContentProvider);
@@ -113,6 +120,10 @@ export async function activate(context: vscode.ExtensionContext) {
     })
   );
 
+  // Register DevIns language completion provider
+  context.subscriptions.push(registerDevInsCompletionProvider(context));
+  log('DevIns language support registered');
+
   // Show welcome message on first install
   const welcomeShownKey = 'autodev.welcomeShown';
   if (!context.globalState.get(welcomeShownKey)) {

mpp-vscode/src/extension.ts

@@ -0,0 +1,156 @@
+/**
+ * DevIns Completion Provider - Auto-completion for DevIns language
+ */
+
+import * as vscode from 'vscode';
+import { CompletionManager } from '../bridge/mpp-core';
+
+/**
+ * Built-in DevIns commands
+ */
+const BUILTIN_COMMANDS = [
+  { name: '/file', description: 'Read file content', args: ':path' },
+  { name: '/write', description: 'Write content to file', args: ':path' },
+  { name: '/run', description: 'Run shell command', args: ':command' },
+  { name: '/patch', description: 'Apply patch to file', args: ':path' },
+  { name: '/commit', description: 'Create git commit', args: ':message' },
+  { name: '/symbol', description: 'Find symbol in codebase', args: ':name' },
+  { name: '/rev', description: 'Review code changes', args: '' },
+  { name: '/refactor', description: 'Refactor code', args: ':instruction' },
+  { name: '/test', description: 'Generate tests', args: '' },
+  { name: '/doc', description: 'Generate documentation', args: '' },
+  { name: '/help', description: 'Show available commands', args: '' }
+];
+
+/**
+ * Built-in agents
+ */
+const BUILTIN_AGENTS = [
+  { name: '@code', description: 'Code generation agent' },
+  { name: '@test', description: 'Test generation agent' },
+  { name: '@doc', description: 'Documentation agent' },
+  { name: '@review', description: 'Code review agent' },
+  { name: '@refactor', description: 'Refactoring agent' },
+  { name: '@explain', description: 'Code explanation agent' }
+];
+
+/**
+ * Built-in variables
+ */
+const BUILTIN_VARIABLES = [
+  { name: '$selection', description: 'Current editor selection' },
+  { name: '$file', description: 'Current file path' },
+  { name: '$fileName', description: 'Current file name' },
+  { name: '$language', description: 'Current file language' },
+  { name: '$workspace', description: 'Workspace root path' },
+  { name: '$clipboard', description: 'Clipboard content' }
+];
+
+/**
+ * DevIns Completion Provider
+ */
+export class DevInsCompletionProvider implements vscode.CompletionItemProvider {
+  private completionManager: CompletionManager | undefined;
+
+  constructor() {
+    try {
+      this.completionManager = new CompletionManager();
+    } catch (e) {
+      // mpp-core not available, use built-in completions only
+    }
+  }
+
+  async provideCompletionItems(
+    document: vscode.TextDocument,
+    position: vscode.Position,
+    _token: vscode.CancellationToken,
+    _context: vscode.CompletionContext
+  ): Promise<vscode.CompletionItem[]> {
+    const linePrefix = document.lineAt(position).text.substring(0, position.character);
+    const items: vscode.CompletionItem[] = [];
+
+    // Command completion (starts with /)
+    if (linePrefix.endsWith('/') || /\/[a-zA-Z]*$/.test(linePrefix)) {
+      items.push(...this.getCommandCompletions(linePrefix));
+    }
+
+    // Agent completion (starts with @)
+    if (linePrefix.endsWith('@') || /@[a-zA-Z]*$/.test(linePrefix)) {
+      items.push(...this.getAgentCompletions(linePrefix));
+    }
+
+    // Variable completion (starts with $)
+    if (linePrefix.endsWith('$') || /\$[a-zA-Z]*$/.test(linePrefix)) {
+      items.push(...this.getVariableCompletions(linePrefix));
+    }
+
+    return items;
+  }
+
+  private getCommandCompletions(linePrefix: string): vscode.CompletionItem[] {
+    const prefix = linePrefix.match(/\/([a-zA-Z]*)$/)?.[1] || '';
+    
+    return BUILTIN_COMMANDS
+      .filter(cmd => cmd.name.substring(1).startsWith(prefix))
+      .map(cmd => {
+        const item = new vscode.CompletionItem(
+          cmd.name,
+          vscode.CompletionItemKind.Function
+        );
+        item.detail = cmd.description;
+        item.insertText = cmd.name.substring(1) + cmd.args;
+        item.documentation = new vscode.MarkdownString(`**${cmd.name}**\n\n${cmd.description}`);
+        return item;
+      });
+  }
+
+  private getAgentCompletions(linePrefix: string): vscode.CompletionItem[] {
+    const prefix = linePrefix.match(/@([a-zA-Z]*)$/)?.[1] || '';
+    
+    return BUILTIN_AGENTS
+      .filter(agent => agent.name.substring(1).startsWith(prefix))
+      .map(agent => {
+        const item = new vscode.CompletionItem(
+          agent.name,
+          vscode.CompletionItemKind.Class
+        );
+        item.detail = agent.description;
+        item.insertText = agent.name.substring(1);
+        item.documentation = new vscode.MarkdownString(`**${agent.name}**\n\n${agent.description}`);
+        return item;
+      });
+  }
+
+  private getVariableCompletions(linePrefix: string): vscode.CompletionItem[] {
+    const prefix = linePrefix.match(/\$([a-zA-Z]*)$/)?.[1] || '';
+    
+    return BUILTIN_VARIABLES
+      .filter(v => v.name.substring(1).startsWith(prefix))
+      .map(v => {
+        const item = new vscode.CompletionItem(
+          v.name,
+          vscode.CompletionItemKind.Variable
+        );
+        item.detail = v.description;
+        item.insertText = v.name.substring(1);
+        item.documentation = new vscode.MarkdownString(`**${v.name}**\n\n${v.description}`);
+        return item;
+      });
+  }
+}
+
+/**
+ * Register DevIns completion provider
+ */
+export function registerDevInsCompletionProvider(
+  context: vscode.ExtensionContext
+): vscode.Disposable {
+  const provider = new DevInsCompletionProvider();
+  
+  return vscode.languages.registerCompletionItemProvider(
+    { language: 'DevIns', scheme: 'file' },
+    provider,
+    '/', '@', '$'
+  );
+}
+

mpp-vscode/src/providers/devins-completion.ts

@@ -0,0 +1,128 @@
+/**
+ * Status Bar Service - Shows AutoDev status in VSCode status bar
+ */
+
+import * as vscode from 'vscode';
+
+export type StatusBarState = 'idle' | 'thinking' | 'streaming' | 'error';
+
+/**
+ * Status Bar Manager for AutoDev
+ */
+export class StatusBarManager {
+  private statusBarItem: vscode.StatusBarItem;
+  private state: StatusBarState = 'idle';
+  private animationInterval: NodeJS.Timeout | undefined;
+  private animationFrame = 0;
+
+  constructor() {
+    this.statusBarItem = vscode.window.createStatusBarItem(
+      vscode.StatusBarAlignment.Right,
+      100
+    );
+    this.statusBarItem.command = 'autodev.chat';
+    this.statusBarItem.tooltip = 'Click to open AutoDev Chat';
+    this.updateDisplay();
+    this.statusBarItem.show();
+  }
+
+  /**
+   * Set the status bar state
+   */
+  setState(state: StatusBarState, message?: string): void {
+    this.state = state;
+    this.stopAnimation();
+
+    if (state === 'thinking' || state === 'streaming') {
+      this.startAnimation();
+    }
+
+    this.updateDisplay(message);
+  }
+
+  /**
+   * Show a temporary message
+   */
+  showMessage(message: string, timeout = 3000): void {
+    const previousState = this.state;
+    this.updateDisplay(message);
+    
+    setTimeout(() => {
+      if (this.state === previousState) {
+        this.updateDisplay();
+      }
+    }, timeout);
+  }
+
+  /**
+   * Dispose the status bar item
+   */
+  dispose(): void {
+    this.stopAnimation();
+    this.statusBarItem.dispose();
+  }
+
+  private updateDisplay(message?: string): void {
+    const icons: Record<StatusBarState, string> = {
+      idle: '$(sparkle)',
+      thinking: this.getThinkingIcon(),
+      streaming: this.getStreamingIcon(),
+      error: '$(error)'
+    };
+
+    const colors: Record<StatusBarState, string | undefined> = {
+      idle: undefined,
+      thinking: new vscode.ThemeColor('statusBarItem.warningForeground').toString(),
+      streaming: new vscode.ThemeColor('statusBarItem.prominentForeground').toString(),
+      error: new vscode.ThemeColor('statusBarItem.errorForeground').toString()
+    };
+
+    const icon = icons[this.state];
+    const text = message || this.getDefaultText();
+    
+    this.statusBarItem.text = `${icon} ${text}`;
+    this.statusBarItem.backgroundColor = this.state === 'error' 
+      ? new vscode.ThemeColor('statusBarItem.errorBackground')
+      : undefined;
+  }
+
+  private getDefaultText(): string {
+    switch (this.state) {
+      case 'idle':
+        return 'AutoDev';
+      case 'thinking':
+        return 'Thinking...';
+      case 'streaming':
+        return 'Generating...';
+      case 'error':
+        return 'Error';
+    }
+  }
+
+  private getThinkingIcon(): string {
+    const frames = ['$(loading~spin)', '$(sync~spin)', '$(gear~spin)'];
+    return frames[this.animationFrame % frames.length];
+  }
+
+  private getStreamingIcon(): string {
+    const frames = ['$(pulse)', '$(radio-tower)', '$(broadcast)'];
+    return frames[this.animationFrame % frames.length];
+  }
+
+  private startAnimation(): void {
+    this.animationFrame = 0;
+    this.animationInterval = setInterval(() => {
+      this.animationFrame++;
+      this.updateDisplay();
+    }, 500);
+  }
+
+  private stopAnimation(): void {
+    if (this.animationInterval) {
+      clearInterval(this.animationInterval);
+      this.animationInterval = undefined;
+    }
+    this.animationFrame = 0;
+  }
+}
+