claude-memory-layer 1.0.31 → 1.0.33

package/src/core/graduation-worker.ts

@@ -1,171 +0,0 @@
-/**
- * Graduation Worker
- * Periodically evaluates memory events for promotion to higher levels
- * L0 → L1 → L2 → L3 → L4 based on access patterns and confidence
- */
-
-import type { MemoryLevel } from './types.js';
-import { EventStore } from './event-store.js';
-import { GraduationPipeline } from './graduation.js';
-
-export interface GraduationWorkerConfig {
-  /** How often to run graduation evaluation (ms) */
-  evaluationIntervalMs: number;
-  /** Batch size for graduation evaluation */
-  batchSize: number;
-  /** Minimum time between evaluations of the same event (ms) */
-  cooldownMs: number;
-}
-
-const DEFAULT_CONFIG: GraduationWorkerConfig = {
-  evaluationIntervalMs: 300000, // 5 minutes
-  batchSize: 50,
-  cooldownMs: 3600000 // 1 hour cooldown between evaluations
-};
-
-export class GraduationWorker {
-  private running = false;
-  private timeout: NodeJS.Timeout | null = null;
-  private lastEvaluated: Map<string, number> = new Map();
-
-  constructor(
-    private eventStore: EventStore,
-    private graduation: GraduationPipeline,
-    private config: GraduationWorkerConfig = DEFAULT_CONFIG
-  ) {}
-
-  /**
-   * Start the graduation worker
-   */
-  start(): void {
-    if (this.running) return;
-    this.running = true;
-    this.scheduleNext();
-  }
-
-  /**
-   * Stop the graduation worker
-   */
-  stop(): void {
-    this.running = false;
-    if (this.timeout) {
-      clearTimeout(this.timeout);
-      this.timeout = null;
-    }
-  }
-
-  /**
-   * Check if currently running
-   */
-  isRunning(): boolean {
-    return this.running;
-  }
-
-  /**
-   * Force a graduation evaluation run
-   */
-  async forceRun(): Promise<GraduationRunResult> {
-    return await this.runGraduation();
-  }
-
-  /**
-   * Schedule the next graduation check
-   */
-  private scheduleNext(): void {
-    if (!this.running) return;
-
-    this.timeout = setTimeout(
-      () => this.run(),
-      this.config.evaluationIntervalMs
-    );
-  }
-
-  /**
-   * Run graduation evaluation
-   */
-  private async run(): Promise<void> {
-    if (!this.running) return;
-
-    try {
-      await this.runGraduation();
-    } catch (error) {
-      console.error('Graduation error:', error);
-    }
-
-    this.scheduleNext();
-  }
-
-  /**
-   * Perform graduation evaluation across all levels
-   */
-  private async runGraduation(): Promise<GraduationRunResult> {
-    const result: GraduationRunResult = {
-      evaluated: 0,
-      graduated: 0,
-      byLevel: {}
-    };
-
-    const levels: MemoryLevel[] = ['L0', 'L1', 'L2', 'L3'];
-    const now = Date.now();
-
-    for (const level of levels) {
-      const events = await this.eventStore.getEventsByLevel(level, {
-        limit: this.config.batchSize
-      });
-
-      let levelGraduated = 0;
-
-      for (const event of events) {
-        // Check cooldown
-        const lastEval = this.lastEvaluated.get(event.id);
-        if (lastEval && (now - lastEval) < this.config.cooldownMs) {
-          continue;
-        }
-
-        result.evaluated++;
-        this.lastEvaluated.set(event.id, now);
-
-        const gradResult = await this.graduation.evaluateGraduation(event.id, level);
-
-        if (gradResult.success) {
-          result.graduated++;
-          levelGraduated++;
-        }
-      }
-
-      if (levelGraduated > 0) {
-        result.byLevel[level] = levelGraduated;
-      }
-    }
-
-    // Clean up old cooldown entries (keep last 1000)
-    if (this.lastEvaluated.size > 1000) {
-      const entries = Array.from(this.lastEvaluated.entries());
-      entries.sort((a, b) => b[1] - a[1]);
-      this.lastEvaluated = new Map(entries.slice(0, 1000));
-    }
-
-    return result;
-  }
-}
-
-export interface GraduationRunResult {
-  evaluated: number;
-  graduated: number;
-  byLevel: Record<string, number>;
-}
-
-/**
- * Create a Graduation Worker instance
- */
-export function createGraduationWorker(
-  eventStore: EventStore,
-  graduation: GraduationPipeline,
-  config?: Partial<GraduationWorkerConfig>
-): GraduationWorker {
-  return new GraduationWorker(
-    eventStore,
-    graduation,
-    { ...DEFAULT_CONFIG, ...config }
-  );
-}

