claude-memory-layer 1.0.31 → 1.0.32

package/src/core/working-set-store.ts

@@ -1,257 +0,0 @@
-/**
- * Working Set Store
- * Manages the active memory window for Endless Mode
- * Biomimetic: Simulates human working memory (7±2 items, 15-30s duration)
- */
-
-import { randomUUID } from 'crypto';
-import { dbRun, dbAll, toDate, type Database } from './db-wrapper.js';
-import type {
-  MemoryEvent,
-  EndlessModeConfig,
-  WorkingSet,
-  WorkingSetItem
-} from './types.js';
-import { EventStore } from './event-store.js';
-
-export class WorkingSetStore {
-  constructor(
-    private eventStore: EventStore,
-    private config: EndlessModeConfig
-  ) {}
-
-  private get db(): Database {
-    return this.eventStore.getDatabase();
-  }
-
-  /**
-   * Add an event to the working set
-   */
-  async add(eventId: string, relevanceScore: number = 1.0, topics?: string[]): Promise<void> {
-    const expiresAt = new Date(
-      Date.now() + this.config.workingSet.timeWindowHours * 60 * 60 * 1000
-    );
-
-    await dbRun(
-      this.db,
-      `INSERT OR REPLACE INTO working_set (id, event_id, added_at, relevance_score, topics, expires_at)
-       VALUES (?, ?, CURRENT_TIMESTAMP, ?, ?, ?)`,
-      [
-        randomUUID(),
-        eventId,
-        relevanceScore,
-        JSON.stringify(topics || []),
-        expiresAt.toISOString()
-      ]
-    );
-
-    // Enforce size limit
-    await this.enforceLimit();
-  }
-
-  /**
-   * Get the current working set
-   */
-  async get(): Promise<WorkingSet> {
-    // Clean up expired items first
-    await this.cleanup();
-
-    // Get working set items with their events
-    const rows = await dbAll<Record<string, unknown>>(
-      this.db,
-      `SELECT ws.*, e.*
-       FROM working_set ws
-       JOIN events e ON ws.event_id = e.id
-       ORDER BY ws.relevance_score DESC, ws.added_at DESC
-       LIMIT ?`,
-      [this.config.workingSet.maxEvents]
-    );
-
-    const events: MemoryEvent[] = rows.map(row => ({
-      id: row.id as string,
-      eventType: row.event_type as 'user_prompt' | 'agent_response' | 'session_summary' | 'tool_observation',
-      sessionId: row.session_id as string,
-      timestamp: toDate(row.timestamp),
-      content: row.content as string,
-      canonicalKey: row.canonical_key as string,
-      dedupeKey: row.dedupe_key as string,
-      metadata: row.metadata ? JSON.parse(row.metadata as string) : undefined
-    }));
-
-    return {
-      recentEvents: events,
-      lastActivity: events.length > 0 ? events[0].timestamp : new Date(),
-      continuityScore: await this.calculateContinuityScore()
-    };
-  }
-
-  /**
-   * Get working set items (metadata only)
-   */
-  async getItems(): Promise<WorkingSetItem[]> {
-    const rows = await dbAll<Record<string, unknown>>(
-      this.db,
-      `SELECT * FROM working_set ORDER BY relevance_score DESC, added_at DESC`
-    );
-
-    return rows.map(row => ({
-      id: row.id as string,
-      eventId: row.event_id as string,
-      addedAt: toDate(row.added_at),
-      relevanceScore: row.relevance_score as number,
-      topics: row.topics ? JSON.parse(row.topics as string) : undefined,
-      expiresAt: toDate(row.expires_at)
-    }));
-  }
-
-  /**
-   * Update relevance score for an event
-   */
-  async updateRelevance(eventId: string, score: number): Promise<void> {
-    await dbRun(
-      this.db,
-      `UPDATE working_set SET relevance_score = ? WHERE event_id = ?`,
-      [score, eventId]
-    );
-  }
-
-  /**
-   * Prune specific events from working set (after consolidation)
-   */
-  async prune(eventIds: string[]): Promise<void> {
-    if (eventIds.length === 0) return;
-
-    const placeholders = eventIds.map(() => '?').join(',');
-    await dbRun(
-      this.db,
-      `DELETE FROM working_set WHERE event_id IN (${placeholders})`,
-      eventIds
-    );
-  }
-
-  /**
-   * Get the count of items in working set
-   */
-  async count(): Promise<number> {
-    const result = await dbAll<{ count: number }>(
-      this.db,
-      `SELECT COUNT(*) as count FROM working_set`
-    );
-    return result[0]?.count || 0;
-  }
-
-  /**
-   * Clear the entire working set
-   */
-  async clear(): Promise<void> {
-    await dbRun(this.db, `DELETE FROM working_set`);
-  }
-
-  /**
-   * Check if an event is in the working set
-   */
-  async contains(eventId: string): Promise<boolean> {
-    const result = await dbAll<{ count: number }>(
-      this.db,
-      `SELECT COUNT(*) as count FROM working_set WHERE event_id = ?`,
-      [eventId]
-    );
-    return (result[0]?.count || 0) > 0;
-  }
-
-  /**
-   * Refresh expiration for an event (rehears al - keep relevant items longer)
-   */
-  async refresh(eventId: string): Promise<void> {
-    const newExpiresAt = new Date(
-      Date.now() + this.config.workingSet.timeWindowHours * 60 * 60 * 1000
-    );
-
-    await dbRun(
-      this.db,
-      `UPDATE working_set SET expires_at = ? WHERE event_id = ?`,
-      [newExpiresAt.toISOString(), eventId]
-    );
-  }
-
-  /**
-   * Clean up expired items
-   */
-  private async cleanup(): Promise<void> {
-    await dbRun(
-      this.db,
-      `DELETE FROM working_set WHERE expires_at < datetime('now')`
-    );
-  }
-
-  /**
-   * Enforce the maximum size limit
-   * Removes lowest relevance items when over limit
-   */
-  private async enforceLimit(): Promise<void> {
-    const maxEvents = this.config.workingSet.maxEvents;
-
-    // Get IDs to keep (highest relevance, most recent)
-    const keepIds = await dbAll<{ id: string }>(
-      this.db,
-      `SELECT id FROM working_set
-       ORDER BY relevance_score DESC, added_at DESC
-       LIMIT ?`,
-      [maxEvents]
-    );
-
-    if (keepIds.length === 0) return;
-
-    const keepIdList = keepIds.map(r => r.id);
-    const placeholders = keepIdList.map(() => '?').join(',');
-
-    // Delete everything not in the keep list
-    await dbRun(
-      this.db,
-      `DELETE FROM working_set WHERE id NOT IN (${placeholders})`,
-      keepIdList
-    );
-  }
-
-  /**
-   * Calculate continuity score based on recent context transitions
-   */
-  private async calculateContinuityScore(): Promise<number> {
-    const result = await dbAll<{ avg_score: number | null }>(
-      this.db,
-      `SELECT AVG(continuity_score) as avg_score
-       FROM continuity_log
-       WHERE created_at > datetime('now', '-1 hour')`
-    );
-
-    return result[0]?.avg_score ?? 0.5;
-  }
-
-  /**
-   * Get topics from current working set for context matching
-   */
-  async getActiveTopics(): Promise<string[]> {
-    const rows = await dbAll<{ topics: string }>(
-      this.db,
-      `SELECT topics FROM working_set WHERE topics IS NOT NULL`
-    );
-
-    const allTopics = new Set<string>();
-    for (const row of rows) {
-      const topics = JSON.parse(row.topics) as string[];
-      topics.forEach(t => allTopics.add(t));
-    }
-
-    return Array.from(allTopics);
-  }
-}
-
-/**
- * Create a Working Set Store instance
- */
-export function createWorkingSetStore(
-  eventStore: EventStore,
-  config: EndlessModeConfig
-): WorkingSetStore {
-  return new WorkingSetStore(eventStore, config);
-}

