@pellux/goodvibes-tui 0.20.2 → 0.21.0

package/src/input/input-history.ts

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join } from 'path';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { atomicWriteFileSync } from '@/config/atomic-write.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
@@ -100,11 +101,39 @@ export class HistorySearch {
   }
 }
 
+/**
+ * A redaction rule applied to command text before it is stored or saved.
+ * Any match of `pattern` in the raw text is replaced with `replacement`.
+ */
+export interface HistoryRedactionRule {
+  readonly pattern: RegExp;
+  readonly replacement: string;
+}
+
+/**
+ * Built-in redaction rules that apply regardless of caller-supplied rules.
+ * Scrubs passwords from local-auth commands before they reach disk.
+ */
+const BUILTIN_REDACTION_RULES: readonly HistoryRedactionRule[] = [
+  {
+    // /auth local add-user <user> <password> [roles]
+    pattern: /(\/auth\s+local\s+add-user\s+\S+)\s+(\S+)/i,
+    replacement: '$1 <redacted>',
+  },
+  {
+    // /auth local rotate-password <user> <password>
+    pattern: /(\/auth\s+local\s+rotate-password\s+\S+)\s+(\S+)/i,
+    replacement: '$1 <redacted>',
+  },
+];
+
 export interface InputHistoryOptions {
   readonly historyPath?: string;
   readonly userRoot?: string;
   readonly homeDirectory?: string;
   readonly persist?: boolean;
+  /** Additional redaction rules applied on top of the built-in set. */
+  readonly redactionRules?: readonly HistoryRedactionRule[];
 }
 
 type StoredInputHistoryEntry = string | {
@@ -130,25 +159,44 @@ export class InputHistory {
   private maxEntries = 500;
   private historyPath: string;
   private persist: boolean;
+  private redactionRules: readonly HistoryRedactionRule[];
 
   constructor(options: InputHistoryOptions) {
     this.persist = options.persist ?? true;
     this.historyPath = resolveHistoryPath(options);
+    this.redactionRules = [
+      ...BUILTIN_REDACTION_RULES,
+      ...(options.redactionRules ?? []),
+    ];
     if (this.persist) {
       this.load();
     }
   }
 
+  /**
+   * Apply all active redaction rules to a text string.
+   * Returns the scrubbed text (password arguments replaced with `<redacted>`).
+   */
+  private applyRedaction(text: string): string {
+    let result = text;
+    for (const rule of this.redactionRules) {
+      result = result.replace(rule.pattern, rule.replacement);
+    }
+    return result;
+  }
+
   /**
    * Add a new entry. Called on submit.
    * - Ignores empty/whitespace-only strings.
    * - Deduplicates consecutive identical entries.
+   * - Applies redaction rules to scrub sensitive arguments before persistence.
    * - Resets browsing position.
    */
   add(text: string, options: { readonly recallText?: string } = {}): void {
-    const trimmed = text.trim();
+    const trimmed = this.applyRedaction(text.trim());
     if (!trimmed) return;
-    const recallText = options.recallText?.trim();
+    const rawRecallText = options.recallText?.trim();
+    const recallText = rawRecallText ? this.applyRedaction(rawRecallText) : undefined;
     const entry: StoredInputHistoryEntry = recallText && recallText !== trimmed
       ? { text: trimmed, recallText }
       : trimmed;
@@ -240,8 +288,7 @@ export class InputHistory {
    */
   save(): void {
     try {
-      mkdirSync(dirname(this.historyPath), { recursive: true });
-      writeFileSync(this.historyPath, JSON.stringify(this.entries), 'utf-8');
+      atomicWriteFileSync(this.historyPath, JSON.stringify(this.entries), { mkdirp: true });
     } catch (err) {
       logger.debug('InputHistory save failed (non-fatal)', { error: summarizeError(err) });
     }
@@ -249,6 +296,10 @@ export class InputHistory {
 
   /**
    * Load history from disk.
+   *
+   * Redaction is applied to every loaded entry so that cleartext passwords
+   * persisted before the redaction rules were deployed are scrubbed on first
+   * load and will not be re-persisted on the next save().
    */
   load(): void {
     try {
@@ -259,6 +310,7 @@ export class InputHistory {
           this.entries = (parsed as unknown[])
             .map((entry) => this.normalizeStoredEntry(entry))
             .filter((entry): entry is StoredInputHistoryEntry => entry !== null)
+            .map((entry) => this.redactEntry(entry))
             .slice(0, this.maxEntries);
         }
       }
@@ -281,6 +333,24 @@ export class InputHistory {
       && this.getRecallText(a) === this.getRecallText(b);
   }
 
+  /**
+   * Apply redaction rules to a loaded entry, scrubbing any sensitive text that
+   * was persisted before redaction was deployed.
+   */
+  private redactEntry(entry: StoredInputHistoryEntry): StoredInputHistoryEntry {
+    if (typeof entry === 'string') {
+      return this.applyRedaction(entry);
+    }
+    const redactedText = this.applyRedaction(entry.text);
+    const redactedRecallText = entry.recallText !== undefined
+      ? this.applyRedaction(entry.recallText)
+      : undefined;
+    if (redactedRecallText !== undefined && redactedRecallText !== redactedText) {
+      return { text: redactedText, recallText: redactedRecallText };
+    }
+    return redactedText;
+  }
+
   private normalizeStoredEntry(entry: unknown): StoredInputHistoryEntry | null {
     if (typeof entry === 'string') return entry;
     if (!entry || typeof entry !== 'object') return null;

package/src/input/model-picker-filter.ts

@@ -0,0 +1,265 @@
+/**
+ * model-picker-filter — pure filtering, sorting, and cache-key helpers for ModelPickerModal.
+ *
+ * All functions are stateless: they receive inputs and return results without
+ * side-effects. The class in model-picker.ts uses these as delegates.
+ */
+
+import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers';
+import { compositeScore, A_TIER_THRESHOLD } from '@pellux/goodvibes-sdk/platform/providers';
+import type { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers';
+import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
+import { tierToCategoryFilter } from './model-picker-types.ts';
+import type {
+  BenchmarkSort,
+  CapabilityFilter,
+  CategoryFilter,
+  FilteredModelsCache,
+  FilteredProvidersCache,
+  GroupByMode,
+} from './model-picker-types.ts';
+import { filterProviders } from './model-picker-provider-filter.ts';
+
+export { filterProviders };
+
+// ---------------------------------------------------------------------------
+// Cache key helpers
+// ---------------------------------------------------------------------------
+
+export function setKey(values: ReadonlySet<string>): string {
+  if (values.size === 0) return '';
+  return [...values].sort().join('');
+}
+
+export function orderedListKey(values: readonly string[]): string {
+  return values.length === 0 ? '' : values.join('');
+}
+
+export function mapKey(values: ReadonlyMap<string, string | undefined>): string {
+  if (values.size === 0) return '';
+  return [...values.entries()]
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => `${key}${value ?? ''}`)
+    .join('');
+}
+
+// ---------------------------------------------------------------------------
+// Synthetic sub-group classification
+// ---------------------------------------------------------------------------
+
+export function getSyntheticSubgroup(
+  model: ModelDefinition,
+  providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog'>,
+): 'top' | 'all' {
+  const info = providerRegistry.getSyntheticModelInfoFromCatalog(model.id);
+  const score = info?.bestCompositeScore ?? null;
+  return score !== null && score >= A_TIER_THRESHOLD ? 'top' : 'all';
+}
+
+// ---------------------------------------------------------------------------
+// buildFilteredModels
+// ---------------------------------------------------------------------------
+
+export interface FilterModelParams {
+  readonly models: ModelDefinition[];
+  readonly configuredProviders: ReadonlySet<string>;
+  readonly pinnedIds: ReadonlySet<string>;
+  readonly recentIds: readonly string[];
+  readonly query: string;
+  readonly categoryFilter: CategoryFilter;
+  readonly capabilityFilter: CapabilityFilter;
+  readonly availableOnly: boolean;
+  readonly benchmarkSort: BenchmarkSort;
+  readonly groupBy: GroupByMode;
+  readonly benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks'>;
+  readonly providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog'>;
+}
+
+export function buildFilteredModels(
+  params: FilterModelParams,
+  cache: FilteredModelsCache | null,
+): { result: ModelDefinition[]; cache: FilteredModelsCache } {
+  const {
+    models,
+    configuredProviders,
+    pinnedIds,
+    recentIds,
+    query,
+    categoryFilter,
+    capabilityFilter,
+    availableOnly,
+    benchmarkSort,
+    groupBy,
+    benchmarkStore,
+    providerRegistry,
+  } = params;
+
+  const configuredProvidersKey = setKey(configuredProviders);
+  const pinnedIdsKey = setKey(pinnedIds);
+  const recentIdsKey = orderedListKey(recentIds);
+
+  if (
+    cache !== null
+    && cache.modelsRef === models
+    && cache.configuredProvidersKey === configuredProvidersKey
+    && cache.pinnedIdsKey === pinnedIdsKey
+    && cache.recentIdsKey === recentIdsKey
+    && cache.query === query
+    && cache.categoryFilter === categoryFilter
+    && cache.capabilityFilter === capabilityFilter
+    && cache.availableOnly === availableOnly
+    && cache.benchmarkSort === benchmarkSort
+    && cache.groupBy === groupBy
+  ) {
+    return { result: cache.result, cache };
+  }
+
+  let result = models;
+
+  // Available-only filter
+  if (availableOnly && configuredProviders.size > 0) {
+    result = result.filter(m => configuredProviders.has(m.provider));
+  }
+
+  // Pricing tier / category filter
+  if (categoryFilter === 'free') {
+    result = result.filter(m => m.tier === 'free');
+  } else if (categoryFilter === 'paid') {
+    result = result.filter(m => m.tier === 'standard' || m.tier === 'premium' || m.tier == null);
+  } else if (categoryFilter === 'subscription') {
+    result = result.filter(m => tierToCategoryFilter(m.tier) === 'subscription');
+  }
+
+  // Capability filter
+  if (capabilityFilter === 'reasoning') {
+    result = result.filter(m => m.capabilities?.reasoning === true);
+  } else if (capabilityFilter === 'toolUse') {
+    result = result.filter(m => m.capabilities?.toolCalling === true);
+  } else if (capabilityFilter === 'multimodal') {
+    result = result.filter(m => m.capabilities?.multimodal === true);
+  }
+
+  // Query filter — fuzzy: every space-separated word must appear somewhere
+  if (query.trim().length > 0) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    result = result.filter(m => {
+      const haystack = `${m.id} ${m.displayName} ${m.provider}`.toLowerCase();
+      return words.every(w => haystack.includes(w));
+    });
+  }
+
+  // Benchmark sort
+  if (benchmarkSort !== 'none') {
+    result = [...result].sort((a, b) => {
+      let scoreA: number | null = null;
+      let scoreB: number | null = null;
+
+      if (benchmarkSort === 'composite') {
+        if (a.provider === 'synthetic') {
+          scoreA = providerRegistry.getSyntheticModelInfoFromCatalog(a.id)?.bestCompositeScore ?? null;
+        } else {
+          const bA = benchmarkStore.getBenchmarks(a.id) ?? benchmarkStore.getBenchmarks(a.displayName);
+          scoreA = bA ? compositeScore(bA.benchmarks) : null;
+        }
+        if (b.provider === 'synthetic') {
+          scoreB = providerRegistry.getSyntheticModelInfoFromCatalog(b.id)?.bestCompositeScore ?? null;
+        } else {
+          const bB = benchmarkStore.getBenchmarks(b.id) ?? benchmarkStore.getBenchmarks(b.displayName);
+          scoreB = bB ? compositeScore(bB.benchmarks) : null;
+        }
+      } else {
+        // swe/gpqa sort — individual scores not available for synthetic models
+        const bA = a.provider === 'synthetic' ? null : (benchmarkStore.getBenchmarks(a.id) ?? benchmarkStore.getBenchmarks(a.displayName));
+        const bB = b.provider === 'synthetic' ? null : (benchmarkStore.getBenchmarks(b.id) ?? benchmarkStore.getBenchmarks(b.displayName));
+        if (benchmarkSort === 'swe') {
+          scoreA = bA?.benchmarks.swe ?? null;
+          scoreB = bB?.benchmarks.swe ?? null;
+        } else if (benchmarkSort === 'gpqa') {
+          scoreA = bA?.benchmarks.gpqa ?? null;
+          scoreB = bB?.benchmarks.gpqa ?? null;
+        }
+      }
+      // Models with no score sink to the end
+      if (scoreA == null && scoreB == null) return 0;
+      if (scoreA == null) return 1;
+      if (scoreB == null) return -1;
+      return scoreB - scoreA; // descending
+    });
+  }
+
+  // Synthetic sub-grouping: when groupBy is 'provider', order synthetic models so that
+  // "Top Models" (score >= 0.65) appear before "All Synthetic"
+  if (groupBy === 'provider' && benchmarkSort === 'none') {
+    const nonSynthetic = result.filter(m => m.provider !== 'synthetic');
+    const synthetic = result.filter(m => m.provider === 'synthetic');
+
+    if (synthetic.length > 0) {
+      const topModels = synthetic.filter(m => getSyntheticSubgroup(m, providerRegistry) === 'top');
+      const allModels = synthetic.filter(m => getSyntheticSubgroup(m, providerRegistry) === 'all');
+
+      // Sort top models by composite score descending
+      topModels.sort((a, b) => {
+        const sA = providerRegistry.getSyntheticModelInfoFromCatalog(a.id)?.bestCompositeScore ?? null;
+        const sB = providerRegistry.getSyntheticModelInfoFromCatalog(b.id)?.bestCompositeScore ?? null;
+        if (sA == null && sB == null) return 0;
+        if (sA == null) return 1;
+        if (sB == null) return -1;
+        return sB - sA;
+      });
+
+      // Sort remaining alphabetically by id
+      allModels.sort((a, b) => a.id.localeCompare(b.id));
+
+      result = [...nonSynthetic, ...topModels, ...allModels];
+    }
+  }
+
+  // Boost recent (non-pinned) models to the front
+  if (recentIds.length > 0) {
+    const recentSet = new Set(recentIds);
+    const recent = recentIds
+      .filter(id => result.some(m => m.id === id && !pinnedIds.has(id)))
+      .map(id => result.find(m => m.id === id)!)
+      .filter(Boolean);
+    const rest = result.filter(m => !recentSet.has(m.id) || pinnedIds.has(m.id));
+    result = [...recent, ...rest];
+  }
+
+  const newCache: FilteredModelsCache = {
+    modelsRef: models,
+    configuredProvidersKey,
+    pinnedIdsKey,
+    recentIdsKey,
+    query,
+    categoryFilter,
+    capabilityFilter,
+    availableOnly,
+    benchmarkSort,
+    groupBy,
+    result,
+  };
+
+  return { result, cache: newCache };
+}
+
+// ---------------------------------------------------------------------------
+// buildFilteredProviders (cache-aware)
+// ---------------------------------------------------------------------------
+
+export function buildFilteredProviders(
+  providers: string[],
+  query: string,
+  cache: FilteredProvidersCache | null,
+): { result: string[]; cache: FilteredProvidersCache } {
+  if (
+    cache !== null
+    && cache.providersRef === providers
+    && cache.query === query
+  ) {
+    return { result: cache.result, cache };
+  }
+
+  const result = filterProviders(providers, query);
+  const newCache: FilteredProvidersCache = { providersRef: providers, query, result };
+  return { result, cache: newCache };
+}

package/src/input/model-picker-items.ts

@@ -0,0 +1,208 @@
+/**
+ * model-picker-items — pure item-building helpers for ModelPickerModal.
+ *
+ * Converts filtered ModelDefinition/provider arrays into PickerItem lists
+ * with group headers, quality-tier badges, pin markers, and configured-via flags.
+ * All functions are stateless.
+ */
+
+import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers';
+import { EFFORT_DESCRIPTIONS, getQualityTier, getQualityTierFromScore } from '@pellux/goodvibes-sdk/platform/providers';
+import type { BenchmarkStore } from '@pellux/goodvibes-sdk/platform/providers';
+import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
+import {
+  POPULAR_PROVIDERS,
+  detectFamily,
+  tierToCategoryFilter,
+} from './model-picker-types.ts';
+import type {
+  GroupByMode,
+  ModelItemsCache,
+  PickerItem,
+  ProviderItemsCache,
+} from './model-picker-types.ts';
+import { getSyntheticSubgroup, setKey, mapKey } from './model-picker-filter.ts';
+
+// ---------------------------------------------------------------------------
+// getModelGroupKey
+// ---------------------------------------------------------------------------
+
+export function getModelGroupKey(
+  model: ModelDefinition,
+  groupBy: GroupByMode,
+  providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog'>,
+  benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks'>,
+): string {
+  switch (groupBy) {
+    case 'provider':
+      if (model.provider === 'synthetic') {
+        return getSyntheticSubgroup(model, providerRegistry) === 'top' ? 'Top Models' : 'All Synthetic';
+      }
+      return model.provider;
+    case 'family':
+      return detectFamily(model);
+    case 'pricingTier':
+      return tierToCategoryFilter(model.tier);
+    case 'qualityTier': {
+      if (model.provider === 'synthetic') {
+        const info = providerRegistry.getSyntheticModelInfoFromCatalog(model.id);
+        return info?.bestCompositeScore != null ? getQualityTierFromScore(info.bestCompositeScore) : 'C';
+      }
+      const b = benchmarkStore.getBenchmarks(model.id) ?? benchmarkStore.getBenchmarks(model.displayName);
+      return b ? getQualityTier(b.benchmarks) : 'C';
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// toModelItem — single model -> PickerItem
+// ---------------------------------------------------------------------------
+
+export function toModelItem(
+  model: ModelDefinition,
+  isPinned: boolean,
+  providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog'>,
+  benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks'>,
+): PickerItem {
+  let qualityTier: string | undefined;
+  let detail: string;
+
+  if (model.provider === 'synthetic') {
+    const synthInfo = providerRegistry.getSyntheticModelInfoFromCatalog(model.id);
+    if (synthInfo?.bestCompositeScore != null) {
+      qualityTier = getQualityTierFromScore(synthInfo.bestCompositeScore);
+    }
+    detail = synthInfo !== null
+      ? `${model.provider} [${synthInfo.keyedBackendCount} provider${synthInfo.keyedBackendCount !== 1 ? 's' : ''}]`
+      : model.provider;
+  } else {
+    detail = model.provider;
+    const b = benchmarkStore.getBenchmarks(model.id) ?? benchmarkStore.getBenchmarks(model.displayName);
+    qualityTier = b ? getQualityTier(b.benchmarks) : undefined;
+  }
+
+  const isFree = tierToCategoryFilter(model.tier) === 'free';
+
+  return {
+    id: model.id,
+    label: model.displayName,
+    detail,
+    qualityTier,
+    isPinned,
+    isFree,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// buildModelItems — filtered models -> PickerItem[] with group headers
+// ---------------------------------------------------------------------------
+
+export function buildModelItems(
+  filtered: ModelDefinition[],
+  pinnedIds: ReadonlySet<string>,
+  groupBy: GroupByMode,
+  providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog'>,
+  benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks'>,
+  cache: ModelItemsCache | null,
+): { result: PickerItem[]; cache: ModelItemsCache } {
+  const pinnedIdsKey = setKey(pinnedIds);
+
+  if (
+    cache !== null
+    && cache.filteredModelsRef === filtered
+    && cache.pinnedIdsKey === pinnedIdsKey
+    && cache.groupBy === groupBy
+  ) {
+    return { result: cache.result, cache };
+  }
+
+  const pinned = filtered.filter(m => pinnedIds.has(m.id));
+  const unpinned = filtered.filter(m => !pinnedIds.has(m.id));
+
+  const items: PickerItem[] = [];
+
+  // Pinned section header (only if pinned models are in the filtered list)
+  if (pinned.length > 0) {
+    items.push({ id: '__header__pinned', label: 'Favorites', isGroupHeader: true });
+    for (const m of pinned) {
+      items.push(toModelItem(m, true, providerRegistry, benchmarkStore));
+    }
+  }
+
+  // Grouped unpinned models
+  let lastGroupKey = '';
+  for (const m of unpinned) {
+    const groupKey = getModelGroupKey(m, groupBy, providerRegistry, benchmarkStore);
+    if (groupKey !== lastGroupKey) {
+      items.push({ id: `__header__${groupKey}`, label: groupKey, isGroupHeader: true });
+      lastGroupKey = groupKey;
+    }
+    items.push(toModelItem(m, false, providerRegistry, benchmarkStore));
+  }
+
+  const newCache: ModelItemsCache = {
+    filteredModelsRef: filtered,
+    pinnedIdsKey,
+    groupBy,
+    result: items,
+  };
+
+  return { result: items, cache: newCache };
+}
+
+// ---------------------------------------------------------------------------
+// buildProviderItems — filtered providers -> PickerItem[] with group headers
+// ---------------------------------------------------------------------------
+
+export function buildProviderItems(
+  filteredProviders: string[],
+  configuredProviders: ReadonlySet<string>,
+  configuredViaMap: ReadonlyMap<string, 'env' | 'secrets' | 'subscription' | 'anonymous'>,
+  cache: ProviderItemsCache | null,
+): { result: PickerItem[]; cache: ProviderItemsCache } {
+  const configuredProvidersKey = setKey(configuredProviders);
+  const configuredViaKey = mapKey(configuredViaMap);
+
+  if (
+    cache !== null
+    && cache.filteredProvidersRef === filteredProviders
+    && cache.configuredProvidersKey === configuredProvidersKey
+    && cache.configuredViaKey === configuredViaKey
+  ) {
+    return { result: cache.result, cache };
+  }
+
+  const items: PickerItem[] = [];
+  let currentGroup: 'Popular' | 'All Providers' | null = null;
+
+  for (const p of filteredProviders) {
+    const group: 'Popular' | 'All Providers' = POPULAR_PROVIDERS.has(p.toLowerCase()) ? 'Popular' : 'All Providers';
+    if (group !== currentGroup) {
+      items.push({ id: `__header__${group}`, label: group, isGroupHeader: true });
+      currentGroup = group;
+    }
+    items.push({
+      id: p,
+      label: p,
+      isConfigured: configuredProviders.has(p),
+      configuredVia: configuredViaMap.get(p),
+    });
+  }
+
+  const newCache: ProviderItemsCache = {
+    filteredProvidersRef: filteredProviders,
+    configuredProvidersKey,
+    configuredViaKey,
+    result: items,
+  };
+
+  return { result: items, cache: newCache };
+}
+
+// ---------------------------------------------------------------------------
+// buildEffortItems — effort levels -> PickerItem[]
+// ---------------------------------------------------------------------------
+
+export function buildEffortItems(effortLevels: readonly string[]): PickerItem[] {
+  return effortLevels.map(e => ({ id: e, label: e, detail: EFFORT_DESCRIPTIONS[e] ?? '' }));
+}