package/src/core/graduation.ts

@@ -1,377 +0,0 @@
-/**
- * Memory Graduation Pipeline - AXIOMMIND L0→L1→L2→L3→L4
- *
- * L0: EventStore (raw events, append-only)
- * L1: Structured JSON (session summaries, patterns)
- * L2: Type Candidates (Idris2-inspired, validated schemas)
- * L3: Verified Knowledge (cross-session validated)
- * L4: Active/Searchable (indexed, readily available)
- */
-
-import { EventStore } from './event-store.js';
-import type {
-  MemoryEvent,
-  MemoryLevel,
-  GraduationResult,
-  Insight
-} from './types.js';
-
-export interface GraduationCriteria {
-  minAccessCount: number;
-  minConfidence: number;
-  minCrossSessionRefs: number;
-  maxAgeDays: number;
-}
-
-export interface LevelCriteria {
-  L0toL1: GraduationCriteria;
-  L1toL2: GraduationCriteria;
-  L2toL3: GraduationCriteria;
-  L3toL4: GraduationCriteria;
-}
-
-const DEFAULT_CRITERIA: LevelCriteria = {
-  L0toL1: {
-    minAccessCount: 1,
-    minConfidence: 0.5,
-    minCrossSessionRefs: 0,
-    maxAgeDays: 30
-  },
-  L1toL2: {
-    minAccessCount: 3,
-    minConfidence: 0.7,
-    minCrossSessionRefs: 1,
-    maxAgeDays: 60
-  },
-  L2toL3: {
-    minAccessCount: 5,
-    minConfidence: 0.85,
-    minCrossSessionRefs: 2,
-    maxAgeDays: 90
-  },
-  L3toL4: {
-    minAccessCount: 10,
-    minConfidence: 0.92,
-    minCrossSessionRefs: 3,
-    maxAgeDays: 180
-  }
-};
-
-export interface EventMetrics {
-  eventId: string;
-  accessCount: number;
-  lastAccessed: Date;
-  crossSessionRefs: number;
-  confidence: number;
-}
-
-export class GraduationPipeline {
-  private readonly eventStore: EventStore;
-  private readonly criteria: LevelCriteria;
-  private readonly metrics: Map<string, EventMetrics> = new Map();
-
-  constructor(
-    eventStore: EventStore,
-    criteria: Partial<LevelCriteria> = {}
-  ) {
-    this.eventStore = eventStore;
-    this.criteria = {
-      L0toL1: { ...DEFAULT_CRITERIA.L0toL1, ...criteria.L0toL1 },
-      L1toL2: { ...DEFAULT_CRITERIA.L1toL2, ...criteria.L1toL2 },
-      L2toL3: { ...DEFAULT_CRITERIA.L2toL3, ...criteria.L2toL3 },
-      L3toL4: { ...DEFAULT_CRITERIA.L3toL4, ...criteria.L3toL4 }
-    };
-  }
-
-  // Track which sessions have accessed each event
-  private readonly sessionAccesses: Map<string, Set<string>> = new Map();
-
-  /**
-   * Record an access to an event (used for graduation scoring)
-   */
-  recordAccess(eventId: string, fromSessionId: string, confidence: number = 1.0): void {
-    const existing = this.metrics.get(eventId);
-
-    // Track sessions that have accessed this event
-    if (!this.sessionAccesses.has(eventId)) {
-      this.sessionAccesses.set(eventId, new Set());
-    }
-    const sessions = this.sessionAccesses.get(eventId)!;
-    const isNewSession = !sessions.has(fromSessionId);
-    sessions.add(fromSessionId);
-
-    if (existing) {
-      existing.accessCount++;
-      existing.lastAccessed = new Date();
-      existing.confidence = Math.max(existing.confidence, confidence);
-      // Update cross-session references count
-      if (isNewSession && sessions.size > 1) {
-        existing.crossSessionRefs = sessions.size - 1;
-      }
-    } else {
-      this.metrics.set(eventId, {
-        eventId,
-        accessCount: 1,
-        lastAccessed: new Date(),
-        crossSessionRefs: 0,
-        confidence
-      });
-    }
-  }
-
-  /**
-   * Evaluate if an event should graduate to the next level
-   */
-  async evaluateGraduation(eventId: string, currentLevel: MemoryLevel): Promise<GraduationResult> {
-    const metrics = this.metrics.get(eventId);
-
-    if (!metrics) {
-      return {
-        eventId,
-        fromLevel: currentLevel,
-        toLevel: currentLevel,
-        success: false,
-        reason: 'No metrics available for event'
-      };
-    }
-
-    const nextLevel = this.getNextLevel(currentLevel);
-    if (!nextLevel) {
-      return {
-        eventId,
-        fromLevel: currentLevel,
-        toLevel: currentLevel,
-        success: false,
-        reason: 'Already at maximum level'
-      };
-    }
-
-    const criteria = this.getCriteria(currentLevel, nextLevel);
-    const evaluation = this.checkCriteria(metrics, criteria);
-
-    if (evaluation.passed) {
-      // Update level in event store
-      await this.eventStore.updateMemoryLevel(eventId, nextLevel);
-
-      return {
-        eventId,
-        fromLevel: currentLevel,
-        toLevel: nextLevel,
-        success: true
-      };
-    }
-
-    return {
-      eventId,
-      fromLevel: currentLevel,
-      toLevel: currentLevel,
-      success: false,
-      reason: evaluation.reason
-    };
-  }
-
-  /**
-   * Run graduation evaluation for all events at a given level
-   */
-  async graduateBatch(level: MemoryLevel): Promise<GraduationResult[]> {
-    const results: GraduationResult[] = [];
-
-    for (const eventId of this.metrics.keys()) {
-      const result = await this.evaluateGraduation(eventId, level);
-      results.push(result);
-    }
-
-    return results;
-  }
-
-  /**
-   * Extract insights from graduated events (L1+)
-   */
-  extractInsights(events: MemoryEvent[]): Insight[] {
-    const insights: Insight[] = [];
-
-    // Pattern detection: Look for repeated themes
-    const patterns = this.detectPatterns(events);
-    for (const pattern of patterns) {
-      insights.push({
-        id: crypto.randomUUID(),
-        insightType: 'pattern',
-        content: pattern.description,
-        canonicalKey: pattern.key,
-        confidence: pattern.confidence,
-        sourceEvents: pattern.eventIds,
-        createdAt: new Date(),
-        lastUpdated: new Date()
-      });
-    }
-
-    // Preference detection: Look for user preferences
-    const preferences = this.detectPreferences(events);
-    for (const pref of preferences) {
-      insights.push({
-        id: crypto.randomUUID(),
-        insightType: 'preference',
-        content: pref.description,
-        canonicalKey: pref.key,
-        confidence: pref.confidence,
-        sourceEvents: pref.eventIds,
-        createdAt: new Date(),
-        lastUpdated: new Date()
-      });
-    }
-
-    return insights;
-  }
-
-  /**
-   * Get the next level in the graduation pipeline
-   */
-  private getNextLevel(current: MemoryLevel): MemoryLevel | null {
-    const levels: MemoryLevel[] = ['L0', 'L1', 'L2', 'L3', 'L4'];
-    const currentIndex = levels.indexOf(current);
-
-    if (currentIndex === -1 || currentIndex >= levels.length - 1) {
-      return null;
-    }
-
-    return levels[currentIndex + 1];
-  }
-
-  /**
-   * Get criteria for level transition
-   */
-  private getCriteria(from: MemoryLevel, to: MemoryLevel): GraduationCriteria {
-    const key = `${from}to${to}` as keyof LevelCriteria;
-    return this.criteria[key] || DEFAULT_CRITERIA.L0toL1;
-  }
-
-  /**
-   * Check if metrics meet criteria
-   */
-  private checkCriteria(
-    metrics: EventMetrics,
-    criteria: GraduationCriteria
-  ): { passed: boolean; reason?: string } {
-    if (metrics.accessCount < criteria.minAccessCount) {
-      return {
-        passed: false,
-        reason: `Access count ${metrics.accessCount} < ${criteria.minAccessCount}`
-      };
-    }
-
-    if (metrics.confidence < criteria.minConfidence) {
-      return {
-        passed: false,
-        reason: `Confidence ${metrics.confidence} < ${criteria.minConfidence}`
-      };
-    }
-
-    if (metrics.crossSessionRefs < criteria.minCrossSessionRefs) {
-      return {
-        passed: false,
-        reason: `Cross-session refs ${metrics.crossSessionRefs} < ${criteria.minCrossSessionRefs}`
-      };
-    }
-
-    const ageDays = (Date.now() - metrics.lastAccessed.getTime()) / (1000 * 60 * 60 * 24);
-    if (ageDays > criteria.maxAgeDays) {
-      return {
-        passed: false,
-        reason: `Event too old: ${ageDays.toFixed(1)} days > ${criteria.maxAgeDays}`
-      };
-    }
-
-    return { passed: true };
-  }
-
-  /**
-   * Detect patterns in events
-   */
-  private detectPatterns(events: MemoryEvent[]): Array<{
-    key: string;
-    description: string;
-    confidence: number;
-    eventIds: string[];
-  }> {
-    // Simple pattern detection: group by canonical key and look for repeats
-    const keyGroups = new Map<string, MemoryEvent[]>();
-
-    for (const event of events) {
-      const existing = keyGroups.get(event.canonicalKey) || [];
-      existing.push(event);
-      keyGroups.set(event.canonicalKey, existing);
-    }
-
-    const patterns: Array<{
-      key: string;
-      description: string;
-      confidence: number;
-      eventIds: string[];
-    }> = [];
-
-    for (const [key, groupEvents] of keyGroups) {
-      if (groupEvents.length >= 2) {
-        patterns.push({
-          key,
-          description: `Repeated topic: ${key.slice(0, 50)}`,
-          confidence: Math.min(1.0, groupEvents.length / 5),
-          eventIds: groupEvents.map(e => e.id)
-        });
-      }
-    }
-
-    return patterns;
-  }
-
-  /**
-   * Detect user preferences from events
-   */
-  private detectPreferences(events: MemoryEvent[]): Array<{
-    key: string;
-    description: string;
-    confidence: number;
-    eventIds: string[];
-  }> {
-    // Simple preference detection: look for keywords
-    const preferenceKeywords = ['prefer', 'like', 'want', 'always', 'never', 'favorite'];
-    const preferences: Array<{
-      key: string;
-      description: string;
-      confidence: number;
-      eventIds: string[];
-    }> = [];
-
-    for (const event of events) {
-      if (event.eventType !== 'user_prompt') continue;
-
-      const lowerContent = event.content.toLowerCase();
-      for (const keyword of preferenceKeywords) {
-        if (lowerContent.includes(keyword)) {
-          preferences.push({
-            key: `preference_${keyword}_${event.id.slice(0, 8)}`,
-            description: `User preference: ${event.content.slice(0, 100)}`,
-            confidence: 0.7,
-            eventIds: [event.id]
-          });
-          break;
-        }
-      }
-    }
-
-    return preferences;
-  }
-
-  /**
-   * Get graduation statistics
-   */
-  async getStats(): Promise<{ level: string; count: number }[]> {
-    return this.eventStore.getLevelStats();
-  }
-}
-
-/**
- * Create graduation pipeline with default settings
- */
-export function createGraduationPipeline(eventStore: EventStore): GraduationPipeline {
-  return new GraduationPipeline(eventStore);
-}

