claude-memory-layer 1.0.30 → 1.0.32

package/src/core/sqlite-wrapper.ts

@@ -1,116 +0,0 @@
-/**
- * SQLite Wrapper with WAL Mode Support
- * Primary store for hooks - always available, no lock conflicts
- */
-
-import Database from 'better-sqlite3';
-import * as fs from 'fs';
-import * as nodePath from 'path';
-
-export type SQLiteDatabase = Database.Database;
-
-export interface SQLiteOptions {
-  readonly?: boolean;
-  walMode?: boolean;
-}
-
-/**
- * Creates a new SQLite database with WAL mode
- */
-export function createSQLiteDatabase(path: string, options?: SQLiteOptions): SQLiteDatabase {
-  // Ensure parent directory exists
-  const dir = nodePath.dirname(path);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-
-  const db = new Database(path, {
-    readonly: options?.readonly ?? false,
-  });
-
-  // Enable WAL mode for concurrent access (unless read-only)
-  if (!options?.readonly && (options?.walMode ?? true)) {
-    db.pragma('journal_mode = WAL');
-    db.pragma('synchronous = NORMAL');
-    db.pragma('busy_timeout = 5000');
-  }
-
-  return db;
-}
-
-/**
- * Execute a statement that doesn't return rows (INSERT, UPDATE, DELETE)
- */
-export function sqliteRun(
-  db: SQLiteDatabase,
-  sql: string,
-  params: unknown[] = []
-): Database.RunResult {
-  const stmt = db.prepare(sql);
-  return stmt.run(...params);
-}
-
-/**
- * Execute a query and return all rows
- */
-export function sqliteAll<T = Record<string, unknown>>(
-  db: SQLiteDatabase,
-  sql: string,
-  params: unknown[] = []
-): T[] {
-  const stmt = db.prepare(sql);
-  return stmt.all(...params) as T[];
-}
-
-/**
- * Execute a query and return first row
- */
-export function sqliteGet<T = Record<string, unknown>>(
-  db: SQLiteDatabase,
-  sql: string,
-  params: unknown[] = []
-): T | undefined {
-  const stmt = db.prepare(sql);
-  return stmt.get(...params) as T | undefined;
-}
-
-/**
- * Execute multiple statements (for schema creation)
- */
-export function sqliteExec(db: SQLiteDatabase, sql: string): void {
-  db.exec(sql);
-}
-
-/**
- * Close database connection
- */
-export function sqliteClose(db: SQLiteDatabase): void {
-  db.close();
-}
-
-/**
- * Run multiple statements in a transaction
- */
-export function sqliteTransaction<T>(
-  db: SQLiteDatabase,
-  fn: () => T
-): T {
-  return db.transaction(fn)();
-}
-
-/**
- * Safely converts a value to a Date object
- */
-export function toDateFromSQLite(value: unknown): Date {
-  if (value instanceof Date) return value;
-  if (typeof value === 'string') return new Date(value);
-  if (typeof value === 'number') return new Date(value);
-  return new Date(String(value));
-}
-
-/**
- * Convert Date to ISO string for SQLite storage
- */
-export function toSQLiteTimestamp(date: Date): string {
-  return date.toISOString();
-}

package/src/core/sync-worker.ts