package/src/extensions/endless-memory/endless-memory-services.ts

@@ -1,350 +0,0 @@
-import { randomUUID } from 'crypto';
-
-import type { EventStore } from '../../core/event-store.js';
-import {
-  createWorkingSetStore,
-  type WorkingSetStore
-} from '../../core/working-set-store.js';
-import {
-  createConsolidatedStore,
-  type ConsolidatedStore
-} from '../../core/consolidated-store.js';
-import {
-  createConsolidationWorker,
-  type ConsolidationWorker
-} from '../../core/consolidation-worker.js';
-import {
-  createContinuityManager,
-  type ContinuityManager
-} from '../../core/continuity-manager.js';
-import type {
-  ConsolidatedMemory,
-  ContinuityScore,
-  EndlessModeConfig,
-  EndlessModeStatus,
-  MemoryMode,
-  WorkingSet
-} from '../../core/types.js';
-
-export interface EndlessConfigStore {
-  getEndlessConfig(key: string): Promise<unknown>;
-  setEndlessConfig(key: string, value: unknown): Promise<void>;
-}
-
-export interface WorkingSetStorePort {
-  add(eventId: string, relevanceScore?: number): Promise<void>;
-  get(): Promise<WorkingSet>;
-  count(): Promise<number>;
-}
-
-export interface ConsolidatedStorePort {
-  search(query: string, options?: { topK?: number }): Promise<ConsolidatedMemory[]>;
-  getAll(options?: { limit?: number }): Promise<ConsolidatedMemory[]>;
-  markAccessed(memoryId: string): Promise<void>;
-  count(): Promise<number>;
-  getLastConsolidationTime(): Promise<Date | null>;
-}
-
-export interface ConsolidationWorkerPort {
-  start(): void;
-  stop(): void;
-  recordActivity(): void;
-  forceRun(): Promise<number>;
-}
-
-export interface ContinuityManagerPort {
-  createSnapshot(
-    id: string,
-    content: string,
-    metadata?: { files?: string[]; entities?: string[] }
-  ): unknown;
-  calculateScore(snapshot: unknown): Promise<ContinuityScore>;
-}
-
-export interface EndlessMemoryServicesFactories {
-  createWorkingSetStore: (eventStore: EventStore, config: EndlessModeConfig) => WorkingSetStorePort;
-  createConsolidatedStore: (eventStore: EventStore) => ConsolidatedStorePort;
-  createConsolidationWorker: (
-    workingSetStore: WorkingSetStorePort,
-    consolidatedStore: ConsolidatedStorePort,
-    config: EndlessModeConfig
-  ) => ConsolidationWorkerPort;
-  createContinuityManager: (eventStore: EventStore, config: EndlessModeConfig) => ContinuityManagerPort;
-  randomUUID?: () => string;
-}
-
-export interface EndlessMemoryServicesOptions {
-  eventStore: EventStore;
-  configStore: EndlessConfigStore;
-  initialize: () => Promise<void>;
-  factories?: EndlessMemoryServicesFactories;
-}
-
-export interface EndlessMemoryServices {
-  initializeFromSavedMode(): Promise<void>;
-  initializeEndlessMode(): Promise<void>;
-  getEndlessConfig(): Promise<EndlessModeConfig>;
-  setEndlessConfig(config: Partial<EndlessModeConfig>): Promise<void>;
-  setMode(mode: MemoryMode): Promise<void>;
-  getMode(): MemoryMode;
-  isEndlessModeActive(): boolean;
-  addToWorkingSet(eventId: string, relevanceScore?: number): Promise<void>;
-  getWorkingSet(): Promise<WorkingSet | null>;
-  searchConsolidated(query: string, options?: { topK?: number }): Promise<ConsolidatedMemory[]>;
-  getConsolidatedMemories(limit?: number): Promise<ConsolidatedMemory[]>;
-  markMemoryAccessed(memoryId: string): Promise<void>;
-  calculateContinuity(
-    content: string,
-    metadata?: { files?: string[]; entities?: string[] }
-  ): Promise<ContinuityScore | null>;
-  recordActivity(): void;
-  forceConsolidation(): Promise<number>;
-  getEndlessModeStatus(): Promise<EndlessModeStatus>;
-  formatEndlessContext(query: string): Promise<string>;
-  shutdown(): void;
-}
-
-function getDefaultEndlessConfig(): EndlessModeConfig {
-  return {
-    enabled: true,
-    workingSet: {
-      maxEvents: 100,
-      timeWindowHours: 24,
-      minRelevanceScore: 0.5
-    },
-    consolidation: {
-      triggerIntervalMs: 3600000,
-      triggerEventCount: 100,
-      triggerIdleMs: 1800000,
-      useLLMSummarization: false
-    },
-    continuity: {
-      minScoreForSeamless: 0.7,
-      topicDecayHours: 48
-    }
-  };
-}
-
-const defaultFactories: Required<EndlessMemoryServicesFactories> = {
-  createWorkingSetStore: (eventStore, config) => createWorkingSetStore(eventStore, config) as WorkingSetStore,
-  createConsolidatedStore: (eventStore) => createConsolidatedStore(eventStore) as ConsolidatedStore,
-  createConsolidationWorker: (workingSetStore, consolidatedStore, config) => createConsolidationWorker(
-    workingSetStore as WorkingSetStore,
-    consolidatedStore as ConsolidatedStore,
-    config
-  ) as ConsolidationWorker,
-  createContinuityManager: (eventStore, config) => createContinuityManager(eventStore, config) as ContinuityManager,
-  randomUUID
-};
-
-class DefaultEndlessMemoryServices implements EndlessMemoryServices {
-  private readonly factories: Required<EndlessMemoryServicesFactories>;
-  private workingSetStore: WorkingSetStorePort | null = null;
-  private consolidatedStore: ConsolidatedStorePort | null = null;
-  private consolidationWorker: ConsolidationWorkerPort | null = null;
-  private continuityManager: ContinuityManagerPort | null = null;
-  private mode: MemoryMode = 'session';
-
-  constructor(private readonly options: EndlessMemoryServicesOptions) {
-    this.factories = options.factories
-      ? { ...options.factories, randomUUID: options.factories.randomUUID ?? randomUUID }
-      : defaultFactories;
-  }
-
-  async initializeFromSavedMode(): Promise<void> {
-    const savedMode = await this.options.configStore.getEndlessConfig('mode') as MemoryMode | null;
-    if (savedMode === 'endless') {
-      this.mode = 'endless';
-      await this.initializeEndlessMode();
-    }
-  }
-
-  async initializeEndlessMode(): Promise<void> {
-    if (this.consolidationWorker) return;
-
-    const config = await this.getEndlessConfig();
-    const workingSetStore = this.factories.createWorkingSetStore(this.options.eventStore, config);
-    const consolidatedStore = this.factories.createConsolidatedStore(this.options.eventStore);
-    const consolidationWorker = this.factories.createConsolidationWorker(
-      workingSetStore,
-      consolidatedStore,
-      config
-    );
-    const continuityManager = this.factories.createContinuityManager(this.options.eventStore, config);
-
-    try {
-      consolidationWorker.start();
-    } catch (error) {
-      consolidationWorker.stop();
-      throw error;
-    }
-
-    this.workingSetStore = workingSetStore;
-    this.consolidatedStore = consolidatedStore;
-    this.consolidationWorker = consolidationWorker;
-    this.continuityManager = continuityManager;
-  }
-
-  async getEndlessConfig(): Promise<EndlessModeConfig> {
-    const savedConfig = await this.options.configStore.getEndlessConfig('config') as EndlessModeConfig | null;
-    return savedConfig || getDefaultEndlessConfig();
-  }
-
-  async setEndlessConfig(config: Partial<EndlessModeConfig>): Promise<void> {
-    const current = await this.getEndlessConfig();
-    const merged = { ...current, ...config };
-    await this.options.configStore.setEndlessConfig('config', merged);
-  }
-
-  async setMode(mode: MemoryMode): Promise<void> {
-    await this.options.initialize();
-    if (mode === this.mode) return;
-
-    this.mode = mode;
-    await this.options.configStore.setEndlessConfig('mode', mode);
-
-    if (mode === 'endless') {
-      await this.initializeEndlessMode();
-    } else {
-      this.stopEndlessMode();
-    }
-  }
-
-  getMode(): MemoryMode {
-    return this.mode;
-  }
-
-  isEndlessModeActive(): boolean {
-    return this.mode === 'endless';
-  }
-
-  async addToWorkingSet(eventId: string, relevanceScore?: number): Promise<void> {
-    if (!this.workingSetStore) return;
-    await this.workingSetStore.add(eventId, relevanceScore);
-  }
-
-  async getWorkingSet(): Promise<WorkingSet | null> {
-    if (!this.workingSetStore) return null;
-    return this.workingSetStore.get();
-  }
-
-  async searchConsolidated(query: string, options?: { topK?: number }): Promise<ConsolidatedMemory[]> {
-    if (!this.consolidatedStore) return [];
-    return this.consolidatedStore.search(query, options);
-  }
-
-  async getConsolidatedMemories(limit?: number): Promise<ConsolidatedMemory[]> {
-    if (!this.consolidatedStore) return [];
-    return this.consolidatedStore.getAll({ limit });
-  }
-
-  async markMemoryAccessed(memoryId: string): Promise<void> {
-    if (!this.consolidatedStore) return;
-    await this.consolidatedStore.markAccessed(memoryId);
-  }
-
-  async calculateContinuity(
-    content: string,
-    metadata?: { files?: string[]; entities?: string[] }
-  ): Promise<ContinuityScore | null> {
-    if (!this.continuityManager) return null;
-    const snapshot = this.continuityManager.createSnapshot(
-      this.factories.randomUUID(),
-      content,
-      metadata
-    );
-    return this.continuityManager.calculateScore(snapshot);
-  }
-
-  recordActivity(): void {
-    this.consolidationWorker?.recordActivity();
-  }
-
-  async forceConsolidation(): Promise<number> {
-    if (!this.consolidationWorker) return 0;
-    return this.consolidationWorker.forceRun();
-  }
-
-  async getEndlessModeStatus(): Promise<EndlessModeStatus> {
-    await this.options.initialize();
-
-    let workingSetSize = 0;
-    let continuityScore = 0.5;
-    let consolidatedCount = 0;
-    let lastConsolidation: Date | null = null;
-
-    if (this.workingSetStore) {
-      workingSetSize = await this.workingSetStore.count();
-      const workingSet = await this.workingSetStore.get();
-      continuityScore = workingSet.continuityScore;
-    }
-
-    if (this.consolidatedStore) {
-      consolidatedCount = await this.consolidatedStore.count();
-      lastConsolidation = await this.consolidatedStore.getLastConsolidationTime();
-    }
-
-    return {
-      mode: this.mode,
-      workingSetSize,
-      continuityScore,
-      consolidatedCount,
-      lastConsolidation
-    };
-  }
-
-  async formatEndlessContext(query: string): Promise<string> {
-    if (!this.isEndlessModeActive()) {
-      return '';
-    }
-
-    const workingSet = await this.getWorkingSet();
-    const consolidated = await this.searchConsolidated(query, { topK: 3 });
-    const continuity = await this.calculateContinuity(query);
-
-    const parts: string[] = [];
-
-    if (continuity) {
-      const statusEmoji = continuity.transitionType === 'seamless' ? '🔗' :
-                          continuity.transitionType === 'topic_shift' ? '↪️' : '🆕';
-      parts.push(`${statusEmoji} Context: ${continuity.transitionType} (score: ${continuity.score.toFixed(2)})`);
-    }
-
-    if (workingSet && workingSet.recentEvents.length > 0) {
-      parts.push('\n## Recent Context (Working Set)');
-      const recent = workingSet.recentEvents.slice(0, 5);
-      for (const event of recent) {
-        const preview = event.content.slice(0, 80) + (event.content.length > 80 ? '...' : '');
-        const time = event.timestamp.toLocaleTimeString();
-        parts.push(`- ${time} [${event.eventType}] ${preview}`);
-      }
-    }
-
-    if (consolidated.length > 0) {
-      parts.push('\n## Related Knowledge (Consolidated)');
-      for (const memory of consolidated) {
-        parts.push(`- ${memory.topics.slice(0, 3).join(', ')}: ${memory.summary.slice(0, 100)}...`);
-      }
-    }
-
-    return parts.join('\n');
-  }
-
-  shutdown(): void {
-    this.stopEndlessMode();
-  }
-
-  private stopEndlessMode(): void {
-    if (this.consolidationWorker) {
-      this.consolidationWorker.stop();
-    }
-    this.workingSetStore = null;
-    this.consolidatedStore = null;
-    this.consolidationWorker = null;
-    this.continuityManager = null;
-  }
-}
-
-export function createEndlessMemoryServices(options: EndlessMemoryServicesOptions): EndlessMemoryServices {
-  return new DefaultEndlessMemoryServices(options);
-}

package/src/extensions/endless-memory/index.ts

@@ -1 +0,0 @@
-export * from './endless-memory-services.js';

package/src/extensions/index.ts

@@ -1,5 +0,0 @@
-/**
- * Optional accelerators and extension surfaces live here.
- */
-
-export {};