package/src/core/index.ts

@@ -1,64 +0,0 @@
-/**
- * Core module exports
- * AXIOMMIND Memory Graduation Pipeline
- */
-
-// Types
-export * from './types.js';
-export * from './model/raw-event.js';
-export * from './model/memory-fact.js';
-export * from './model/memory-summary.js';
-export * from './model/memory-rule.js';
-export * from './model/retrieval-result.js';
-
-// Registry
-export * from './registry/project-path.js';
-export * from './registry/session-registry.js';
-
-// Engine
-export * from './engine/index.js';
-
-// Derivation
-export * from './derive/index.js';
-
-// Canonical Key (identity)
-export * from './canonical-key.js';
-
-// Storage
-export * from './event-store.js';
-export * from './sqlite-wrapper.js';
-export * from './sqlite-event-store.js';
-export * from './sync-worker.js';
-export * from './mongo-sync-worker.js';
-export * from './entity-repo.js';
-export * from './edge-repo.js';
-
-// Vector
-export * from './vector-store.js';
-export * from './embedder.js';
-export * from './vector-worker.js';
-export * from './vector-outbox.js';
-
-// Product validation
-export * from './product-validation-matrix.js';
-
-// Matching & Alignment
-export * from './matcher.js';
-export * from './evidence-aligner.js';
-
-// Retrieval & Graduation
-export * from './retriever.js';
-export * from './graduation.js';
-export * from './graduation-worker.js';
-
-// Task Entity System
-export * from './task/index.js';
-
-// Shared Store (Cross-Project Knowledge)
-export * from './shared-event-store.js';
-export * from './shared-store.js';
-export * from './shared-vector-store.js';
-export * from './shared-promoter.js';
-
-// External read-only market context
-export * from './external-market-context.js';

