@pellux/goodvibes-tui 0.18.4

package/src/input/commands.ts

@@ -0,0 +1,127 @@
+import type { CommandRegistry } from './command-registry.ts';
+import { policyCommand } from './commands/policy.ts';
+import { providerCommand } from './commands/provider.ts';
+import { evalCommand } from './commands/eval.ts';
+import { sessionCommand } from './commands/session.ts';
+import { recallCommand } from './commands/memory.ts';
+import { knowledgeCommand } from './commands/knowledge.ts';
+import { registerShellCoreCommands } from './commands/shell-core.ts';
+import { registerConfigCommand } from './commands/config.ts';
+import { registerSessionWorkflowCommands } from './commands/session-workflow.ts';
+import { registerDiscoveryRuntimeCommands } from './commands/discovery-runtime.ts';
+import { registerPlanningRuntimeCommands } from './commands/planning-runtime.ts';
+import { registerScheduleRuntimeCommands } from './commands/schedule-runtime.ts';
+import { registerBranchRuntimeCommands } from './commands/branch-runtime.ts';
+import { registerOperatorRuntimeCommands } from './commands/operator-runtime.ts';
+import { registerIntegrationRuntimeCommands } from './commands/integration-runtime.ts';
+import { registerDiffRuntimeCommands } from './commands/diff-runtime.ts';
+import { registerGitRuntimeCommands } from './commands/git-runtime.ts';
+import { registerNotifyRuntimeCommands } from './commands/notify-runtime.ts';
+import { registerReplayRuntimeCommands } from './commands/replay-runtime.ts';
+import { registerShareRuntimeCommands } from './commands/share-runtime.ts';
+import { registerLocalSetupCommands } from './commands/local-setup.ts';
+import { registerProductRuntimeCommands } from './commands/product-runtime.ts';
+import { registerPlatformRuntimeCommands } from './commands/platform-runtime.ts';
+import { registerProfileSyncRuntimeCommands } from './commands/profile-sync-runtime.ts';
+import { registerManagedRuntimeCommands } from './commands/managed-runtime.ts';
+import { registerPlatformAccessRuntimeCommands } from './commands/platform-access-runtime.ts';
+import { registerPlatformServicesRuntimeCommands } from './commands/platform-services-runtime.ts';
+import { registerTeamworkRuntimeCommands } from './commands/teamwork-runtime.ts';
+import { registerMarketplaceRuntimeCommands } from './commands/marketplace-runtime.ts';
+import { registerGuidanceRuntimeCommands } from './commands/guidance-runtime.ts';
+import { registerRemoteRuntimeCommands } from './commands/remote-runtime.ts';
+import { registerTeleportRuntimeCommands } from './commands/teleport-runtime.ts';
+import { registerSubscriptionRuntimeCommands } from './commands/subscription-runtime.ts';
+import { registerHooksRuntimeCommands } from './commands/hooks-runtime.ts';
+import { registerControlRoomRuntimeCommands } from './commands/control-room-runtime.ts';
+import { registerMcpRuntimeCommands } from './commands/mcp-runtime.ts';
+import { registerSessionContentCommands } from './commands/session-content.ts';
+import { registerLocalRuntimeCommands } from './commands/local-runtime.ts';
+import { registerExperienceRuntimeCommands } from './commands/experience-runtime.ts';
+import { registerIncidentRuntimeCommands } from './commands/incident-runtime.ts';
+import { registerMemoryProductRuntimeCommands } from './commands/memory-product-runtime.ts';
+import { registerSkillsRuntimeCommands } from './commands/skills-runtime.ts';
+import { registerServicesRuntimeCommands } from './commands/services-runtime.ts';
+import { registerTasksRuntimeCommands } from './commands/tasks-runtime.ts';
+import { registerPermissionsRuntimeCommands } from './commands/permissions-runtime.ts';
+import { registerLocalProviderRuntimeCommands } from './commands/local-provider-runtime.ts';
+import { registerHealthRuntimeCommands } from './commands/health-runtime.ts';
+import { registerSettingsSyncRuntimeCommands } from './commands/settings-sync-runtime.ts';
+import { registerWorktreeRuntimeCommands } from './commands/worktree-runtime.ts';
+import { registerProviderAccountsRuntimeCommands } from './commands/provider-accounts-runtime.ts';
+import { registerLocalAuthRuntimeCommands } from './commands/local-auth-runtime.ts';
+import { registerIntelligenceRuntimeCommands } from './commands/intelligence-runtime.ts';
+import { registerConversationRuntimeCommands } from './commands/conversation-runtime.ts';
+
+/**
+ * registerBuiltinCommands - Register all built-in slash commands into the registry.
+ * Call once during application startup.
+ */
+export function registerBuiltinCommands(registry: CommandRegistry): void {
+  registerShellCoreCommands(registry);
+  registerConfigCommand(registry);
+  registerOperatorRuntimeCommands(registry);
+  registerIntegrationRuntimeCommands(registry);
+  registerDiffRuntimeCommands(registry);
+  registerGitRuntimeCommands(registry);
+  registerNotifyRuntimeCommands(registry);
+  registerReplayRuntimeCommands(registry);
+  registerShareRuntimeCommands(registry);
+  registerLocalSetupCommands(registry);
+  registerProductRuntimeCommands(registry);
+  registerPlatformRuntimeCommands(registry);
+  registerProfileSyncRuntimeCommands(registry);
+  registerManagedRuntimeCommands(registry);
+  registerPlatformAccessRuntimeCommands(registry);
+  registerPlatformServicesRuntimeCommands(registry);
+  registerTeamworkRuntimeCommands(registry);
+  registerMarketplaceRuntimeCommands(registry);
+  registerGuidanceRuntimeCommands(registry);
+  registerRemoteRuntimeCommands(registry);
+  registerTeleportRuntimeCommands(registry);
+  registerSubscriptionRuntimeCommands(registry);
+  registerHooksRuntimeCommands(registry);
+  registerControlRoomRuntimeCommands(registry);
+  registerMcpRuntimeCommands(registry);
+  registerIncidentRuntimeCommands(registry);
+  registerMemoryProductRuntimeCommands(registry);
+  registerSkillsRuntimeCommands(registry);
+  registerExperienceRuntimeCommands(registry);
+  registerServicesRuntimeCommands(registry);
+  registerTasksRuntimeCommands(registry);
+  registerPermissionsRuntimeCommands(registry);
+  registerLocalProviderRuntimeCommands(registry);
+  registerHealthRuntimeCommands(registry);
+  registerSettingsSyncRuntimeCommands(registry);
+  registerWorktreeRuntimeCommands(registry);
+  registerProviderAccountsRuntimeCommands(registry);
+  registerLocalAuthRuntimeCommands(registry);
+  registerIntelligenceRuntimeCommands(registry);
+  registerConversationRuntimeCommands(registry);
+  registerLocalRuntimeCommands(registry);
+  registerSessionWorkflowCommands(registry);
+  registerDiscoveryRuntimeCommands(registry);
+  registerPlanningRuntimeCommands(registry);
+  registerScheduleRuntimeCommands(registry);
+  registerBranchRuntimeCommands(registry);
+  registerSessionContentCommands(registry);
+
+  // ── /policy ───────────────────────────────────────────────────────────────
+  registry.register(policyCommand);
+
+  // ── /provider ─────────────────────────────────────────────────────────────
+  registry.register(providerCommand);
+
+  // ── /eval ─────────────────────────────────────────────────────────────────
+  registry.register(evalCommand);
+
+  // ── /session ─────────────────────────────────────────────────────────────
+  registry.register(sessionCommand);
+
+  // ── /recall ──────────────────────────────────────────────────────────────
+  registry.register(recallCommand);
+
+  // ── /knowledge ───────────────────────────────────────────────────────────
+  registry.register(knowledgeCommand);
+
+}