@@ -1,228 +0,0 @@
-/**
- * Sync Worker - SQLite to DuckDB synchronization
- * Runs periodically to sync primary store (SQLite) to analytics store (DuckDB)
- */
-
-import { SQLiteEventStore } from './sqlite-event-store.js';
-import { EventStore } from './event-store.js';
-import { MemoryEvent } from './types.js';
-
-export interface SyncWorkerConfig {
-  intervalMs: number;      // Sync interval (default: 30000 = 30 seconds)
-  batchSize: number;       // Events per batch (default: 500)
-  maxRetries: number;      // Max retries on failure (default: 3)
-  retryDelayMs: number;    // Delay between retries (default: 5000)
-}
-
-const DEFAULT_CONFIG: SyncWorkerConfig = {
-  intervalMs: 30000,
-  batchSize: 500,
-  maxRetries: 3,
-  retryDelayMs: 5000
-};
-
-export interface SyncStats {
-  lastSyncAt: Date | null;
-  eventsSynced: number;
-  sessionsSynced: number;
-  errors: number;
-  status: 'idle' | 'syncing' | 'error' | 'stopped';
-}
-
-export class SyncWorker {
-  private config: SyncWorkerConfig;
-  private intervalHandle: NodeJS.Timeout | null = null;
-  private running = false;
-  private stats: SyncStats = {
-    lastSyncAt: null,
-    eventsSynced: 0,
-    sessionsSynced: 0,
-    errors: 0,
-    status: 'idle'
-  };
-
-  constructor(
-    private sqliteStore: SQLiteEventStore,
-    private duckdbStore: EventStore,
-    config?: Partial<SyncWorkerConfig>
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  /**
-   * Start the sync worker
-   */
-  start(): void {
-    if (this.running) return;
-
-    this.running = true;
-    this.stats.status = 'idle';
-
-    // Run initial sync
-    this.syncNow().catch(err => {
-      console.error('[SyncWorker] Initial sync failed:', err);
-    });
-
-    // Schedule periodic sync
-    this.intervalHandle = setInterval(() => {
-      this.syncNow().catch(err => {
-        console.error('[SyncWorker] Periodic sync failed:', err);
-      });
-    }, this.config.intervalMs);
-  }
-
-  /**
-   * Stop the sync worker
-   */
-  stop(): void {
-    this.running = false;
-    this.stats.status = 'stopped';
-
-    if (this.intervalHandle) {
-      clearInterval(this.intervalHandle);
-      this.intervalHandle = null;
-    }
-  }
-
-  /**
-   * Trigger immediate sync
-   */
-  async syncNow(): Promise<void> {
-    if (this.stats.status === 'syncing') {
-      return; // Already syncing
-    }
-
-    this.stats.status = 'syncing';
-
-    try {
-      await this.syncEvents();
-      await this.syncSessions();
-      this.stats.lastSyncAt = new Date();
-      this.stats.status = 'idle';
-    } catch (error) {
-      this.stats.errors++;
-      this.stats.status = 'error';
-      throw error;
-    }
-  }
-
-  /**
-   * Sync events from SQLite to DuckDB
-   */
-  private async syncEvents(): Promise<void> {
-    const targetName = 'duckdb_analytics';
-
-    // Get last sync position from SQLite
-    const position = await this.sqliteStore.getSyncPosition(targetName);
-    const lastTimestamp = position.lastTimestamp || '1970-01-01T00:00:00.000Z';
-
-    let hasMore = true;
-    let totalSynced = 0;
-
-    while (hasMore) {
-      // Get batch of events since last sync
-      const events = await this.sqliteStore.getEventsSince(lastTimestamp, this.config.batchSize);
-
-      if (events.length === 0) {
-        hasMore = false;
-        break;
-      }
-
-      // Insert into DuckDB with retry
-      await this.retryWithBackoff(async () => {
-        for (const event of events) {
-          await this.insertEventToDuckDB(event);
-        }
-      });
-
-      totalSynced += events.length;
-
-      // Update sync position
-      const lastEvent = events[events.length - 1];
-      await this.sqliteStore.updateSyncPosition(
-        targetName,
-        lastEvent.id,
-        lastEvent.timestamp.toISOString()
-      );
-
-      // Check if we got a full batch (more to sync)
-      hasMore = events.length === this.config.batchSize;
-    }
-
-    this.stats.eventsSynced += totalSynced;
-  }
-
-  /**
-   * Sync sessions from SQLite to DuckDB
-   */
-  private async syncSessions(): Promise<void> {
-    // Get all sessions from SQLite
-    const sessions = await this.sqliteStore.getAllSessions();
-
-    // Upsert each session to DuckDB
-    for (const session of sessions) {
-      await this.retryWithBackoff(async () => {
-        await this.duckdbStore.upsertSession(session);
-      });
-    }
-
-    this.stats.sessionsSynced = sessions.length;
-  }
-
-  /**
-   * Insert a single event into DuckDB
-   */
-  private async insertEventToDuckDB(event: MemoryEvent): Promise<void> {
-    // Use append which handles deduplication
-    await this.duckdbStore.append({
-      eventType: event.eventType,
-      sessionId: event.sessionId,
-      timestamp: event.timestamp,
-      content: event.content,
-      metadata: event.metadata
-    });
-  }
-
-  /**
-   * Retry operation with exponential backoff
-   */
-  private async retryWithBackoff<T>(fn: () => Promise<T>): Promise<T> {
-    let lastError: Error | null = null;
-
-    for (let attempt = 0; attempt < this.config.maxRetries; attempt++) {
-      try {
-        return await fn();
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-
-        if (attempt < this.config.maxRetries - 1) {
-          const delay = this.config.retryDelayMs * Math.pow(2, attempt);
-          await this.sleep(delay);
-        }
-      }
-    }
-
-    throw lastError;
-  }
-
-  /**
-   * Sleep utility
-   */
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Get sync statistics
-   */
-  getStats(): SyncStats {
-    return { ...this.stats };
-  }
-
-  /**
-   * Check if worker is running
-   */
-  isRunning(): boolean {
-    return this.running;
-  }
-}

package/src/core/tag-taxonomy.ts

@@ -1,51 +0,0 @@
-export const TAG_NAMESPACES = {
-  SYSTEM: 'sys:',
-  QUALITY: 'q:',
-  PROJECT: 'proj:',
-  TOPIC: 'topic:',
-  TEMPORAL: 't:',
-  USER: 'user:',
-  AGENT: 'agent:'
-} as const;
-
-export const VALID_TAG_NAMESPACES = new Set<string>(Object.values(TAG_NAMESPACES));
-
-export function parseTag(tag: string): { namespace?: string; value: string } {
-  const value = (tag || '').trim();
-  const idx = value.indexOf(':');
-  if (idx <= 0) return { value };
-
-  const namespace = `${value.slice(0, idx)}:`;
-  const tagValue = value.slice(idx + 1);
-  if (!tagValue) return { value };
-
-  return { namespace, value: tagValue };
-}
-
-export function validateTag(tag: string): boolean {
-  const normalized = (tag || '').trim();
-  if (!normalized) return false;
-
-  const { namespace } = parseTag(normalized);
-  if (!namespace) return true; // backward compatibility for legacy tags
-  return VALID_TAG_NAMESPACES.has(namespace);
-}
-
-export function withNamespace(value: string, namespace: string): string {
-  const clean = parseTag(value).value.trim();
-  return `${namespace}${clean}`;
-}
-
-export function normalizeTags(tags: unknown): string[] {
-  if (!Array.isArray(tags)) return [];
-
-  const dedup = new Set<string>();
-  for (const item of tags) {
-    if (typeof item !== 'string') continue;
-    const normalized = item.trim();
-    if (!validateTag(normalized)) continue;
-    dedup.add(normalized);
-  }
-
-  return [...dedup];
-}