editormate 0.0.0-stage → 1.0.2

package/extension/src/commands_manager.ts

@@ -0,0 +1,466 @@
+/**
+ * EditorMate — IDE Commands & Alias Manager
+ * Manages EditorMate supported remote commands, 3 custom assignable IDE slots, and aliases.
+ */
+
+import * as vscode from 'vscode';
+import * as http from 'http';
+
+export interface CommandAlias {
+  alias: string;
+  command: string;
+  description?: string;
+  createdAt: number;
+}
+
+export interface SupportedCommand {
+  id: string;
+  label: string;
+  description: string;
+}
+
+export const EDITORMATE_PRIMARY_COMMANDS: SupportedCommand[] = [
+  { id: '/status', label: '/status', description: 'Agent Working State & Health' },
+  { id: '/snap', label: '/snap', description: 'Capture Silent IDE Window Snapshot' },
+  { id: '/terminal', label: '/terminal', description: 'Execute Workstation Shell Command' },
+  { id: '/approve', label: '/approve', description: 'One-Tap Turn Approval' },
+];
+
+export const EDITORMATE_BUILTIN_COMMANDS: SupportedCommand[] = [
+  ...EDITORMATE_PRIMARY_COMMANDS,
+  { id: '/diff', label: '/diff', description: 'Git Modified Status & Diff Summary' },
+  { id: '/pdf', label: '/pdf', description: 'Generate Executive PDF Status Report' },
+  { id: '/chats', label: '/chats', description: 'Switchboard: List Recent Sessions' },
+  { id: '/select', label: '/select', description: 'Switch Active IDE Chat Session' },
+  { id: '/reject', label: '/reject', description: 'Decline / Abort Pending Action' },
+  { id: '/stop', label: '/stop', description: 'Stop Long-Running Coding Loop' },
+];
+
+export interface IdeCustomSlot {
+  slotIndex: number;
+  alias: string;
+  command: string;
+  label: string;
+  description: string;
+}
+
+export class CommandsManager {
+  private _cachedCommands: string[] = [];
+  private _lastFetchTime = 0;
+
+  constructor(private readonly _context: vscode.ExtensionContext) {}
+
+  /**
+   * Retrieves all available IDE commands (cached 60s) for slot assignment.
+   */
+  public async getAvailableCommands(forceRefresh: boolean = false): Promise<string[]> {
+    const now = Date.now();
+    if (!forceRefresh && this._cachedCommands.length > 0 && now - this._lastFetchTime < 60000) {
+      return this._cachedCommands;
+    }
+
+    try {
+      const all = await vscode.commands.getCommands(true);
+      this._cachedCommands = all
+        .filter(
+          (c) =>
+            !c.startsWith('_') &&
+            !c.includes('internal') &&
+            !c.startsWith('vscode.') &&
+            (c.includes('.') || c.includes(':'))
+        )
+        .sort();
+      this._lastFetchTime = now;
+      return this._cachedCommands;
+    } catch {
+      return this._cachedCommands;
+    }
+  }
+
+  public getPrimaryCommands(): SupportedCommand[] {
+    return EDITORMATE_PRIMARY_COMMANDS;
+  }
+
+  public getBuiltinCommands(): SupportedCommand[] {
+    return EDITORMATE_BUILTIN_COMMANDS;
+  }
+
+  public getCustomSlots(): IdeCustomSlot[] {
+    return (
+      this._context.globalState.get<IdeCustomSlot[]>('editormate.ideCustomSlots') || [
+        {
+          slotIndex: 1,
+          alias: 'fmt',
+          command: 'editor.action.formatDocument',
+          label: 'Format Document',
+          description: 'Format active document in editor',
+        },
+        {
+          slotIndex: 2,
+          alias: 'save',
+          command: 'workbench.action.files.save',
+          label: 'Save File',
+          description: 'Save current active file',
+        },
+        {
+          slotIndex: 3,
+          alias: 'term',
+          command: 'workbench.action.terminal.toggleTerminal',
+          label: 'Toggle Terminal',
+          description: 'Toggle integrated terminal panel',
+        },
+      ]
+    );
+  }
+
+  public async setCustomSlots(slots: IdeCustomSlot[]): Promise<void> {
+    await this._context.globalState.update('editormate.ideCustomSlots', slots);
+    // Mirror slots to customShortcuts for daemon sync
+    const shortcuts = slots.map((s) => ({
+      id: String(s.slotIndex),
+      label: s.alias,
+      command: s.command,
+      description: s.description,
+    }));
+    await this._context.globalState.update('editormate.customShortcuts', shortcuts);
+    await this.syncSlotsToDaemon(slots);
+  }
+
+  public async updateSlot(
+    slotIndex: number,
+    alias: string,
+    command: string,
+    label?: string
+  ): Promise<boolean> {
+    const slots = this.getCustomSlots();
+    const target = slots.find((s) => s.slotIndex === slotIndex);
+    const cleanAlias = alias.trim().replace(/^\//, '').toLowerCase();
+    const cleanCmd = command.trim();
+    const friendlyLabel = label?.trim() || cleanCmd.split('.').pop() || cleanCmd;
+
+    if (target) {
+      target.alias = cleanAlias;
+      target.command = cleanCmd;
+      target.label = friendlyLabel;
+      target.description = `Execute ${cleanCmd}`;
+    } else {
+      slots.push({
+        slotIndex,
+        alias: cleanAlias,
+        command: cleanCmd,
+        label: friendlyLabel,
+        description: `Execute ${cleanCmd}`,
+      });
+    }
+
+    await this.setCustomSlots(slots);
+    vscode.window.showInformationMessage(`✅ EditorMate: Slot ${slotIndex} updated to /${cleanAlias} ➔ ${cleanCmd}`);
+    return true;
+  }
+
+  public async configureSlot(slotIndex: number): Promise<boolean> {
+    vscode.window.setStatusBarMessage('🔍 Loading IDE commands...', 1500);
+    const commands = await this.getAvailableCommands();
+    const picked = await vscode.window.showQuickPick(
+      commands.map((c) => ({ label: c, description: 'VS Code Command' })),
+      { placeHolder: `Assign IDE Command to Slot ${slotIndex}:` }
+    );
+    if (!picked) return false;
+
+    const friendlyLabel = await vscode.window.showInputBox({
+      prompt: `Enter friendly label for Slot ${slotIndex} (command: ${picked.label}):`,
+      value: picked.label.split('.').pop() || picked.label,
+    });
+    if (!friendlyLabel) return false;
+
+    const slots = this.getCustomSlots();
+    const target = slots.find((s) => s.slotIndex === slotIndex);
+    if (target) {
+      target.command = picked.label;
+      target.label = friendlyLabel.trim();
+      target.description = `Execute ${picked.label}`;
+    } else {
+      const defaultAlias = slotIndex === 1 ? 'fmt' : slotIndex === 2 ? 'save' : 'term';
+      slots.push({
+        slotIndex,
+        alias: defaultAlias,
+        command: picked.label,
+        label: friendlyLabel.trim(),
+        description: `Execute ${picked.label}`,
+      });
+    }
+    await this.setCustomSlots(slots);
+    vscode.window.showInformationMessage(`✅ EditorMate: Slot ${slotIndex} assigned to "${picked.label}"`);
+    return true;
+  }
+
+  public async promptConfigureAllSlots(): Promise<void> {
+    const slots = this.getCustomSlots();
+    const items = slots.map((s) => ({
+      label: `Slot ${s.slotIndex}: ${s.label}`,
+      description: `➔ ${s.command}`,
+      slotIndex: s.slotIndex,
+    }));
+
+    const pick = await vscode.window.showQuickPick(items, {
+      placeHolder: 'Select which Assignable IDE Slot to configure:',
+    });
+
+    if (pick) {
+      await this.configureSlot(pick.slotIndex);
+    }
+  }
+
+  public getAliases(): CommandAlias[] {
+    return (
+      this._context.globalState.get<CommandAlias[]>('editormate.commandAliases') || [
+        { alias: 'fmt', command: 'editor.action.formatDocument', description: 'Format active document', createdAt: Date.now() },
+        { alias: 'save', command: 'workbench.action.files.save', description: 'Save current active file', createdAt: Date.now() },
+        { alias: 'terminal', command: 'workbench.action.terminal.toggleTerminal', description: 'Toggle integrated terminal', createdAt: Date.now() },
+        { alias: 'snap', command: '/snap', description: 'Capture silent IDE window snapshot', createdAt: Date.now() },
+        { alias: 'st', command: '/status', description: 'Inspect agent working state', createdAt: Date.now() },
+      ]
+    );
+  }
+
+  public async setAliases(aliases: CommandAlias[]): Promise<void> {
+    await this._context.globalState.update('editormate.commandAliases', aliases);
+    const shortcuts = aliases.map((a, i) => ({
+      id: String(i + 1),
+      label: a.alias,
+      command: a.command,
+      description: a.description,
+    }));
+    await this._context.globalState.update('editormate.customShortcuts', shortcuts);
+    await this.syncAliasesToDaemon(aliases);
+  }
+
+  public async validateNewAlias(newAlias: string, currentOldAlias?: string): Promise<{ valid: boolean; error?: string; cleanAlias: string }> {
+    const cleanAlias = newAlias.trim().toLowerCase().replace(/^\//, '');
+    if (!cleanAlias) {
+      return { valid: false, error: 'Alias name cannot be empty.', cleanAlias };
+    }
+
+    const existingAliases = this.getAliases();
+    const conflictAlias = existingAliases.find(
+      (a) => a.alias.toLowerCase() === cleanAlias && a.alias.toLowerCase() !== (currentOldAlias?.toLowerCase() || '')
+    );
+    if (conflictAlias) {
+      return {
+        valid: false,
+        error: `Alias "${cleanAlias}" is already taken by command "${conflictAlias.command}".`,
+        cleanAlias,
+      };
+    }
+
+    return { valid: true, cleanAlias };
+  }
+
+  public async addAlias(alias: string, command: string, description?: string): Promise<boolean> {
+    const validation = await this.validateNewAlias(alias);
+    if (!validation.valid) {
+      vscode.window.showErrorMessage(`❌ EditorMate: ${validation.error}`);
+      return false;
+    }
+    const cleanAlias = validation.cleanAlias;
+    const aliases = this.getAliases().filter((a) => a.alias.toLowerCase() !== cleanAlias);
+    aliases.push({
+      alias: cleanAlias,
+      command: command.trim(),
+      description: description?.trim() || `Execute ${command}`,
+      createdAt: Date.now(),
+    });
+    await this.setAliases(aliases);
+    vscode.window.showInformationMessage(`✅ EditorMate: Added alias "/${cleanAlias}" ➔ ${command}`);
+    return true;
+  }
+
+  public async editAlias(oldAlias: string, newAlias: string, targetCommand: string): Promise<boolean> {
+    const validation = await this.validateNewAlias(newAlias, oldAlias);
+    if (!validation.valid) {
+      vscode.window.showErrorMessage(`❌ EditorMate: ${validation.error}`);
+      return false;
+    }
+    const cleanNewAlias = validation.cleanAlias;
+    const cleanOld = oldAlias.trim().toLowerCase().replace(/^\//, '');
+
+    const aliases = this.getAliases().filter(
+      (a) => a.alias.toLowerCase() !== cleanOld && a.alias.toLowerCase() !== cleanNewAlias
+    );
+    aliases.push({
+      alias: cleanNewAlias,
+      command: targetCommand.trim(),
+      description: `Execute ${targetCommand}`,
+      createdAt: Date.now(),
+    });
+    await this.setAliases(aliases);
+    vscode.window.showInformationMessage(`✅ EditorMate: Updated alias "/${cleanOld}" ➔ "/${cleanNewAlias}"`);
+    return true;
+  }
+
+  public async removeAlias(alias: string): Promise<boolean> {
+    const aliases = this.getAliases().filter((a) => a.alias.toLowerCase() !== alias.trim().toLowerCase());
+    await this.setAliases(aliases);
+    vscode.window.showInformationMessage(`🗑️ EditorMate: Removed alias "${alias}"`);
+    return true;
+  }
+
+  public findCommandByAlias(input: string): string | null {
+    const clean = input.trim().toLowerCase().replace(/^\//, '');
+    const slot = this.getCustomSlots().find((s) => s.alias.toLowerCase() === clean);
+    if (slot) return slot.command;
+    const primary = this.getPrimaryCommands().find((p) => p.id.replace(/^\//, '').toLowerCase() === clean);
+    if (primary) return primary.id;
+    const match = this.getAliases().find((a) => a.alias.toLowerCase() === clean);
+    return match ? match.command : null;
+  }
+
+  /**
+   * Prompts user to add an alias for either a supported command or an assignable IDE command.
+   */
+  public async promptAddAlias(preselectedCommand?: string): Promise<void> {
+    let targetCommand = preselectedCommand;
+
+    if (!targetCommand) {
+      const builtin = this.getBuiltinCommands().map((b) => ({
+        label: b.id,
+        description: b.description,
+        detail: 'EditorMate Built-in Remote Command',
+      }));
+
+      const slots = this.getCustomSlots().map((s) => ({
+        label: s.command,
+        description: `Slot ${s.slotIndex}: ${s.label}`,
+        detail: 'Assignable IDE Command',
+      }));
+
+      const picked = await vscode.window.showQuickPick([...builtin, ...slots], {
+        placeHolder: 'Select a supported command or assignable slot to create an alias for:',
+      });
+      if (!picked) return;
+      targetCommand = picked.label;
+    }
+
+    const defaultAlias = targetCommand.startsWith('/') ? targetCommand.replace(/^\//, '') : targetCommand.split('.').pop() || '';
+    const aliasName = await vscode.window.showInputBox({
+      prompt: `Enter alias shortcut name for: ${targetCommand}`,
+      placeHolder: 'e.g. s, snap, st, fmt, save, run, test',
+      value: defaultAlias,
+      validateInput: (val) => (!val || !val.trim() ? 'Alias name cannot be empty' : null),
+    });
+
+    if (!aliasName) return;
+
+    const desc = await vscode.window.showInputBox({
+      prompt: `Optional description for alias "${aliasName.trim()}":`,
+      placeHolder: `Runs ${targetCommand}`,
+      value: `Runs ${targetCommand}`,
+    });
+
+    await this.addAlias(aliasName.trim(), targetCommand, desc);
+  }
+
+  /**
+   * Interactive dropdown to manage, test, or delete existing aliases.
+   */
+  public async promptManageAliases(): Promise<void> {
+    const aliases = this.getAliases();
+    const items = [
+      { label: '$(plus) Add New Command Alias...', action: 'add' },
+      { label: '$(gear) Configure 3 Assignable IDE Slots...', action: 'configureSlots' },
+      ...aliases.map((a) => ({
+        label: `$(symbol-keyword) /${a.alias}`,
+        description: `➔ ${a.command}`,
+        detail: a.description || undefined,
+        action: 'edit',
+        alias: a,
+      })),
+    ];
+
+    const pick: any = await vscode.window.showQuickPick(items, {
+      placeHolder: 'Manage EditorMate Command Aliases & IDE Slots:',
+    });
+
+    if (!pick) return;
+
+    if (pick.action === 'add') {
+      await this.promptAddAlias();
+    } else if (pick.action === 'configureSlots') {
+      await this.promptConfigureAllSlots();
+    } else if (pick.alias) {
+      const a = pick.alias as CommandAlias;
+      const subAction = await vscode.window.showQuickPick(
+        [
+          { label: '$(play) Test Run Command', id: 'run' },
+          { label: '$(trash) Delete Alias', id: 'delete' },
+        ],
+        { placeHolder: `Alias "/${a.alias}" (runs: ${a.command})` }
+      );
+
+      if (subAction?.id === 'run') {
+        try {
+          if (a.command.startsWith('/')) {
+            vscode.window.showInformationMessage(`⚡ EditorMate: Executed remote command ${a.command}`);
+          } else {
+            await vscode.commands.executeCommand(a.command);
+            vscode.window.setStatusBarMessage(`⚡ Executed alias [/${a.alias}]`, 3000);
+          }
+        } catch (e: any) {
+          vscode.window.showErrorMessage(`Failed to run ${a.command}: ${e.message}`);
+        }
+      } else if (subAction?.id === 'delete') {
+        await this.removeAlias(a.alias);
+      }
+    }
+  }
+
+  private async syncAliasesToDaemon(aliases: CommandAlias[]): Promise<void> {
+    try {
+      const shortcuts = aliases.slice(0, 8).map((a, i) => ({
+        id: String(i + 1),
+        label: a.alias,
+        command: a.command,
+      }));
+      const payload = JSON.stringify({ shortcuts });
+      const req = http.request(
+        'http://127.0.0.1:4588/api/shortcuts/save',
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(payload),
+          },
+        },
+        () => {}
+      );
+      req.on('error', () => {});
+      req.write(payload);
+      req.end();
+    } catch {}
+  }
+
+  private async syncSlotsToDaemon(slots: IdeCustomSlot[]): Promise<void> {
+    try {
+      const shortcuts = slots.map((s) => ({
+        id: String(s.slotIndex),
+        label: s.alias,
+        command: s.command,
+      }));
+      const payload = JSON.stringify({ shortcuts });
+      const req = http.request(
+        'http://127.0.0.1:4588/api/shortcuts/save',
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(payload),
+          },
+        },
+        () => {}
+      );
+      req.on('error', () => {});
+      req.write(payload);
+      req.end();
+    } catch {}
+  }
+}