claude-memory-layer 1.0.0

package/src/core/continuity-manager.ts

@@ -0,0 +1,336 @@
+/**
+ * Continuity Manager
+ * Tracks and calculates context continuity between interactions
+ * Biomimetic: Simulates context-dependent memory retrieval
+ */
+
+import { randomUUID } from 'crypto';
+import { Database } from 'duckdb';
+import type {
+  EndlessModeConfig,
+  ContextSnapshot,
+  ContinuityScore,
+  TransitionType,
+  ContinuityLog
+} from './types.js';
+import { EventStore } from './event-store.js';
+
+export class ContinuityManager {
+  private lastContext: ContextSnapshot | null = null;
+
+  constructor(
+    private eventStore: EventStore,
+    private config: EndlessModeConfig
+  ) {}
+
+  private get db(): Database {
+    return this.eventStore.getDatabase();
+  }
+
+  /**
+   * Calculate continuity score between current and previous context
+   */
+  async calculateScore(
+    currentContext: ContextSnapshot,
+    previousContext?: ContextSnapshot
+  ): Promise<ContinuityScore> {
+    const prev = previousContext || this.lastContext;
+
+    if (!prev) {
+      // No previous context - this is a fresh start
+      this.lastContext = currentContext;
+      return { score: 0.5, transitionType: 'break' };
+    }
+
+    let score = 0;
+
+    // Topic continuity (30%)
+    const topicOverlap = this.calculateOverlap(
+      currentContext.topics,
+      prev.topics
+    );
+    score += topicOverlap * 0.3;
+
+    // File continuity (20%)
+    const fileOverlap = this.calculateOverlap(
+      currentContext.files,
+      prev.files
+    );
+    score += fileOverlap * 0.2;
+
+    // Time proximity (30%)
+    const timeDiff = currentContext.timestamp - prev.timestamp;
+    const decayHours = this.config.continuity.topicDecayHours;
+    const timeScore = Math.exp(-timeDiff / (decayHours * 3600000));
+    score += timeScore * 0.3;
+
+    // Entity continuity (20%)
+    const entityOverlap = this.calculateOverlap(
+      currentContext.entities,
+      prev.entities
+    );
+    score += entityOverlap * 0.2;
+
+    // Determine transition type
+    const transitionType = this.determineTransitionType(score);
+
+    // Log the transition
+    await this.logTransition(currentContext, prev, score, transitionType);
+
+    // Update last context
+    this.lastContext = currentContext;
+
+    return { score, transitionType };
+  }
+
+  /**
+   * Create a context snapshot from current state
+   */
+  createSnapshot(
+    id: string,
+    content: string,
+    metadata?: {
+      files?: string[];
+      entities?: string[];
+    }
+  ): ContextSnapshot {
+    return {
+      id,
+      timestamp: Date.now(),
+      topics: this.extractTopics(content),
+      files: metadata?.files || this.extractFiles(content),
+      entities: metadata?.entities || this.extractEntities(content)
+    };
+  }
+
+  /**
+   * Get recent continuity logs
+   */
+  async getRecentLogs(limit: number = 10): Promise<ContinuityLog[]> {
+    const rows = await this.db.all<Array<Record<string, unknown>>>(
+      `SELECT * FROM continuity_log
+       ORDER BY created_at DESC
+       LIMIT ?`,
+      [limit]
+    );
+
+    return rows.map(row => ({
+      logId: row.log_id as string,
+      fromContextId: row.from_context_id as string | undefined,
+      toContextId: row.to_context_id as string | undefined,
+      continuityScore: row.continuity_score as number,
+      transitionType: row.transition_type as TransitionType,
+      createdAt: new Date(row.created_at as string)
+    }));
+  }
+
+  /**
+   * Get average continuity score over time period
+   */
+  async getAverageScore(hours: number = 1): Promise<number> {
+    const result = await this.db.all<Array<{ avg_score: number | null }>>(
+      `SELECT AVG(continuity_score) as avg_score
+       FROM continuity_log
+       WHERE created_at > datetime('now', '-${hours} hours')`
+    );
+
+    return result[0]?.avg_score ?? 0.5;
+  }
+
+  /**
+   * Get transition type distribution
+   */
+  async getTransitionStats(hours: number = 24): Promise<Record<TransitionType, number>> {
+    const rows = await this.db.all<Array<{ transition_type: string; count: number }>>(
+      `SELECT transition_type, COUNT(*) as count
+       FROM continuity_log
+       WHERE created_at > datetime('now', '-${hours} hours')
+       GROUP BY transition_type`
+    );
+
+    const stats: Record<TransitionType, number> = {
+      seamless: 0,
+      topic_shift: 0,
+      break: 0
+    };
+
+    for (const row of rows) {
+      stats[row.transition_type as TransitionType] = row.count;
+    }
+
+    return stats;
+  }
+
+  /**
+   * Clear old continuity logs
+   */
+  async cleanup(olderThanDays: number = 7): Promise<number> {
+    const result = await this.db.all<Array<{ changes: number }>>(
+      `DELETE FROM continuity_log
+       WHERE created_at < datetime('now', '-${olderThanDays} days')
+       RETURNING COUNT(*) as changes`
+    );
+
+    return result[0]?.changes || 0;
+  }
+
+  /**
+   * Calculate overlap between two arrays
+   */
+  private calculateOverlap(a: string[], b: string[]): number {
+    if (a.length === 0 || b.length === 0) return 0;
+
+    const setA = new Set(a.map(s => s.toLowerCase()));
+    const setB = new Set(b.map(s => s.toLowerCase()));
+
+    const intersection = [...setA].filter(x => setB.has(x));
+    const union = new Set([...setA, ...setB]);
+
+    return intersection.length / union.size; // Jaccard similarity
+  }
+
+  /**
+   * Determine transition type based on score
+   */
+  private determineTransitionType(score: number): TransitionType {
+    if (score >= this.config.continuity.minScoreForSeamless) {
+      return 'seamless';
+    } else if (score >= 0.4) {
+      return 'topic_shift';
+    } else {
+      return 'break';
+    }
+  }
+
+  /**
+   * Log a context transition
+   */
+  private async logTransition(
+    current: ContextSnapshot,
+    previous: ContextSnapshot,
+    score: number,
+    type: TransitionType
+  ): Promise<void> {
+    await this.db.run(
+      `INSERT INTO continuity_log
+        (log_id, from_context_id, to_context_id, continuity_score, transition_type, created_at)
+       VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)`,
+      [randomUUID(), previous.id, current.id, score, type]
+    );
+  }
+
+  /**
+   * Extract topics from content
+   */
+  private extractTopics(content: string): string[] {
+    const topics: string[] = [];
+    const contentLower = content.toLowerCase();
+
+    // Programming language keywords
+    const langPatterns = [
+      { pattern: /typescript|\.ts\b/i, topic: 'typescript' },
+      { pattern: /javascript|\.js\b/i, topic: 'javascript' },
+      { pattern: /python|\.py\b/i, topic: 'python' },
+      { pattern: /rust|\.rs\b/i, topic: 'rust' },
+      { pattern: /go\b|golang/i, topic: 'go' }
+    ];
+
+    for (const { pattern, topic } of langPatterns) {
+      if (pattern.test(content)) {
+        topics.push(topic);
+      }
+    }
+
+    // Common development topics
+    const devTopics = [
+      'api', 'database', 'test', 'bug', 'feature', 'refactor',
+      'component', 'function', 'class', 'module', 'hook',
+      'deploy', 'build', 'config', 'docker', 'git'
+    ];
+
+    for (const topic of devTopics) {
+      if (contentLower.includes(topic)) {
+        topics.push(topic);
+      }
+    }
+
+    return [...new Set(topics)].slice(0, 10);
+  }
+
+  /**
+   * Extract file paths from content
+   */
+  private extractFiles(content: string): string[] {
+    const filePatterns = [
+      /(?:^|\s)([a-zA-Z0-9_\-./]+\.[a-zA-Z0-9]+)(?:\s|$|:)/gm,
+      /['"](\.?\/[^'"]+\.[a-zA-Z0-9]+)['"]/g,
+      /file[:\s]+([^\s,]+)/gi
+    ];
+
+    const files = new Set<string>();
+
+    for (const pattern of filePatterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const file = match[1];
+        if (file && file.length > 3 && file.length < 100) {
+          // Filter out common non-file patterns
+          if (!file.match(/^(https?:|mailto:|ftp:)/i)) {
+            files.add(file);
+          }
+        }
+      }
+    }
+
+    return Array.from(files).slice(0, 10);
+  }
+
+  /**
+   * Extract entity names from content (functions, classes, variables)
+   */
+  private extractEntities(content: string): string[] {
+    const entities = new Set<string>();
+
+    const entityPatterns = [
+      /\b(function|const|let|var|class|interface|type)\s+([a-zA-Z_][a-zA-Z0-9_]*)/g,
+      /\b([A-Z][a-zA-Z0-9_]*(?:Component|Service|Store|Manager|Handler|Factory|Provider))\b/g,
+      /\b(use[A-Z][a-zA-Z0-9_]*)\b/g // React hooks
+    ];
+
+    for (const pattern of entityPatterns) {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const entity = match[2] || match[1];
+        if (entity && entity.length > 2) {
+          entities.add(entity);
+        }
+      }
+    }
+
+    return Array.from(entities).slice(0, 20);
+  }
+
+  /**
+   * Reset the last context (for testing or manual reset)
+   */
+  resetLastContext(): void {
+    this.lastContext = null;
+  }
+
+  /**
+   * Get the last context snapshot
+   */
+  getLastContext(): ContextSnapshot | null {
+    return this.lastContext;
+  }
+}
+
+/**
+ * Create a Continuity Manager instance
+ */
+export function createContinuityManager(
+  eventStore: EventStore,
+  config: EndlessModeConfig
+): ContinuityManager {
+  return new ContinuityManager(eventStore, config);
+}

