@pellux/goodvibes-agent 0.1.0

package/src/input/panel-integration-actions.ts

@@ -0,0 +1,78 @@
+import type { CommandContext } from './command-registry.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import type { Panel } from '../panels/types.ts';
+import type { PanelManager } from '../panels/panel-manager.ts';
+import { FileExplorerPanel } from '../panels/file-explorer-panel.ts';
+import { FilePreviewPanel } from '../panels/file-preview-panel.ts';
+import { SymbolOutlinePanel } from '../panels/symbol-outline-panel.ts';
+import { ApprovalPanel } from '../panels/approval-panel.ts';
+
+function ensurePreviewPanel(panelManager: PanelManager): FilePreviewPanel | null {
+  const existing = panelManager.getPanel('preview');
+  if (existing instanceof FilePreviewPanel) {
+    const pane = panelManager.getPaneOf('preview');
+    panelManager.activateById('preview');
+    if (pane) panelManager.focusPane(pane);
+    return existing;
+  }
+  const targetPane: 'top' | 'bottom' = panelManager.isBottomPaneVisible()
+    ? (panelManager.getFocusedPane() === 'top' ? 'bottom' : 'top')
+    : 'bottom';
+  const opened = panelManager.open('preview', targetPane);
+  panelManager.show();
+  panelManager.focusPane(targetPane);
+  return opened instanceof FilePreviewPanel ? opened : null;
+}
+
+function syncSymbolOutlineFromPreview(panelManager: PanelManager, previewPanel: FilePreviewPanel): void {
+  const symbols = panelManager.getPanel('symbols');
+  const filePath = previewPanel.getCurrentFilePath();
+  const source = previewPanel.getSource();
+  if (symbols instanceof SymbolOutlinePanel && filePath && source !== null) {
+    symbols.loadFile(filePath, source);
+  }
+}
+
+export function handlePanelIntegrationAction(
+  panelManager: PanelManager,
+  activePanel: Panel | null,
+  key: string,
+  commandContext?: CommandContext,
+): boolean {
+  if (!activePanel) return false;
+
+  if ((key === 'enter' || key === 'return' || key === 'right') && activePanel instanceof FileExplorerPanel) {
+    const filePath = activePanel.getFocusedFilePath();
+    if (!filePath) return false;
+    const previewPanel = ensurePreviewPanel(panelManager);
+    if (!previewPanel) return false;
+    previewPanel.openFile(filePath);
+    syncSymbolOutlineFromPreview(panelManager, previewPanel);
+    return true;
+  }
+
+  if ((key === 'enter' || key === 'return') && activePanel instanceof SymbolOutlinePanel) {
+    const location = activePanel.getSelectedLocation();
+    if (!location) return false;
+    const previewPanel = ensurePreviewPanel(panelManager);
+    if (!previewPanel) return false;
+    if (previewPanel.getCurrentFilePath() !== location.path) {
+      previewPanel.openFile(location.path);
+      syncSymbolOutlineFromPreview(panelManager, previewPanel);
+    }
+    previewPanel.goToLine(location.line);
+    return true;
+  }
+
+  if ((key === 'enter' || key === 'return') && activePanel instanceof ApprovalPanel) {
+    const command = activePanel.getSelectedCommand();
+    if (!command || !commandContext?.executeCommand) return false;
+    const parts = command.replace(/^\//, '').split(/\s+/).filter(Boolean);
+    const [name, ...args] = parts;
+    if (!name) return false;
+    void commandContext.executeCommand(name, args).catch((err) => { logger.debug('approval panel command dispatch failed', { err }); });
+    return true;
+  }
+
+  return false;
+}

package/src/input/profile-picker-modal.ts

@@ -0,0 +1,222 @@
+/**
+ * ProfilePickerModal — state management for the /profiles picker modal.
+ *
+ * Lists profiles from ProfileManager.list(), tracks selected index,
+ * and handles load/delete/save actions.
+ */
+
+import type { ProfileInfo, ProfileData, ProfileManager } from '@pellux/goodvibes-sdk/platform/profiles';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+/** Known display setting keys (subset of ConfigKey that maps to display.*). */
+const DISPLAY_KEYS: ConfigKey[] = [
+  'display.stream', 'display.lineNumbers', 'display.collapseThreshold',
+  'display.theme', 'display.showThinking', 'display.showReasoningSummary',
+  'display.showTokenSpeed', 'display.showToolPreview',
+] as const;
+
+/** Known behavior setting keys (subset of ConfigKey that maps to behavior.*). */
+const BEHAVIOR_KEYS: ConfigKey[] = [
+  'behavior.autoApprove', 'behavior.autoCompactThreshold',
+  'behavior.saveHistory', 'behavior.notifyOnComplete',
+] as const;
+
+/**
+ * Apply a profile data category to the config manager.
+ * Iterates only known/valid keys rather than open-ended Object.entries.
+ */
+function applyProfileCategory(
+  cm: ConfigManager,
+  data: Record<string, unknown>,
+  keys: ConfigKey[],
+): void {
+  for (const key of keys) {
+    const field = key.split('.')[1];
+    if (field && Object.prototype.hasOwnProperty.call(data, field)) {
+      try {
+        cm.setDynamic(key, data[field]);
+      } catch (e) { logger.debug('applyProfileCategory: key set failed', { key, error: summarizeError(e) }); }
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// ProfilePickerModal
+// ---------------------------------------------------------------------------
+
+export class ProfilePickerModal {
+  public active = false;
+  public profiles: ProfileInfo[] = [];
+  public selectedIndex = 0;
+  public scrollOffset = 0;
+  public visibleRows = 8;
+  public deleteConfirmationTarget: string | null = null;
+
+  /** Last status message (success/error feedback). */
+  public statusMessage = '';
+
+  public constructor(private readonly profileManager: ProfileManager) {}
+
+  /**
+   * Open the modal, loading profiles from ProfileManager.
+   */
+  open(): void {
+    this.profiles = this.profileManager.list();
+    this.selectedIndex = 0;
+    this.scrollOffset = 0;
+    this.statusMessage = '';
+    this.deleteConfirmationTarget = null;
+    this.active = true;
+  }
+
+  close(): void {
+    this.active = false;
+    this.statusMessage = '';
+    this.deleteConfirmationTarget = null;
+  }
+
+  moveUp(): void {
+    if (this.profiles.length === 0) return;
+    this.selectedIndex = (this.selectedIndex - 1 + this.profiles.length) % this.profiles.length;
+    this._clampScroll();
+    this.deleteConfirmationTarget = null;
+  }
+
+  moveDown(): void {
+    if (this.profiles.length === 0) return;
+    this.selectedIndex = (this.selectedIndex + 1) % this.profiles.length;
+    this._clampScroll();
+    this.deleteConfirmationTarget = null;
+  }
+
+  setVisibleRows(rows: number): void {
+    this.visibleRows = Math.max(3, rows);
+    this._clampScroll();
+  }
+
+  getSelected(): ProfileInfo | null {
+    return this.profiles[this.selectedIndex] ?? null;
+  }
+
+  /**
+   * Load the selected profile into configManager.
+   * Returns true on success, false on error.
+   */
+  loadSelected(configManager: ConfigManager): boolean {
+    const profile = this.getSelected();
+    if (!profile) return false;
+
+    try {
+      const { data } = this.profileManager.load(profile.name);
+
+      // Apply display settings using validated key list
+      if (data.display) {
+        applyProfileCategory(configManager, data.display as Record<string, unknown>, DISPLAY_KEYS);
+      }
+
+      // Apply provider settings (model + reasoningEffort only)
+      if (data.provider) {
+        if (data.provider.model !== undefined) {
+          try { configManager.set('provider.model', data.provider.model); } catch (e) { logger.debug('profile: model set failed', { error: summarizeError(e) }); }
+        }
+        if (data.provider.reasoningEffort !== undefined) {
+          try { configManager.set('provider.reasoningEffort', data.provider.reasoningEffort); } catch (e) { logger.debug('profile: reasoningEffort set failed', { error: summarizeError(e) }); }
+        }
+      }
+
+      // Apply behavior settings using validated key list
+      if (data.behavior) {
+        applyProfileCategory(configManager, data.behavior as Record<string, unknown>, BEHAVIOR_KEYS);
+      }
+
+      configManager.save();
+      this.statusMessage = `Loaded profile: ${profile.name}`;
+      return true;
+    } catch (e) {
+      this.statusMessage = `Error: ${summarizeError(e)}`;
+      return false;
+    }
+  }
+
+  /**
+   * Delete the selected profile from disk.
+   * Refreshes the list after deletion.
+   */
+  deleteSelected(): boolean {
+    const profile = this.getSelected();
+    if (!profile) return false;
+    if (this.deleteConfirmationTarget !== profile.name) {
+      this.deleteConfirmationTarget = profile.name;
+      this.statusMessage = `Press delete again to remove profile: ${profile.name}`;
+      return false;
+    }
+
+    try {
+      const deleted = this.profileManager.delete(profile.name);
+      if (!deleted) {
+        this.statusMessage = `Profile not found: ${profile.name}`;
+        this.deleteConfirmationTarget = null;
+        return false;
+      }
+      this.profiles = this.profileManager.list();
+      if (this.selectedIndex >= this.profiles.length) {
+        this.selectedIndex = Math.max(0, this.profiles.length - 1);
+      }
+      this._clampScroll();
+      this.deleteConfirmationTarget = null;
+      this.statusMessage = `Deleted: ${profile.name}`;
+      return true;
+    } catch (e) {
+      this.deleteConfirmationTarget = null;
+      this.statusMessage = `Error: ${summarizeError(e)}`;
+      return false;
+    }
+  }
+
+  /**
+   * Save the current config settings as a new profile under `name`.
+   */
+  saveCurrentAs(name: string, configManager: ConfigManager): boolean {
+    if (!name || !name.trim()) {
+      this.statusMessage = 'Profile name cannot be empty';
+      return false;
+    }
+
+    try {
+      const all = configManager.getAll();
+      const data: ProfileData = {
+        display: { ...all.display },
+        provider: {
+          model: all.provider.model,
+          reasoningEffort: all.provider.reasoningEffort,
+        },
+        behavior: { ...all.behavior },
+      };
+
+      this.profileManager.save(name, data);
+
+      // Reload list
+      this.profiles = this.profileManager.list();
+      this.statusMessage = `Saved profile: ${name}`;
+      this._clampScroll();
+      return true;
+    } catch (e) {
+      this.statusMessage = `Error: ${summarizeError(e)}`;
+      return false;
+    }
+  }
+
+  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.profiles.length - visRows);
+    this.scrollOffset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
+  }
+}

package/src/input/search.ts

@@ -0,0 +1,100 @@
+import type { InfiniteBuffer } from '../core/history.ts';
+
+export interface SearchMatch {
+  line: number;
+  col: number;
+  length: number;
+}
+
+/**
+ * SearchManager - Handles search-within-output state.
+ * Tracks active query, matches, and current match navigation.
+ */
+export class SearchManager {
+  public active = false;
+  /** When true, the query is locked and arrow/comma/period navigate matches. */
+  public locked = false;
+  public query = '';
+  public matches: SearchMatch[] = [];
+  public currentMatch = 0;
+
+  /** Open search mode. */
+  open(): void {
+    this.active = true;
+    this.locked = false;
+    this.query = '';
+    this.matches = [];
+    this.currentMatch = 0;
+  }
+
+  /** Lock the query — switches from typing mode to navigation mode. */
+  lock(): void {
+    this.locked = true;
+  }
+
+  /** Unlock — return to typing mode. */
+  unlock(): void {
+    this.locked = false;
+  }
+
+  /** Close search mode. */
+  close(): void {
+    this.active = false;
+    this.locked = false;
+  }
+
+  /** Update query and find matches in the history buffer. */
+  search(query: string, history: InfiniteBuffer): void {
+    this.query = query;
+    this.matches = [];
+    this.currentMatch = 0;
+
+    if (query.length === 0) return;
+
+    const lowerQuery = query.toLowerCase();
+    const lines = history.getAllLines();
+
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+      const line = lines[lineIdx];
+      // Build text from cells
+      const text = line.map(c => c.char).join('').toLowerCase();
+      let col = 0;
+      while (col <= text.length - lowerQuery.length) {
+        const idx = text.indexOf(lowerQuery, col);
+        if (idx === -1) break;
+        this.matches.push({ line: lineIdx, col: idx, length: query.length });
+        col = idx + 1;
+      }
+    }
+  }
+
+  /** Jump to next match. */
+  nextMatch(): void {
+    if (this.matches.length === 0) return;
+    this.currentMatch = (this.currentMatch + 1) % this.matches.length;
+  }
+
+  /** Jump to previous match. */
+  prevMatch(): void {
+    if (this.matches.length === 0) return;
+    this.currentMatch = (this.currentMatch - 1 + this.matches.length) % this.matches.length;
+  }
+
+  /** Get the line number of the current match (for scroll). */
+  getCurrentMatchLine(): number {
+    if (this.matches.length === 0) return -1;
+    return this.matches[this.currentMatch]?.line ?? -1;
+  }
+
+  /** Get matches on a given line. */
+  getMatchesOnLine(lineIdx: number): SearchMatch[] {
+    return this.matches.filter(m => m.line === lineIdx);
+  }
+
+  /** Is the current match on the given line at the given col? */
+  isCurrentMatch(lineIdx: number, col: number): boolean {
+    if (this.matches.length === 0) return false;
+    const m = this.matches[this.currentMatch];
+    return m !== undefined && m.line === lineIdx && m.col === col;
+  }
+}

package/src/input/selection-modal.ts

@@ -0,0 +1,163 @@
+/**
+ * SelectionModal - Generic reusable selection modal with fuzzy search.
+ * Used by /template, /sessions, /bookmarks, /tools, and focused pickers.
+ */
+
+export interface SelectionItem {
+  id: string;
+  label: string;
+  detail?: string;        // shown to the right of label
+  category?: string;      // optional grouping header
+  actions?: string;       // hint text for available actions (e.g., "[d] delete")
+  fg?: string;             // optional foreground color override for this item
+  primaryAction?: SelectionAction; // default Enter/Space behavior for this row
+  adjustable?: boolean;   // supports left/right adjustment without leaving the modal
+  adjustStep?: number;    // base step for left/right adjustments
+  adjustMin?: number;     // minimum numeric value when adjustable
+  adjustMax?: number;     // maximum numeric value when adjustable
+  adjustPrecision?: number; // decimal places to preserve for numeric adjustments
+}
+
+export type SelectionAction = 'select' | 'delete' | 'edit' | 'toggle' | 'increment' | 'decrement';
+
+export interface SelectionResult {
+  item: SelectionItem;
+  action: SelectionAction;
+  step?: number;
+}
+
+export class SelectionModal {
+  public active = false;
+  public title = '';
+  public query = '';           // fuzzy search query
+  public searchFocused = false;
+  public items: SelectionItem[] = [];
+  public filteredItems: SelectionItem[] = [];
+  public selectedIndex = 0;
+  public allowSearch = true;
+  public customActions: Map<string, SelectionAction> = new Map();
+
+  /** Open the modal with items and title */
+  open(
+    title: string,
+    items: SelectionItem[],
+    opts?: {
+      preSelectId?: string;
+      allowSearch?: boolean;
+      customActions?: Map<string, SelectionAction>;
+    }
+  ): void {
+    this.title = title;
+    this.items = items;
+    this.query = '';
+    this.allowSearch = opts?.allowSearch ?? true;
+    this.searchFocused = false;
+    this.customActions = opts?.customActions ?? new Map();
+    this.active = true;
+    this.filterItems();
+
+    // Pre-select by id if provided
+    if (opts?.preSelectId) {
+      const idx = this.filteredItems.findIndex(it => it.id === opts.preSelectId);
+      this.selectedIndex = idx >= 0 ? idx : 0;
+    } else {
+      this.selectedIndex = 0;
+    }
+  }
+
+  close(): void {
+    this.active = false;
+    this.title = '';
+    this.query = '';
+    this.searchFocused = false;
+    this.items = [];
+    this.filteredItems = [];
+    this.selectedIndex = 0;
+    this.customActions = new Map();
+  }
+
+  moveUp(): void {
+    // Skip category headers (items with no id-based content — filtered items include only selectable ones)
+    if (this.filteredItems.length === 0) return;
+    this.selectedIndex = this.selectedIndex > 0
+      ? this.selectedIndex - 1
+      : this.filteredItems.length - 1;
+  }
+
+  moveDown(): void {
+    if (this.filteredItems.length === 0) return;
+    this.selectedIndex = this.selectedIndex < this.filteredItems.length - 1
+      ? this.selectedIndex + 1
+      : 0;
+  }
+
+  /** Update fuzzy search filter */
+  setQuery(query: string): void {
+    this.query = query;
+    this.selectedIndex = 0;
+    this.filterItems();
+  }
+
+  canFocusSearch(): boolean {
+    return this.allowSearch;
+  }
+
+  focusSearch(): void {
+    if (this.allowSearch) this.searchFocused = true;
+  }
+
+  blurSearch(): void {
+    this.searchFocused = false;
+  }
+
+  /** Get currently highlighted item */
+  getSelected(): SelectionItem | null {
+    if (this.filteredItems.length === 0) return null;
+    return this.filteredItems[this.selectedIndex] ?? null;
+  }
+
+  /** Fuzzy match items against query — resets filteredItems */
+  private filterItems(): void {
+    if (this.query.length === 0) {
+      this.filteredItems = this.items.slice();
+      return;
+    }
+
+    const scored = this.items
+      .map(item => ({ item, ...this.fuzzyMatch(this.query, item.label + ' ' + (item.detail ?? '') + ' ' + (item.category ?? '')) }))
+      .filter(r => r.match)
+      .sort((a, b) => b.score - a.score);
+
+    this.filteredItems = scored.map(r => r.item);
+    if (this.selectedIndex >= this.filteredItems.length) {
+      this.selectedIndex = Math.max(0, this.filteredItems.length - 1);
+    }
+  }
+
+  /** 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) {
+      return { match: true, score: 100 - 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 };
+  }
+}

package/src/input/selection.ts

@@ -0,0 +1,135 @@
+import type { InfiniteBuffer } from '../core/history.ts';
+import type { Cell } from '../types/grid.ts';
+
+export interface SelectionPoint {
+  col: number;
+  row: number;
+}
+
+/**
+ * SelectionManager - Owns text selection state.
+ * Extracted from StateManager. Requires access to the history buffer
+ * and scroll state (scrollTop, viewportHeight) at call time.
+ */
+export class SelectionManager {
+  public anchor: SelectionPoint | null = null;
+  public focus: SelectionPoint | null = null;
+  public isDragging = false;
+
+  private screenToAbsoluteRow(viewportRow: number, scrollTop: number, vHeight: number, lineCount: number): number {
+    const offset = Math.max(0, vHeight - lineCount);
+    return scrollTop + (viewportRow - offset);
+  }
+
+  public startSelection(col: number, viewportRow: number, scrollTop: number, vHeight: number, lineCount: number): void {
+    const absoluteRow = this.screenToAbsoluteRow(viewportRow, scrollTop, vHeight, lineCount);
+    this.anchor = { col, row: absoluteRow };
+    this.focus = { col, row: absoluteRow };
+    this.isDragging = true;
+  }
+
+  public extendSelection(col: number, viewportRow: number, scrollTop: number, vHeight: number, lineCount: number): void {
+    if (!this.isDragging) return;
+    const absoluteRow = this.screenToAbsoluteRow(viewportRow, scrollTop, vHeight, lineCount);
+    this.focus = { col, row: absoluteRow };
+  }
+
+  public endSelection(): void {
+    this.isDragging = false;
+  }
+
+  public clearSelection(): void {
+    this.anchor = null;
+    this.focus = null;
+    this.isDragging = false;
+  }
+
+  public hasSelection(): boolean {
+    if (!this.anchor || !this.focus) return false;
+    return this.anchor.row !== this.focus.row || this.anchor.col !== this.focus.col;
+  }
+
+  public getSelectedText(history: InfiniteBuffer): string {
+    if (!this.anchor || !this.focus) return '';
+
+    const start =
+      this.anchor.row < this.focus.row ||
+      (this.anchor.row === this.focus.row && this.anchor.col <= this.focus.col)
+        ? this.anchor
+        : this.focus;
+    const end = start === this.anchor ? this.focus : this.anchor;
+
+    const lines: string[] = [];
+    const allLines = history.getAllLines();
+
+    for (let r = Math.max(0, start.row); r <= Math.min(allLines.length - 1, end.row); r++) {
+      const line = allLines[r];
+      if (!line) continue;
+
+      const startCol = r === start.row ? start.col : 0;
+      const endCol = r === end.row ? end.col : line.length;
+      const gutterEnd = this.findLineNumberGutterEnd(line);
+      const effectiveStartCol = startCol < gutterEnd ? gutterEnd : startCol;
+
+      let lineText = '';
+      for (let c = Math.max(0, effectiveStartCol); c < Math.min(line.length, endCol); c++) {
+        const cell = line[c];
+        if (cell && cell.char !== '') lineText += cell.char;
+      }
+
+      lines.push(this.stripDecorativePrefix(lineText));
+    }
+
+    return lines.join('\n');
+  }
+
+  private findLineNumberGutterEnd(line: Cell[]): number {
+    let i = 0;
+    while (i < line.length) {
+      const cell = line[i];
+      if (cell?.char === ' ' && !cell?.dim && (cell?.bg ?? '') === '') {
+        i++;
+        continue;
+      }
+      break;
+    }
+    const start = i;
+    let sawDigit = false;
+    while (i < line.length) {
+      const cell = line[i];
+      const ch = cell?.char ?? '';
+      if (cell?.dim && ch !== '' && /[0-9 │]/.test(ch)) {
+        if (/[0-9]/.test(ch)) sawDigit = true;
+        i++;
+        continue;
+      }
+      break;
+    }
+    if (!sawDigit) return start;
+    if (i < line.length && line[i]?.char === ' ') i++;
+    return i > start ? i : start;
+  }
+
+  private stripDecorativePrefix(text: string): string {
+    return text
+      .replace(/^(\s*)(?:[▸▾▶►●○◆▲△▼▽•✕✓▌]\s+)+/u, '$1')
+      .replace(/^(\s*)\[(?:x|~| )\]\s+/u, '$1')
+      .trimEnd();
+  }
+
+  public isCellSelected(col: number, absoluteRow: number): boolean {
+    if (!this.anchor || !this.focus) return false;
+    const start =
+      this.anchor.row < this.focus.row ||
+      (this.anchor.row === this.focus.row && this.anchor.col <= this.focus.col)
+        ? this.anchor
+        : this.focus;
+    const end = start === this.anchor ? this.focus : this.anchor;
+    if (absoluteRow < start.row || absoluteRow > end.row) return false;
+    if (absoluteRow === start.row && absoluteRow === end.row)
+      return col >= start.col && col < end.col;
+    if (absoluteRow === start.row) return col >= start.col;
+    if (absoluteRow === end.row) return col < end.col;
+    return true;
+  }
+}