@pellux/goodvibes-tui 0.18.10 → 0.18.12

package/src/state/memory-embeddings.ts

@@ -1,312 +0,0 @@
-import { ConfigManager, getConfiguredEmbeddingProviderId } from '../config/index.ts';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
-import { createBuiltinMemoryEmbeddingProviders } from '@pellux/goodvibes-sdk/platform/state/memory-embedding-http';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-export const DEFAULT_MEMORY_EMBEDDING_DIMS = 384;
-
-export type MemoryEmbeddingProviderState = 'healthy' | 'degraded' | 'disabled' | 'unconfigured';
-export type MemoryEmbeddingUsage = 'record' | 'query' | 'doctor';
-
-export interface MemoryEmbeddingRequest {
-  readonly text: string;
-  readonly dimensions: number;
-  readonly usage: MemoryEmbeddingUsage;
-  readonly recordId?: string;
-  readonly metadata?: Record<string, unknown>;
-}
-
-export interface MemoryEmbeddingResult {
-  readonly vector: Float32Array | readonly number[];
-  readonly dimensions: number;
-  readonly modelId?: string;
-  readonly metadata?: Record<string, unknown>;
-}
-
-export interface MemoryEmbeddingProviderStatus {
-  readonly id: string;
-  readonly label: string;
-  readonly state: MemoryEmbeddingProviderState;
-  readonly dimensions: number;
-  readonly configured: boolean;
-  readonly deterministic?: boolean;
-  readonly detail?: string;
-  readonly metadata: Record<string, unknown>;
-}
-
-export interface MemoryEmbeddingProvider {
-  readonly id: string;
-  readonly label: string;
-  readonly dimensions: number;
-  readonly deterministic?: boolean;
-  readonly local?: boolean;
-  embedSync?(request: MemoryEmbeddingRequest): MemoryEmbeddingResult;
-  embed?(request: MemoryEmbeddingRequest): Promise<MemoryEmbeddingResult>;
-  status?(): MemoryEmbeddingProviderStatus | Promise<MemoryEmbeddingProviderStatus>;
-}
-
-export interface MemoryEmbeddingDoctorReport {
-  readonly activeProviderId: string;
-  readonly providers: readonly MemoryEmbeddingProviderStatus[];
-  readonly asyncProviders: readonly string[];
-  readonly syncProviders: readonly string[];
-  readonly warnings: readonly string[];
-}
-
-export interface MemoryEmbeddingProviderRegistryOptions {
-  readonly configManager: ConfigManager;
-}
-
-export function embedMemoryText(text: string, dims = DEFAULT_MEMORY_EMBEDDING_DIMS): Float32Array {
-  const vector = new Float32Array(dims);
-  const normalized = text.toLowerCase();
-  const tokens = normalized
-    .split(/[^a-z0-9_./-]+/)
-    .map((token) => token.trim())
-    .filter((token) => token.length >= 2);
-
-  for (const token of tokens) {
-    addHashedFeature(vector, `tok:${token}`, 1.2);
-    if (token.includes('/') || token.includes('.') || token.includes('-') || token.includes('_')) {
-      for (const part of token.split(/[./_-]+/).filter((entry) => entry.length >= 2)) {
-        addHashedFeature(vector, `part:${part}`, 0.8);
-      }
-    }
-  }
-
-  for (let i = 0; i < tokens.length - 1; i++) {
-    addHashedFeature(vector, `bigram:${tokens[i]} ${tokens[i + 1]}`, 0.9);
-  }
-
-  const compact = normalized.replace(/\s+/g, ' ').trim();
-  for (let i = 0; i < compact.length - 2; i++) {
-    const tri = compact.slice(i, i + 3);
-    if (/\s{2,}/.test(tri)) continue;
-    addHashedFeature(vector, `tri:${tri}`, 0.18);
-  }
-
-  normalizeVector(vector);
-  return vector;
-}
-
-export function normalizeMemoryEmbeddingVector(vector: Float32Array | readonly number[], dimensions: number): Float32Array {
-  if (vector instanceof Float32Array && vector.length === dimensions) return vector;
-  const normalized = new Float32Array(dimensions);
-  const limit = Math.min(vector.length, dimensions);
-  for (let i = 0; i < limit; i++) {
-    const value = Number(vector[i]);
-    normalized[i] = Number.isFinite(value) ? value : 0;
-  }
-  normalizeVector(normalized);
-  return normalized;
-}
-
-export class MemoryEmbeddingProviderRegistry {
-  private readonly providers = new Map<string, MemoryEmbeddingProvider>();
-  private activeProviderId = HASHED_MEMORY_EMBEDDING_PROVIDER.id;
-  private readonly configManager: ConfigManager;
-
-  constructor(options: MemoryEmbeddingProviderRegistryOptions) {
-    this.configManager = options.configManager;
-    this.register(HASHED_MEMORY_EMBEDDING_PROVIDER, { replace: true });
-    for (const provider of createBuiltinMemoryEmbeddingProviders()) {
-      this.register(provider, { replace: true });
-    }
-    const configuredDefault = getConfiguredEmbeddingProviderId(this.configManager).trim();
-    if (configuredDefault) {
-      this.activeProviderId = configuredDefault;
-    }
-  }
-
-  register(provider: MemoryEmbeddingProvider, options: { readonly replace?: boolean; readonly makeDefault?: boolean } = {}): () => void {
-    const id = provider.id.trim();
-    if (!id) throw new Error('Memory embedding provider id is required');
-    if (this.providers.has(id) && !options.replace) {
-      throw new Error(`Memory embedding provider already registered: ${id}`);
-    }
-    const registered = { ...provider, id };
-    this.providers.set(id, registered);
-    if (options.makeDefault) {
-      this.activeProviderId = id;
-      persistDefaultEmbeddingProviderId(this.configManager, id);
-    }
-    return () => {
-      if (this.providers.get(id) === registered) this.unregister(id);
-    };
-  }
-
-  unregister(id: string): boolean {
-    if (id === HASHED_MEMORY_EMBEDDING_PROVIDER.id) return false;
-    return this.providers.delete(id);
-  }
-
-  setDefaultProvider(id: string): void {
-    if (!this.providers.has(id)) throw new Error(`Unknown memory embedding provider: ${id}`);
-    this.activeProviderId = id;
-    persistDefaultEmbeddingProviderId(this.configManager, id);
-  }
-
-  getDefaultProvider(): MemoryEmbeddingProvider {
-    return this.providers.get(this.activeProviderId) ?? HASHED_MEMORY_EMBEDDING_PROVIDER;
-  }
-
-  get(id: string): MemoryEmbeddingProvider | null {
-    return this.providers.get(id) ?? null;
-  }
-
-  list(): MemoryEmbeddingProvider[] {
-    return [...this.providers.values()].sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
-  }
-
-  embedSync(request: MemoryEmbeddingRequest): MemoryEmbeddingResult {
-    const provider = this.getDefaultProvider();
-    if (provider.embedSync) return provider.embedSync(request);
-    return HASHED_MEMORY_EMBEDDING_PROVIDER.embedSync!(request);
-  }
-
-  async embedAsync(request: MemoryEmbeddingRequest): Promise<MemoryEmbeddingResult> {
-    const provider = this.getDefaultProvider();
-    if (provider.embed) {
-      try {
-        return await provider.embed(request);
-      } catch (error) {
-        logger.warn('Memory embedding provider failed; falling back to hashed local embeddings', {
-          providerId: provider.id,
-          error: summarizeError(error),
-        });
-      }
-    }
-    if (provider.embedSync) {
-      return provider.embedSync(request);
-    }
-    return HASHED_MEMORY_EMBEDDING_PROVIDER.embedSync!(request);
-  }
-
-  async status(): Promise<MemoryEmbeddingProviderStatus[]> {
-    const statuses: MemoryEmbeddingProviderStatus[] = [];
-    for (const provider of this.providers.values()) {
-      if (provider.status) {
-        statuses.push(await provider.status());
-        continue;
-      }
-      statuses.push({
-        id: provider.id,
-        label: provider.label,
-        state: 'healthy',
-        dimensions: provider.dimensions,
-        configured: true,
-        deterministic: provider.deterministic,
-        metadata: {
-          local: provider.local === true,
-          hasSyncEmbed: typeof provider.embedSync === 'function',
-          hasAsyncEmbed: typeof provider.embed === 'function',
-        },
-      });
-    }
-    if (this.activeProviderId !== HASHED_MEMORY_EMBEDDING_PROVIDER.id && !this.providers.has(this.activeProviderId)) {
-      statuses.push({
-        id: this.activeProviderId,
-        label: `Persisted default (${this.activeProviderId})`,
-        state: 'unconfigured',
-        dimensions: DEFAULT_MEMORY_EMBEDDING_DIMS,
-        configured: false,
-        detail: `Persisted embedding provider '${this.activeProviderId}' is not registered; sqlite-vec will use '${HASHED_MEMORY_EMBEDDING_PROVIDER.id}' until it returns.`,
-        metadata: {
-          local: true,
-          hasSyncEmbed: false,
-          hasAsyncEmbed: false,
-          persistedDefault: true,
-        },
-      });
-    }
-    return statuses.sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
-  }
-
-  async doctor(): Promise<MemoryEmbeddingDoctorReport> {
-    const providers = await this.status();
-    const syncProviders = this.list().filter((provider) => typeof provider.embedSync === 'function').map((provider) => provider.id);
-    const asyncProviders = this.list().filter((provider) => typeof provider.embed === 'function').map((provider) => provider.id);
-    const active = this.getDefaultProvider();
-    const activeStatus = providers.find((provider) => provider.id === active.id);
-    const warnings: string[] = [];
-    if (!this.providers.has(this.activeProviderId)) {
-      warnings.push(`Persisted embedding provider '${this.activeProviderId}' is not currently registered; falling back to '${HASHED_MEMORY_EMBEDDING_PROVIDER.id}'.`);
-    }
-    if (activeStatus && !activeStatus.configured) {
-      warnings.push(`Active embedding provider '${active.id}' is not fully configured: ${activeStatus.detail ?? 'configuration is incomplete'}`);
-    }
-    if (!active.embedSync) {
-      if (active.embed) {
-        warnings.push(`Active embedding provider '${active.id}' is async-only; sqlite-vec indexing will fall back to '${HASHED_MEMORY_EMBEDDING_PROVIDER.id}' for live writes and can be rebuilt asynchronously.`);
-      } else {
-        warnings.push(`Active embedding provider '${active.id}' has no sync embed path; sqlite-vec indexing will fall back to '${HASHED_MEMORY_EMBEDDING_PROVIDER.id}'.`);
-      }
-    }
-    const activeDimensions = active.dimensions;
-    if (activeDimensions !== DEFAULT_MEMORY_EMBEDDING_DIMS) {
-      warnings.push(`Active embedding provider '${active.id}' advertises ${active.dimensions} dimensions; vectors are normalized to ${DEFAULT_MEMORY_EMBEDDING_DIMS} dimensions for sqlite-vec storage.`);
-    }
-    return {
-      activeProviderId: this.activeProviderId,
-      providers,
-      asyncProviders,
-      syncProviders,
-      warnings,
-    };
-  }
-}
-
-function persistDefaultEmbeddingProviderId(configManager: ConfigManager, providerId: string): void {
-  try {
-    configManager.set('provider.embeddingProvider', providerId, { bypassManagedLock: true });
-  } catch {
-    // Persistence is best-effort; runtime selection still takes effect immediately.
-  }
-}
-
-export const HASHED_MEMORY_EMBEDDING_PROVIDER: MemoryEmbeddingProvider = {
-  id: 'hashed-local',
-  label: 'Hashed Local Embeddings',
-  dimensions: DEFAULT_MEMORY_EMBEDDING_DIMS,
-  deterministic: true,
-  local: true,
-  embedSync(request) {
-    return {
-      vector: embedMemoryText(request.text, request.dimensions),
-      dimensions: request.dimensions,
-      modelId: 'goodvibes-hashed-local',
-      metadata: {
-        usage: request.usage,
-        deterministic: true,
-      },
-    };
-  },
-};
-
-function normalizeVector(vector: Float32Array): void {
-  let sum = 0;
-  for (const value of vector) {
-    sum += value * value;
-  }
-  const norm = Math.sqrt(sum);
-  if (norm === 0) return;
-  for (let i = 0; i < vector.length; i++) {
-    vector[i] = vector[i]! / norm;
-  }
-}
-
-function addHashedFeature(vector: Float32Array, feature: string, weight: number): void {
-  const hash = fnv1a(feature);
-  const index = hash % vector.length;
-  const sign = (hash & 0x80000000) === 0 ? 1 : -1;
-  vector[index] += sign * weight;
-}
-
-function fnv1a(value: string): number {
-  let hash = 0x811c9dc5;
-  for (let i = 0; i < value.length; i++) {
-    hash ^= value.charCodeAt(i);
-    hash = Math.imul(hash, 0x01000193);
-  }
-  return hash >>> 0;
-}