package/src/core/edge-repo.ts

@@ -0,0 +1,324 @@
+/**
+ * Edge Repository - CRUD operations for entity/entry relationships
+ * AXIOMMIND Entity-Edge Model
+ */
+
+import { Database } from 'duckdb';
+import { randomUUID } from 'crypto';
+import type { Edge, NodeType, RelationType } from './types.js';
+
+export interface CreateEdgeInput {
+  srcType: NodeType;
+  srcId: string;
+  relType: RelationType;
+  dstType: NodeType;
+  dstId: string;
+  metaJson?: Record<string, unknown>;
+}
+
+export class EdgeRepo {
+  constructor(private db: Database) {}
+
+  /**
+   * Create a new edge (idempotent - ignores duplicates)
+   */
+  async create(input: CreateEdgeInput): Promise<Edge> {
+    const edgeId = randomUUID();
+    const now = new Date();
+
+    await this.db.run(
+      `INSERT INTO edges (edge_id, src_type, src_id, rel_type, dst_type, dst_id, meta_json, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT DO NOTHING`,
+      [
+        edgeId,
+        input.srcType,
+        input.srcId,
+        input.relType,
+        input.dstType,
+        input.dstId,
+        JSON.stringify(input.metaJson ?? {}),
+        now.toISOString()
+      ]
+    );
+
+    return {
+      edgeId,
+      srcType: input.srcType,
+      srcId: input.srcId,
+      relType: input.relType,
+      dstType: input.dstType,
+      dstId: input.dstId,
+      metaJson: input.metaJson,
+      createdAt: now
+    };
+  }
+
+  /**
+   * Create or update edge
+   */
+  async upsert(input: CreateEdgeInput): Promise<Edge> {
+    // Check for existing edge
+    const existing = await this.findByEndpoints(
+      input.srcType,
+      input.srcId,
+      input.relType,
+      input.dstType,
+      input.dstId
+    );
+
+    if (existing) {
+      // Update meta_json
+      await this.db.run(
+        `UPDATE edges SET meta_json = ? WHERE edge_id = ?`,
+        [JSON.stringify(input.metaJson ?? {}), existing.edgeId]
+      );
+      return { ...existing, metaJson: input.metaJson };
+    }
+
+    return this.create(input);
+  }
+
+  /**
+   * Find edge by endpoints
+   */
+  async findByEndpoints(
+    srcType: NodeType,
+    srcId: string,
+    relType: RelationType,
+    dstType: NodeType,
+    dstId: string
+  ): Promise<Edge | null> {
+    const rows = await this.db.all<Array<Record<string, unknown>>>(
+      `SELECT * FROM edges
+       WHERE src_type = ? AND src_id = ? AND rel_type = ?
+       AND dst_type = ? AND dst_id = ?`,
+      [srcType, srcId, relType, dstType, dstId]
+    );
+
+    if (rows.length === 0) return null;
+    return this.rowToEdge(rows[0]);
+  }
+
+  /**
+   * Find edges by source
+   */
+  async findBySrc(
+    srcId: string,
+    relType?: RelationType
+  ): Promise<Edge[]> {
+    let query = `SELECT * FROM edges WHERE src_id = ?`;
+    const params: unknown[] = [srcId];
+
+    if (relType) {
+      query += ` AND rel_type = ?`;
+      params.push(relType);
+    }
+
+    query += ` ORDER BY created_at DESC`;
+
+    const rows = await this.db.all<Array<Record<string, unknown>>>(query, params);
+    return rows.map(row => this.rowToEdge(row));
+  }
+
+  /**
+   * Find edges by destination
+   */
+  async findByDst(
+    dstId: string,
+    relType?: RelationType
+  ): Promise<Edge[]> {
+    let query = `SELECT * FROM edges WHERE dst_id = ?`;
+    const params: unknown[] = [dstId];
+
+    if (relType) {
+      query += ` AND rel_type = ?`;
+      params.push(relType);
+    }
+
+    query += ` ORDER BY created_at DESC`;
+
+    const rows = await this.db.all<Array<Record<string, unknown>>>(query, params);
+    return rows.map(row => this.rowToEdge(row));
+  }
+
+  /**
+   * Find all edges for a node (both directions)
+   */
+  async findByNode(nodeId: string): Promise<{ outgoing: Edge[]; incoming: Edge[] }> {
+    const outgoing = await this.findBySrc(nodeId);
+    const incoming = await this.findByDst(nodeId);
+    return { outgoing, incoming };
+  }
+
+  /**
+   * Delete edge by ID
+   */
+  async delete(edgeId: string): Promise<boolean> {
+    const result = await this.db.run(
+      `DELETE FROM edges WHERE edge_id = ?`,
+      [edgeId]
+    );
+    return true; // DuckDB doesn't return affected rows easily
+  }
+
+  /**
+   * Delete edges by source and relation type
+   */
+  async deleteBySrcAndRel(srcId: string, relType: RelationType): Promise<number> {
+    await this.db.run(
+      `DELETE FROM edges WHERE src_id = ? AND rel_type = ?`,
+      [srcId, relType]
+    );
+    return 0; // DuckDB doesn't return affected rows easily
+  }
+
+  /**
+   * Delete edges by destination and relation type
+   */
+  async deleteByDstAndRel(dstId: string, relType: RelationType): Promise<number> {
+    await this.db.run(
+      `DELETE FROM edges WHERE dst_id = ? AND rel_type = ?`,
+      [dstId, relType]
+    );
+    return 0;
+  }
+
+  /**
+   * Replace edges for a source and relation type
+   * Used for mode=replace in task_blockers_set
+   */
+  async replaceEdges(
+    srcId: string,
+    relType: RelationType,
+    newEdges: Omit<CreateEdgeInput, 'srcId' | 'relType'>[]
+  ): Promise<Edge[]> {
+    // Delete existing edges
+    await this.deleteBySrcAndRel(srcId, relType);
+
+    // Create new edges
+    const created: Edge[] = [];
+    for (const edge of newEdges) {
+      const newEdge = await this.create({
+        srcType: edge.srcType,
+        srcId,
+        relType,
+        dstType: edge.dstType,
+        dstId: edge.dstId,
+        metaJson: edge.metaJson
+      });
+      created.push(newEdge);
+    }
+
+    return created;
+  }
+
+  /**
+   * Get effective blockers (resolving condition → task)
+   * Returns resolved blocker if condition has resolves_to edge
+   */
+  async getEffectiveBlockers(taskId: string): Promise<Array<{
+    originalId: string;
+    effectiveId: string;
+    isResolved: boolean;
+  }>> {
+    const blockerEdges = await this.findBySrc(taskId, 'blocked_by');
+    const results: Array<{
+      originalId: string;
+      effectiveId: string;
+      isResolved: boolean;
+    }> = [];
+
+    for (const edge of blockerEdges) {
+      // Check if blocker has resolves_to edge
+      const resolvesTo = await this.db.all<Array<Record<string, unknown>>>(
+        `SELECT dst_id FROM edges
+         WHERE src_id = ? AND rel_type = 'resolves_to'
+         LIMIT 1`,
+        [edge.dstId]
+      );
+
+      if (resolvesTo.length > 0) {
+        results.push({
+          originalId: edge.dstId,
+          effectiveId: resolvesTo[0].dst_id as string,
+          isResolved: true
+        });
+      } else {
+        results.push({
+          originalId: edge.dstId,
+          effectiveId: edge.dstId,
+          isResolved: false
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Find 2-hop related entries (Entry → Entity → Entry)
+   */
+  async findRelatedEntries(entryId: string): Promise<Array<{
+    entryId: string;
+    viaEntityId: string;
+    relationPath: string;
+  }>> {
+    const rows = await this.db.all<Array<Record<string, unknown>>>(
+      `WITH first_hop AS (
+         SELECT e1.dst_id AS entity_id
+         FROM edges e1
+         WHERE e1.src_type = 'entry'
+           AND e1.rel_type = 'evidence_of'
+           AND e1.src_id = ?
+       )
+       SELECT
+         e2.src_id AS entry_id,
+         f.entity_id AS via_entity_id,
+         'evidence_of→evidence_of' AS relation_path
+       FROM first_hop f
+       JOIN edges e2 ON e2.dst_id = f.entity_id
+                    AND e2.rel_type = 'evidence_of'
+                    AND e2.src_type = 'entry'
+       WHERE e2.src_id != ?`,
+      [entryId, entryId]
+    );
+
+    return rows.map(row => ({
+      entryId: row.entry_id as string,
+      viaEntityId: row.via_entity_id as string,
+      relationPath: row.relation_path as string
+    }));
+  }
+
+  /**
+   * Count edges by relation type
+   */
+  async countByRelType(): Promise<Array<{ relType: string; count: number }>> {
+    const rows = await this.db.all<Array<{ rel_type: string; count: number }>>(
+      `SELECT rel_type, COUNT(*) as count FROM edges GROUP BY rel_type`
+    );
+    return rows.map(row => ({
+      relType: row.rel_type,
+      count: Number(row.count)
+    }));
+  }
+
+  /**
+   * Convert database row to Edge
+   */
+  private rowToEdge(row: Record<string, unknown>): Edge {
+    return {
+      edgeId: row.edge_id as string,
+      srcType: row.src_type as NodeType,
+      srcId: row.src_id as string,
+      relType: row.rel_type as RelationType,
+      dstType: row.dst_type as NodeType,
+      dstId: row.dst_id as string,
+      metaJson: typeof row.meta_json === 'string'
+        ? JSON.parse(row.meta_json)
+        : row.meta_json as Record<string, unknown> | undefined,
+      createdAt: new Date(row.created_at as string)
+    };
+  }
+}