package/src/input/file-picker.ts

@@ -0,0 +1,192 @@
+import { readdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import type { ShellPathService } from '@pellux/goodvibes-sdk/platform/runtime/shell-paths';
+
+/**
+ * FilePickerModal - Fuzzy file finder triggered by @ in the input area.
+ * Walks the project directory, fuzzy-matches against the query,
+ * and lets the user select a file to insert its path.
+ */
+export class FilePickerModal {
+  constructor(private readonly shellPaths: Pick<ShellPathService, 'workingDirectory'>) {}
+
+  public active = false;
+  public query = '';
+  public searchFocused = true;
+  public results: string[] = [];
+  public selectedIndex = 0;
+  /** Position in the prompt where @ was typed — used to replace @query with the selected path */
+  public insertPos = 0;
+  /** When true, selected file inserts as !@path (inject mode) instead of @path */
+  public injectMode = false;
+
+  public allFiles: string[] = [];
+  private filesCached = false;
+  
+
+  private onUpdate: (() => void) | null = null;
+
+  /** Set a callback to trigger re-render when file list loads. */
+  setOnUpdate(fn: () => void): void {
+    this.onUpdate = fn;
+  }
+
+  /** Activate the file picker at the given prompt position. */
+  open(insertPos: number, injectMode = false): void {
+    this.active = true;
+    this.query = '';
+    this.searchFocused = true;
+    this.selectedIndex = 0;
+    this.insertPos = insertPos;
+    this.injectMode = injectMode;
+
+    if (this.filesCached) {
+      this.updateResults();
+    } else {
+      // Show "Loading..." immediately, load files in background
+      this.results = [];
+      this.loadFiles().then(() => {
+        if (this.active) {
+          this.updateResults();
+          this.onUpdate?.();
+        }
+      });
+    }
+  }
+
+  /** Close the file picker without selecting. */
+  close(): void {
+    this.active = false;
+    this.query = '';
+    this.searchFocused = true;
+    this.results = [];
+    this.selectedIndex = 0;
+    this.injectMode = false;
+  }
+
+  /** Update the search query and re-filter results. */
+  setQuery(q: string): void {
+    this.query = q;
+    this.selectedIndex = 0;
+    this.updateResults();
+  }
+
+  canFocusSearch(): boolean {
+    return true;
+  }
+
+  focusSearch(): void {
+    this.searchFocused = true;
+  }
+
+  blurSearch(): void {
+    this.searchFocused = false;
+  }
+
+  /** Move selection up. */
+  moveUp(): void {
+    if (this.selectedIndex > 0) this.selectedIndex--;
+  }
+
+  /** Move selection down. */
+  moveDown(): void {
+    if (this.selectedIndex < this.results.length - 1) this.selectedIndex++;
+  }
+
+  /** Get the currently selected file path, or null if none. */
+  getSelected(): string | null {
+    if (this.results.length === 0) return null;
+    return this.results[this.selectedIndex] ?? null;
+  }
+
+  /** Fuzzy match: does the query match the candidate? */
+  private fuzzyMatch(query: string, candidate: string): { match: boolean; score: number } {
+    if (query.length === 0) return { match: true, score: 0 };
+    const lowerQuery = query.toLowerCase();
+    const lowerCandidate = candidate.toLowerCase();
+
+    // Substring match (highest priority)
+    const subIdx = lowerCandidate.indexOf(lowerQuery);
+    if (subIdx !== -1) {
+      // Bonus for matching at start of filename (after last /)
+      const lastSlash = lowerCandidate.lastIndexOf('/');
+      const filenameStart = lastSlash + 1;
+      const isFilenameMatch = subIdx >= filenameStart;
+      return { match: true, score: isFilenameMatch ? 100 - subIdx : 50 - subIdx };
+    }
+
+    // Character-by-character fuzzy match
+    let qi = 0;
+    let score = 0;
+    for (let ci = 0; ci < lowerCandidate.length && qi < lowerQuery.length; ci++) {
+      if (lowerCandidate[ci] === lowerQuery[qi]) {
+        qi++;
+        score += 1;
+      }
+    }
+    if (qi === lowerQuery.length) {
+      return { match: true, score };
+    }
+    return { match: false, score: 0 };
+  }
+
+  private updateResults(): void {
+    if (this.query.length === 0) {
+      this.results = this.allFiles;
+      return;
+    }
+
+    const scored = this.allFiles
+      .map(f => ({ file: f, ...this.fuzzyMatch(this.query, f) }))
+      .filter(r => r.match)
+      .sort((a, b) => b.score - a.score)
+      ;
+
+    this.results = scored.map(r => r.file);
+    if (this.selectedIndex >= this.results.length) {
+      this.selectedIndex = Math.max(0, this.results.length - 1);
+    }
+  }
+
+  private async loadFiles(): Promise<void> {
+    const root = this.shellPaths.workingDirectory;
+    const files: string[] = [];
+    await this.walkDir(root, files, 0);
+    this.allFiles = files.sort();
+    this.filesCached = true;
+  }
+
+  private async walkDir(dir: string, files: string[], depth: number): Promise<void> {
+    if (depth > 8) return; // Limit depth
+    if (files.length > 5000) return; // Limit total files
+
+    let entries: import('node:fs').Dirent[];
+    try {
+      entries = (await readdir(dir, { withFileTypes: true })) as unknown as import('node:fs').Dirent[];
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      // Skip hidden dirs, node_modules, dist, .git
+      if (entry.name.startsWith('.')) continue;
+      if (entry.name === 'node_modules' || entry.name === 'dist') continue;
+
+      const fullPath = join(dir, entry.name);
+      const relPath = relative(this.shellPaths.workingDirectory, fullPath);
+
+      if (entry.isDirectory()) {
+        files.push(relPath + '/');
+        await this.walkDir(fullPath, files, depth + 1);
+      } else if (entry.isFile()) {
+        files.push(relPath);
+      }
+    }
+  }
+
+  /** Invalidate the file cache (e.g., after file operations). */
+  invalidateCache(): void {
+    this.filesCached = false;
+    this.allFiles = [];
+  }
+}

package/src/input/handler-command-route.ts

@@ -0,0 +1,106 @@
+import { loadSkillByTrigger } from '@pellux/goodvibes-sdk/platform/tools/registry-tool/skill-loader';
+import type { CommandContext, CommandRegistry } from './command-registry.ts';
+import type { AutocompleteEngine } from './autocomplete.ts';
+import type { InputToken } from '@pellux/goodvibes-sdk/platform/core/tokenizer';
+import type { ConversationManager } from '../core/conversation.ts';
+
+export type CommandModeRouteState = {
+  commandMode: boolean;
+  prompt: string;
+  cursorPos: number;
+  autocomplete: AutocompleteEngine | null;
+  modalStack: string[];
+  commandRegistry: CommandRegistry | null;
+  commandContext?: CommandContext;
+  conversationManager: ConversationManager | null;
+  requestRender: () => void;
+  handleEscape: () => void;
+};
+
+export function handleCommandModeToken(state: CommandModeRouteState, token: InputToken): boolean {
+  if (!state.commandMode) return false;
+
+  const closeCommandMode = (): void => {
+    state.commandMode = false;
+    for (let i = state.modalStack.length - 1; i >= 0; i--) {
+      if (state.modalStack[i] === 'command') state.modalStack.splice(i, 1);
+    }
+    state.autocomplete?.reset();
+    state.prompt = '';
+    state.cursorPos = 0;
+  };
+
+  if (token.type !== 'key') return false;
+
+  if (token.logicalName === 'escape') {
+    state.handleEscape();
+    return true;
+  }
+  if (token.logicalName === 'up') {
+    state.autocomplete?.moveUp();
+    return true;
+  }
+  if (token.logicalName === 'down') {
+    state.autocomplete?.moveDown();
+    return true;
+  }
+  if (token.logicalName === 'tab') {
+    const selected = state.autocomplete?.getSelected();
+    if (selected) {
+      state.prompt = `/${selected.name} `;
+      state.cursorPos = state.prompt.length;
+      state.autocomplete?.reset();
+    }
+    return true;
+  }
+  if (token.logicalName === 'backspace') {
+    if (state.cursorPos > 0) {
+      state.prompt = state.prompt.slice(0, state.cursorPos - 1) + state.prompt.slice(state.cursorPos);
+      state.cursorPos--;
+    }
+    if (state.prompt === '') {
+      closeCommandMode();
+      state.autocomplete?.reset();
+    } else {
+      const query = state.prompt.startsWith('/') ? state.prompt.slice(1) : '';
+      const spaceIdx = query.indexOf(' ');
+      if (spaceIdx === -1) state.autocomplete?.update(query);
+    }
+    return true;
+  }
+  if (token.logicalName === 'enter') {
+    const selectedCmd = state.autocomplete?.isActive ? state.autocomplete.getSelected() : undefined;
+    const raw = selectedCmd ? `/${selectedCmd.name}` : state.prompt.trim();
+    if (raw.startsWith('/') && state.commandRegistry && state.commandContext) {
+      closeCommandMode();
+      const parts = raw.slice(1).trim().split(/\s+/);
+      const name = parts[0];
+      const args = parts.slice(1);
+      const ctx = state.commandContext;
+      (ctx.executeCommand?.(name, args) ?? state.commandRegistry.execute(name, args, ctx)).then((handled) => {
+        if (handled) {
+          state.requestRender();
+        } else {
+          const shellPaths = state.commandContext?.workspace.shellPaths;
+          const skillContent = shellPaths
+            ? loadSkillByTrigger('/' + name, {
+                workingDirectory: shellPaths.workingDirectory,
+                homeDirectory: shellPaths.homeDirectory,
+              })
+            : null;
+          if (skillContent) {
+            state.commandContext?.submitInput?.(skillContent);
+          } else {
+            state.conversationManager?.log(`Unknown command: /${name}. Type /help for available commands.`, { fg: '#ef4444' });
+            state.requestRender();
+          }
+        }
+      });
+    } else {
+      closeCommandMode();
+    }
+    return true;
+  }
+
+  return token.logicalName !== 'left' && token.logicalName !== 'right';
+}