package/src/state/memory-ingest.ts

@@ -1,132 +0,0 @@
-import type { MemoryAddOptions, ProvenanceLink } from '@pellux/goodvibes-sdk/platform/state/memory-store';
-import type { ForensicsBundle } from '@pellux/goodvibes-sdk/platform/runtime/forensics/types';
-import type { PolicyPreflightReview } from '@pellux/goodvibes-sdk/platform/runtime/permissions/preflight';
-import type { PluginStatus } from '@pellux/goodvibes-sdk/platform/plugins/manager';
-
-export interface McpSecurityCapture {
-  readonly name: string;
-  readonly role: string;
-  readonly trustMode: string;
-  readonly connected: boolean;
-  readonly allowedPaths: readonly string[];
-  readonly allowedHosts: readonly string[];
-  readonly schemaFreshness: string;
-  readonly quarantineReason?: string;
-  readonly quarantineDetail?: string;
-  readonly quarantineApprovedBy?: string;
-}
-
-export function buildIncidentMemoryAddOptions(bundle: ForensicsBundle): MemoryAddOptions {
-  const provenance: ProvenanceLink[] = [];
-  if (bundle.report.sessionId) provenance.push({ kind: 'session', ref: bundle.report.sessionId });
-  if (bundle.report.turnId) provenance.push({ kind: 'turn', ref: bundle.report.turnId });
-  if (bundle.report.taskId) provenance.push({ kind: 'task', ref: bundle.report.taskId });
-
-  const details = [
-    `classification=${bundle.report.classification}`,
-    bundle.evidence.rootCause ? `rootCause=${bundle.evidence.rootCause}` : undefined,
-    bundle.evidence.terminalPhase ? `terminalPhase=${bundle.evidence.terminalPhase}` : undefined,
-    bundle.evidence.terminalOutcome ? `terminalOutcome=${bundle.evidence.terminalOutcome}` : undefined,
-    `deniedPermissions=${bundle.evidence.deniedPermissionCount}`,
-    `budgetBreaches=${bundle.evidence.budgetBreachCount}`,
-    `replayMismatches=${bundle.replay.mismatchCount}`,
-  ].filter((value): value is string => Boolean(value));
-
-  const tags = [
-    'forensics',
-    bundle.report.classification,
-    ...(bundle.report.stopReason ? [bundle.report.stopReason] : []),
-    ...(bundle.evidence.slowPhases.length > 0 ? ['slow-phase'] : []),
-  ];
-
-  return {
-    cls: 'incident',
-    summary: bundle.report.summary,
-    detail: details.join('\n'),
-    tags,
-    provenance,
-    review: {
-      state: 'fresh',
-      confidence: 90,
-    },
-  };
-}
-
-export function buildPolicyPreflightMemoryAddOptions(review: PolicyPreflightReview): MemoryAddOptions {
-  return {
-    cls: review.status === 'pass' ? 'fact' : 'risk',
-    summary: `Policy preflight: ${review.summary}`,
-    detail: review.issues
-      .map((issue) => `${issue.severity}:${issue.source}${issue.serverName ? `:${issue.serverName}` : ''} ${issue.message}`)
-      .join('\n'),
-    tags: [
-      'security',
-      'policy',
-      'preflight',
-      review.status,
-    ],
-    provenance: [],
-    review: {
-      state: 'fresh',
-      confidence: review.status === 'pass' ? 80 : 75,
-    },
-  };
-}
-
-export function buildMcpSecurityMemoryAddOptions(server: McpSecurityCapture): MemoryAddOptions {
-  const isRisk = server.schemaFreshness === 'quarantined' || server.trustMode === 'allow-all';
-  return {
-    cls: isRisk ? 'risk' : 'fact',
-    summary: `MCP security posture: ${server.name} (${server.role}) ${server.trustMode}`,
-    detail: [
-      `connected=${server.connected}`,
-      `schemaFreshness=${server.schemaFreshness}`,
-      `allowedPaths=${server.allowedPaths.length > 0 ? server.allowedPaths.join(',') : 'unbounded'}`,
-      `allowedHosts=${server.allowedHosts.length > 0 ? server.allowedHosts.join(',') : 'unbounded'}`,
-      server.quarantineReason ? `quarantineReason=${server.quarantineReason}` : undefined,
-      server.quarantineDetail ? `quarantineDetail=${server.quarantineDetail}` : undefined,
-      server.quarantineApprovedBy ? `quarantineApprovedBy=${server.quarantineApprovedBy}` : undefined,
-    ].filter((value): value is string => Boolean(value)).join('\n'),
-    tags: [
-      'security',
-      'mcp',
-      server.role,
-      server.trustMode,
-      server.schemaFreshness,
-    ],
-    provenance: [],
-    review: {
-      state: 'fresh',
-      confidence: isRisk ? 65 : 75,
-    },
-  };
-}
-
-export function buildPluginSecurityMemoryAddOptions(
-  plugin: PluginStatus,
-  quarantineReason?: string,
-): MemoryAddOptions {
-  const isRisk = plugin.quarantined || plugin.trustTier === 'untrusted';
-  return {
-    cls: isRisk ? 'risk' : 'fact',
-    summary: `Plugin security posture: ${plugin.name} ${plugin.trustTier}${plugin.quarantined ? ' quarantined' : ''}`,
-    detail: [
-      `enabled=${plugin.enabled}`,
-      `active=${plugin.active}`,
-      `trustTier=${plugin.trustTier}`,
-      `quarantined=${plugin.quarantined}`,
-      quarantineReason ? `quarantineReason=${quarantineReason}` : undefined,
-    ].filter((value): value is string => Boolean(value)).join('\n'),
-    tags: [
-      'security',
-      'plugin',
-      plugin.trustTier,
-      ...(plugin.quarantined ? ['quarantined'] : []),
-    ],
-    provenance: [],
-    review: {
-      state: 'fresh',
-      confidence: isRisk ? 60 : 70,
-    },
-  };
-}