package/src/core/ingest-interceptor.ts

@@ -1,80 +0,0 @@
-import type { MemoryEventInput } from './types.js';
-
-export type IngestStage = 'before' | 'after' | 'error';
-
-export interface IngestContext {
-  stage: IngestStage;
-  operation: 'user_prompt' | 'agent_response' | 'session_summary' | 'tool_observation';
-  sessionId: string;
-  event: MemoryEventInput;
-  error?: Error;
-}
-
-export type IngestInterceptor = (context: IngestContext) => Promise<void> | void;
-
-export class IngestInterceptorRegistry {
-  private before: IngestInterceptor[] = [];
-  private after: IngestInterceptor[] = [];
-  private onError: IngestInterceptor[] = [];
-
-  registerBefore(interceptor: IngestInterceptor): () => void {
-    this.before.push(interceptor);
-    return () => {
-      this.before = this.before.filter((i) => i !== interceptor);
-    };
-  }
-
-  registerAfter(interceptor: IngestInterceptor): () => void {
-    this.after.push(interceptor);
-    return () => {
-      this.after = this.after.filter((i) => i !== interceptor);
-    };
-  }
-
-  registerOnError(interceptor: IngestInterceptor): () => void {
-    this.onError.push(interceptor);
-    return () => {
-      this.onError = this.onError.filter((i) => i !== interceptor);
-    };
-  }
-
-  async run(stage: IngestStage, context: Omit<IngestContext, 'stage'>): Promise<void> {
-    const interceptors = stage === 'before'
-      ? this.before
-      : stage === 'after'
-      ? this.after
-      : this.onError;
-
-    for (const interceptor of interceptors) {
-      await interceptor({ ...context, stage });
-    }
-  }
-}
-
-export function mergeHierarchicalMetadata(
-  base: Record<string, unknown> | undefined,
-  patch: Record<string, unknown> | undefined
-): Record<string, unknown> | undefined {
-  if (!base && !patch) return undefined;
-  if (!base) return patch;
-  if (!patch) return base;
-
-  const result: Record<string, unknown> = { ...base };
-
-  for (const [key, value] of Object.entries(patch)) {
-    const current = result[key];
-    if (
-      typeof current === 'object' && current !== null && !Array.isArray(current) &&
-      typeof value === 'object' && value !== null && !Array.isArray(value)
-    ) {
-      result[key] = mergeHierarchicalMetadata(
-        current as Record<string, unknown>,
-        value as Record<string, unknown>
-      );
-    } else {
-      result[key] = value;
-    }
-  }
-
-  return result;
-}