@pellux/goodvibes-tui 0.18.4

package/src/input/bookmark-modal.ts

@@ -0,0 +1,115 @@
+/**
+ * BookmarkModal — state management for the /bookmarks command modal.
+ *
+ * Lists bookmarks from BookmarkManager and tracks UI state:
+ * selected index, scroll offset, and pending action.
+ */
+
+import type { BookmarkEntry, BookmarkManager } from '@pellux/goodvibes-sdk/platform/bookmarks/manager';
+
+// ---------------------------------------------------------------------------
+// BookmarkModal
+// ---------------------------------------------------------------------------
+
+export class BookmarkModal {
+  public static readonly DEFAULT_VISIBLE_ROWS = 8;
+  public static readonly VISIBLE_ROWS = BookmarkModal.DEFAULT_VISIBLE_ROWS;
+  public active = false;
+  public entries: BookmarkEntry[] = [];
+  public selectedIndex = 0;
+  /** Scroll offset for the list (number of items scrolled past the top). */
+  public scrollOffset = 0;
+  /** Max visible list rows. */
+  public visibleRows = BookmarkModal.DEFAULT_VISIBLE_ROWS;
+
+  public constructor(private readonly bookmarkManager: BookmarkManager) {}
+
+  /**
+   * open - Load current bookmarks and show the modal.
+   */
+  open(): void {
+    this.entries = this.bookmarkManager.list();
+    this.selectedIndex = 0;
+    this.scrollOffset = 0;
+    this.active = true;
+  }
+
+  close(): void {
+    this.active = false;
+  }
+
+  setVisibleRows(rows: number): void {
+    this.visibleRows = Math.max(3, rows);
+    this._clampScroll();
+  }
+
+  moveUp(): void {
+    if (this.entries.length === 0) return;
+    this.selectedIndex = (this.selectedIndex - 1 + this.entries.length) % this.entries.length;
+    this._clampScroll();
+  }
+
+  moveDown(): void {
+    if (this.entries.length === 0) return;
+    this.selectedIndex = (this.selectedIndex + 1) % this.entries.length;
+    this._clampScroll();
+  }
+
+  getSelected(): BookmarkEntry | null {
+    return this.entries[this.selectedIndex] ?? null;
+  }
+
+  /**
+   * removeSelected - Remove the currently selected bookmark and refresh the list.
+   * Returns the removed entry, or null if nothing was selected.
+   */
+  removeSelected(): BookmarkEntry | null {
+    const entry = this.getSelected();
+    if (!entry) return null;
+    this.bookmarkManager.toggle(entry.key); // toggle off = remove
+    this.entries = this.bookmarkManager.list();
+    // Clamp selectedIndex after removal
+    if (this.entries.length === 0) {
+      this.selectedIndex = 0;
+    } else if (this.selectedIndex >= this.entries.length) {
+      this.selectedIndex = this.entries.length - 1;
+    }
+    this._clampScroll();
+    return entry;
+  }
+
+  /**
+   * openSelectedFile - Load the saved file content for the selected entry.
+   * Returns file content string, or null if no saved file exists for the key.
+   */
+  openSelectedFile(): string | null {
+    const entry = this.getSelected();
+    if (!entry) return null;
+    // Derive the filename from the key (saved as <timestamp>-<label>.txt)
+    // We list all saved files and look for one containing the entry key in the name
+    const files = this.bookmarkManager.listSavedFiles();
+    const match = files.find((f) => {
+      const base = f.split('/').pop() ?? '';
+      return base.includes(entry.key) ||
+        base.includes(entry.label.toLowerCase().replace(/[^a-z0-9_-]/g, '-').replace(/-+/g, '-').slice(0, 40));
+    });
+    if (!match) return null;
+    const name = match.split('/').pop()!;
+    return this.bookmarkManager.loadSavedFile(name);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+
+  private _clampScroll(): void {
+    const visRows = Math.max(3, this.visibleRows);
+    if (this.selectedIndex < this.scrollOffset) {
+      this.scrollOffset = this.selectedIndex;
+    } else if (this.selectedIndex >= this.scrollOffset + visRows) {
+      this.scrollOffset = this.selectedIndex - visRows + 1;
+    }
+    const maxOffset = Math.max(0, this.entries.length - visRows);
+    this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
+  }
+}

package/src/input/command-registry.ts

@@ -0,0 +1,300 @@
+import type { McpRegistry } from '../mcp/registry.ts';
+import type { ProviderRegistry } from '../providers/registry.ts';
+import type { ConversationManager } from '../core/conversation.ts';
+import type { ConfigManager } from '../config/index.ts';
+import type { DeepReadonly, GoodVibesConfig } from '../config/index.ts';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools/registry';
+import type { PermissionRequestHandler } from '../permissions/prompt.ts';
+import type { SelectionItem, SelectionResult, SelectionAction } from './selection-modal.ts';
+import type { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state/file-undo';
+import type { PanelManager } from '../panels/panel-manager.ts';
+import type { KeybindingsManager } from './keybindings.ts';
+import type { KnowledgeApi } from '../knowledge/knowledge-api.ts';
+import type { HookApi } from '../hooks/hook-api.ts';
+import type { McpApi } from '../mcp/mcp-api.ts';
+import type { ProviderApi } from '../providers/provider-api.ts';
+import type { OpsApi } from '../runtime/ops-api.ts';
+import type { OperatorClient } from '../runtime/operator-client.ts';
+import type { PeerClient } from '../runtime/peer-client.ts';
+import type { DirectTransport } from '../runtime/transports/direct.ts';
+import type {
+  CommandWorkspaceShellServices,
+} from '../runtime/shell-command-workspace.ts';
+import type {
+  CommandPlatformShellServices,
+} from '../runtime/shell-command-platform.ts';
+import type {
+  CommandExtensionShellServices,
+} from '../runtime/shell-command-extensions.ts';
+import type {
+  CommandOpsShellServices,
+  RemoteCommandService,
+  PlanRuntimeService,
+} from '../runtime/shell-command-ops.ts';
+
+export type {
+  RemoteCommandService,
+  PlanRuntimeService,
+} from '../runtime/shell-command-ops.ts';
+
+export interface CommandRuntimeState {
+  model: string;
+  provider: string;
+  debugMode: boolean;
+  systemPrompt: string;
+  reasoningEffort: string;
+  sessionId: string;
+}
+
+/**
+ * Top-level shell actions remain flat because commands and nearby shell routes
+ * use them constantly, and nesting them would add noise without clarifying
+ * ownership.
+ */
+export interface CommandUiActions {
+  renderRequest: () => void;
+  print: (text: string) => void;
+  exit: () => void;
+  submitInput?: (text: string, content?: import('../providers/interface.ts').ContentPart[]) => void;
+  executeCommand?: (name: string, args: string[]) => Promise<boolean>;
+  cancelGeneration?: () => void;
+  completeModelSelection?: (selection: {
+    model: { id: string; provider: string; displayName: string; registryKey: string };
+    effort: string;
+    contextCap?: number | null;
+  }) => void;
+  clearScreen?: () => void;
+  activatePlan?: (planId: string, task: string) => void;
+  requestPermission?: PermissionRequestHandler;
+}
+
+export interface CommandShellUiOpeners {
+  reloadSystemPrompt?: () => string;
+  openModelPicker?: () => void;
+  openProviderPicker?: () => void;
+  openContextInspector?: () => void;
+  openBookmarkModal?: () => void;
+  jumpToBookmark?: (key: string) => void;
+  scrollToLine?: (line: number) => void;
+  openHelpOverlay?: () => void;
+  openSelection?: (
+    title: string,
+    items: SelectionItem[],
+    opts: { preSelectId?: string; allowSearch?: boolean; customActions?: Map<string, SelectionAction> } | undefined,
+    callback: (result: SelectionResult | null) => void,
+  ) => void;
+  openSettingsModal?: () => void;
+  openSessionPicker?: () => void;
+  openProfilePicker?: () => void;
+  openShortcutsOverlay?: () => void;
+  getScrollTop?: () => number;
+  openPanelPicker?: () => void;
+  showPanel?: (panelId: string, pane?: 'top' | 'bottom') => void;
+  focusPanels?: () => void;
+  openOpsPanel?: () => void;
+  openCockpitPanel?: () => void;
+  openOrchestrationPanel?: () => void;
+  openForensicsPanel?: () => void;
+  openIncidentPanel?: () => void;
+  openPolicyPanel?: () => void;
+  openHooksPanel?: () => void;
+  openCommunicationPanel?: () => void;
+  openMcpPanel?: () => void;
+  openSecurityPanel?: () => void;
+  openKnowledgePanel?: () => void;
+  openRemotePanel?: () => void;
+  openSubscriptionPanel?: () => void;
+}
+
+export interface CommandSessionServices {
+  readonly conversationManager: ConversationManager;
+  readonly runtime: CommandRuntimeState;
+  readonly sessionManager?: import('../sessions/manager.ts').SessionManager;
+  readonly sessionMemoryStore?: import('@pellux/goodvibes-sdk/platform/core/session-memory').SessionMemoryStore;
+  readonly sessionLineageTracker?: import('@pellux/goodvibes-sdk/platform/core/session-lineage').SessionLineageTracker;
+  readonly changeTracker?: import('@pellux/goodvibes-sdk/platform/sessions/change-tracker').SessionChangeTracker;
+}
+
+export interface CommandProviderServices {
+  readonly providerRegistry: ProviderRegistry;
+  readonly providerOptimizer?: import('../providers/optimizer.ts').ProviderOptimizer;
+  readonly favoritesStore?: import('@pellux/goodvibes-sdk/platform/providers/favorites').FavoritesStore;
+  readonly benchmarkStore?: import('@pellux/goodvibes-sdk/platform/providers/model-benchmarks').BenchmarkStore;
+}
+
+/**
+ * Compose locally-owned command helpers with the narrower shell bridge-owned
+ * runtime surfaces exported from runtime/shell-command-services.ts.
+ */
+export interface CommandWorkspaceUiServices {
+  keybindingsManager?: KeybindingsManager;
+  fileUndoManager?: FileUndoManager;
+  panelManager?: PanelManager;
+  profileManager?: import('@pellux/goodvibes-sdk/platform/profiles/manager').ProfileManager;
+  bookmarkManager?: import('@pellux/goodvibes-sdk/platform/bookmarks/manager').BookmarkManager;
+}
+
+export interface CommandWorkspaceServices
+  extends CommandWorkspaceUiServices,
+    CommandWorkspaceShellServices {}
+
+export interface CommandPlatformConfigServices {
+  readonly config: DeepReadonly<GoodVibesConfig>;
+  readonly configManager: ConfigManager;
+}
+
+export interface CommandPlatformServices
+  extends CommandPlatformConfigServices,
+    CommandPlatformShellServices {}
+
+export interface CommandOpsServices
+  extends CommandOpsShellServices {}
+
+export interface CommandExtensionRegistryServices {
+  readonly toolRegistry: ToolRegistry;
+  readonly mcpRegistry: McpRegistry;
+  readonly evalRegistry?: import('../panels/eval-panel.ts').EvalRegistry;
+}
+
+export interface CommandExtensionServices
+  extends CommandExtensionRegistryServices,
+    CommandExtensionShellServices {}
+
+/**
+ * CommandContext - Passed to every slash command handler so commands can
+ * interact with the shell-facing platform surface without treating every
+ * service as one flat bag of unrelated properties.
+ */
+export interface CommandContext
+  extends CommandUiActions,
+    CommandShellUiOpeners {
+  readonly session: CommandSessionServices;
+  readonly provider: CommandProviderServices;
+  readonly workspace: CommandWorkspaceServices;
+  readonly platform: CommandPlatformServices;
+  readonly ops: CommandOpsServices;
+  readonly extensions: CommandExtensionServices;
+  readonly clients?: {
+    readonly operator?: OperatorClient;
+    readonly peer?: PeerClient;
+    readonly providerApi?: ProviderApi;
+    readonly knowledgeApi?: KnowledgeApi;
+    readonly hookApi?: HookApi;
+    readonly mcpApi?: McpApi;
+    readonly opsApi?: OpsApi;
+    readonly transport?: DirectTransport;
+  };
+}
+
+/**
+ * SlashCommand - A single slash command definition.
+ */
+export interface SlashCommand {
+  /** Primary name, e.g. "model". Full invocation is "/model". */
+  name: string;
+  /** Alternate names, e.g. ["m"]. */
+  aliases?: string[];
+  /** One-line description shown in /help output. */
+  description: string;
+  /** Optional usage hint, e.g. "<model-id>". */
+  usage?: string;
+  /** Short inline argument hint shown after cursor in dim grey, e.g. "[name]". Falls back to usage if not set. */
+  argsHint?: string;
+  /** The function executed when the command is invoked. */
+  handler: (args: string[], context: CommandContext) => void | Promise<void>;
+}
+
+/**
+ * CommandRegistry - Central registry for all slash commands.
+ * Supports fuzzy prefix matching for autocomplete.
+ */
+export class CommandRegistry {
+  private commands = new Map<string, SlashCommand>();
+  private aliasIndex = new Map<string, SlashCommand>();
+
+  /** Register a command. Also indexes all aliases for O(1) lookup. */
+  register(command: SlashCommand): void {
+    this.commands.set(command.name, command);
+    for (const alias of command.aliases ?? []) {
+      this.aliasIndex.set(alias, command);
+    }
+  }
+
+  /** Remove a command by primary name. Also removes its alias entries. */
+  unregister(name: string): void {
+    const cmd = this.commands.get(name);
+    if (cmd) {
+      for (const alias of cmd.aliases ?? []) {
+        this.aliasIndex.delete(alias);
+      }
+    }
+    this.commands.delete(name);
+  }
+
+  /**
+   * get - Look up a command by its primary name or any alias. O(1) for both.
+   */
+  get(name: string): SlashCommand | undefined {
+    return this.commands.get(name) ?? this.aliasIndex.get(name);
+  }
+
+  /** All registered commands. */
+  getAll(): SlashCommand[] {
+    return Array.from(this.commands.values());
+  }
+
+  /**
+   * fuzzyMatch - Return commands ranked by how well `query` matches their
+   * name or aliases. Returns all commands when query is empty.
+   */
+  fuzzyMatch(query: string): Array<{ command: SlashCommand; score: number }> {
+    const q = query.toLowerCase();
+    const results: Array<{ command: SlashCommand; score: number }> = [];
+
+    for (const cmd of this.commands.values()) {
+      const names = [cmd.name, ...(cmd.aliases ?? [])];
+      let bestScore = 0;
+
+      for (const candidate of names) {
+        const score = scoreMatch(q, candidate);
+        if (score > bestScore) bestScore = score;
+      }
+
+      if (bestScore > 0 || q === '') {
+        results.push({ command: cmd, score: q === '' ? 1 : bestScore });
+      }
+    }
+
+    // Sort: higher score first, then alphabetically
+    results.sort((a, b) => b.score - a.score || a.command.name.localeCompare(b.command.name));
+    return results;
+  }
+
+  /**
+   * execute - Look up and run a command. Returns true if found, false otherwise.
+   */
+  async execute(rawName: string, args: string[], context: CommandContext): Promise<boolean> {
+    const cmd = this.get(rawName);
+    if (!cmd) return false;
+    await cmd.handler(args, context);
+    return true;
+  }
+}
+
+/**
+ * scoreMatch - Simple prefix/subsequence scorer.
+ * Returns 0 if no match, higher is better.
+ */
+function scoreMatch(query: string, candidate: string): number {
+  if (query === '') return 1;
+  if (candidate === query) return 100;
+  if (candidate.startsWith(query)) return 80;
+
+  // Subsequence check
+  let qi = 0;
+  for (let ci = 0; ci < candidate.length && qi < query.length; ci++) {
+    if (candidate[ci] === query[qi]) qi++;
+  }
+  if (qi === query.length) return 40 - query.length; // shorter query → higher score
+  return 0;
+}

package/src/input/commands/branch-runtime.ts

@@ -0,0 +1,72 @@
+import type { CommandRegistry } from '../command-registry.ts';
+
+export function registerBranchRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'fork',
+    aliases: ['branch-save'],
+    description: 'Save a named snapshot of the current conversation',
+    usage: '[name]',
+    argsHint: '[name]',
+    handler(args, ctx) {
+      const name = args[0];
+      const branchName = ctx.session.conversationManager.forkBranch(name);
+      const msgCount = ctx.session.conversationManager.getMessageCount();
+      ctx.print(`Forked conversation as "${branchName}" (${msgCount} message${msgCount === 1 ? '' : 's'}).`);
+    },
+  });
+
+  registry.register({
+    name: 'branch',
+    aliases: ['br'],
+    description: 'List conversation branches or switch to one',
+    usage: '[name]',
+    argsHint: '[name]',
+    handler(args, ctx) {
+      if (args.length === 0) {
+        const branches = ctx.session.conversationManager.listBranches();
+        if (branches.length === 0) {
+          ctx.print('No branches. Use /fork [name] to create one.');
+          return;
+        }
+        const current = ctx.session.conversationManager.getCurrentBranch();
+        const lines = [`Branches (current: ${current}):`];
+        for (const branch of branches) {
+          const marker = branch.isCurrent ? '▶' : ' ';
+          lines.push(`  ${marker} ${branch.name}  (${branch.messageCount} message${branch.messageCount === 1 ? '' : 's'})`);
+        }
+        ctx.print(lines.join('\n'));
+        return;
+      }
+      const name = args[0];
+      const ok = ctx.session.conversationManager.switchBranch(name);
+      if (!ok) {
+        ctx.print(`Branch "${name}" not found. Use /fork [name] to create one, or /branch to list.`);
+        return;
+      }
+      ctx.print(`Switched to branch "${name}".`);
+      ctx.renderRequest();
+    },
+  });
+
+  registry.register({
+    name: 'merge',
+    aliases: [],
+    description: 'Append messages from a branch after the fork point',
+    usage: '<name>',
+    argsHint: '<name>',
+    handler(args, ctx) {
+      const name = args[0];
+      if (!name) {
+        ctx.print('Usage: /merge <branch-name>\nSee /branch for available branches.');
+        return;
+      }
+      const ok = ctx.session.conversationManager.mergeBranch(name);
+      if (!ok) {
+        ctx.print(`Branch "${name}" not found. Use /branch to list available branches.`);
+        return;
+      }
+      ctx.print(`Merged branch "${name}" into current conversation.`);
+      ctx.renderRequest();
+    },
+  });
+}