package/src/state/memory-registry.ts

@@ -1,111 +0,0 @@
-import type { MemoryAddOptions, MemoryBundle, MemoryDoctorReport, MemoryLink, MemoryRecord, MemoryReviewPatch, MemoryScope, MemorySearchFilter, MemorySemanticSearchResult, MemoryStore } from '@pellux/goodvibes-sdk/platform/state/memory-store';
-import type { MemoryVectorStats } from '@pellux/goodvibes-sdk/platform/state/memory-vector-store';
-import type { MemoryImportResult } from '@pellux/goodvibes-sdk/platform/state/memory-store';
-
-/**
- * MemoryRegistry — thin observable wrapper around the MemoryStore.
- * Panels subscribe via listeners; commands push/retrieve through this.
- */
-export class MemoryRegistry {
-  private store: MemoryStore;
-  private listeners: Array<() => void> = [];
-
-  constructor(store: MemoryStore) {
-    this.store = store;
-  }
-
-  getStore(): MemoryStore {
-    return this.store;
-  }
-
-  subscribe(fn: () => void): () => void {
-    this.listeners.push(fn);
-    return () => {
-      this.listeners = this.listeners.filter(l => l !== fn);
-    };
-  }
-
-  private notify(): void {
-    for (const fn of this.listeners) fn();
-  }
-
-  async add(opts: MemoryAddOptions): Promise<MemoryRecord> {
-    const record = await this.store.add(opts);
-    this.notify();
-    return record;
-  }
-
-  search(filter: MemorySearchFilter = {}): MemoryRecord[] {
-    return this.store.search(filter);
-  }
-
-  searchSemantic(filter: MemorySearchFilter = {}): MemorySemanticSearchResult[] {
-    return this.store.searchSemantic(filter);
-  }
-
-  rebuildVectors(): MemoryVectorStats {
-    return this.store.rebuildVectorIndex();
-  }
-
-  async rebuildVectorsAsync(): Promise<MemoryVectorStats> {
-    return this.store.rebuildVectorIndexAsync();
-  }
-
-  vectorStats(): MemoryVectorStats {
-    return this.store.vectorStats();
-  }
-
-  async doctor(): Promise<MemoryDoctorReport> {
-    return this.store.doctor();
-  }
-
-  reviewQueue(limit = 10): MemoryRecord[] {
-    return this.store.reviewQueue(limit);
-  }
-
-  exportBundle(filter: MemorySearchFilter = {}): MemoryBundle {
-    return this.store.exportBundle(filter);
-  }
-
-  async importBundle(bundle: MemoryBundle): Promise<MemoryImportResult> {
-    const result = await this.store.importBundle(bundle);
-    this.notify();
-    return result;
-  }
-
-  get(id: string): MemoryRecord | null {
-    return this.store.get(id);
-  }
-
-  async link(fromId: string, toId: string, relation: string): Promise<MemoryLink | null> {
-    const link = await this.store.link(fromId, toId, relation);
-    if (link) this.notify();
-    return link;
-  }
-
-  linksFor(id: string): MemoryLink[] {
-    return this.store.linksFor(id);
-  }
-
-  update(id: string, patch: { scope?: MemoryScope; summary?: string; detail?: string; tags?: string[] }): MemoryRecord | null {
-    const record = this.store.update(id, patch);
-    if (record) this.notify();
-    return record;
-  }
-
-  review(id: string, patch: MemoryReviewPatch): MemoryRecord | null {
-    const record = this.store.review(id, patch);
-    if (record) this.notify();
-    return record;
-  }
-
-  delete(id: string): boolean {
-    const removed = this.store.delete(id);
-    if (removed) this.notify();
-    return removed;
-  }
-
-  getAll(): MemoryRecord[] {
-    return this.store.search({});
-  }
-}