@ulrichc1/sparn 1.0.0

package/dist/index.js

@@ -0,0 +1,900 @@
+// src/adapters/claude-code.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/core/btsp-embedder.ts
+import { randomUUID } from "crypto";
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+
+// src/core/btsp-embedder.ts
+function createBTSPEmbedder() {
+  const BTSP_PATTERNS = [
+    // Error patterns
+    /\b(error|exception|failure|fatal|critical|panic)\b/i,
+    /\b(TypeError|ReferenceError|SyntaxError|RangeError|URIError)\b/,
+    /\bENOENT|EACCES|ECONNREFUSED|ETIMEDOUT\b/,
+    // Stack trace patterns
+    /^\s+at\s+.*\(.*:\d+:\d+\)/m,
+    // JavaScript stack trace
+    /^\s+at\s+.*\.[a-zA-Z]+:\d+/m,
+    // Python/Ruby stack trace
+    // Git diff new files
+    /^new file mode \d+$/m,
+    /^--- \/dev\/null$/m,
+    // Merge conflict markers
+    /^<<<<<<< /m,
+    /^=======/m,
+    /^>>>>>>> /m
+  ];
+  function detectBTSP(content) {
+    return BTSP_PATTERNS.some((pattern) => pattern.test(content));
+  }
+  function createBTSPEntry(content, tags = [], metadata = {}) {
+    return {
+      id: randomUUID(),
+      content,
+      hash: hashContent(content),
+      timestamp: Date.now(),
+      score: 1,
+      // Maximum initial score
+      ttl: 365 * 24 * 3600,
+      // 1 year in seconds (long retention)
+      state: "active",
+      // Always active
+      accessCount: 0,
+      tags: [...tags, "btsp"],
+      metadata,
+      isBTSP: true
+    };
+  }
+  return {
+    detectBTSP,
+    createBTSPEntry
+  };
+}
+
+// src/core/confidence-states.ts
+function createConfidenceStates(config) {
+  const { activeThreshold, readyThreshold } = config;
+  function calculateState(entry) {
+    if (entry.isBTSP) {
+      return "active";
+    }
+    if (entry.score > activeThreshold) {
+      return "active";
+    }
+    if (entry.score >= readyThreshold) {
+      return "ready";
+    }
+    return "silent";
+  }
+  function transition(entry) {
+    const newState = calculateState(entry);
+    return {
+      ...entry,
+      state: newState
+    };
+  }
+  function getDistribution(entries) {
+    const distribution = {
+      silent: 0,
+      ready: 0,
+      active: 0,
+      total: entries.length
+    };
+    for (const entry of entries) {
+      const state = calculateState(entry);
+      distribution[state]++;
+    }
+    return distribution;
+  }
+  return {
+    calculateState,
+    transition,
+    getDistribution
+  };
+}
+
+// src/core/engram-scorer.ts
+function createEngramScorer(config) {
+  const { defaultTTL } = config;
+  function calculateDecay(ageInSeconds, ttlInSeconds) {
+    if (ttlInSeconds === 0) return 1;
+    if (ageInSeconds <= 0) return 0;
+    const ratio = ageInSeconds / ttlInSeconds;
+    const decay = 1 - Math.exp(-ratio);
+    return Math.max(0, Math.min(1, decay));
+  }
+  function calculateScore(entry, currentTime = Date.now()) {
+    const ageInMilliseconds = currentTime - entry.timestamp;
+    const ageInSeconds = Math.max(0, ageInMilliseconds / 1e3);
+    const decay = calculateDecay(ageInSeconds, entry.ttl);
+    let score = entry.score * (1 - decay);
+    if (entry.accessCount > 0) {
+      const accessBonus = Math.log(entry.accessCount + 1) * 0.1;
+      score = Math.min(1, score + accessBonus);
+    }
+    if (entry.isBTSP) {
+      score = Math.max(score, 0.9);
+    }
+    return Math.max(0, Math.min(1, score));
+  }
+  function refreshTTL(entry) {
+    return {
+      ...entry,
+      ttl: defaultTTL * 3600,
+      // Convert hours to seconds
+      timestamp: Date.now()
+    };
+  }
+  return {
+    calculateScore,
+    refreshTTL,
+    calculateDecay
+  };
+}
+
+// src/utils/tokenizer.ts
+function estimateTokens(text) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+  const wordCount = words.length;
+  const charCount = text.length;
+  const charEstimate = Math.ceil(charCount / 4);
+  const wordEstimate = Math.ceil(wordCount * 0.75);
+  return Math.max(wordEstimate, charEstimate);
+}
+
+// src/core/sparse-pruner.ts
+function createSparsePruner(config) {
+  const { threshold } = config;
+  function tokenize(text) {
+    return text.toLowerCase().split(/\s+/).filter((word) => word.length > 0);
+  }
+  function calculateTF(term, tokens) {
+    const count = tokens.filter((t) => t === term).length;
+    return Math.sqrt(count);
+  }
+  function calculateIDF(term, allEntries) {
+    const totalDocs = allEntries.length;
+    const docsWithTerm = allEntries.filter((entry) => {
+      const tokens = tokenize(entry.content);
+      return tokens.includes(term);
+    }).length;
+    if (docsWithTerm === 0) return 0;
+    return Math.log(totalDocs / docsWithTerm);
+  }
+  function scoreEntry(entry, allEntries) {
+    const tokens = tokenize(entry.content);
+    if (tokens.length === 0) return 0;
+    const uniqueTerms = [...new Set(tokens)];
+    let totalScore = 0;
+    for (const term of uniqueTerms) {
+      const tf = calculateTF(term, tokens);
+      const idf = calculateIDF(term, allEntries);
+      totalScore += tf * idf;
+    }
+    return totalScore / tokens.length;
+  }
+  function prune(entries) {
+    if (entries.length === 0) {
+      return {
+        kept: [],
+        removed: [],
+        originalTokens: 0,
+        prunedTokens: 0
+      };
+    }
+    const originalTokens = entries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const scored = entries.map((entry) => ({
+      entry,
+      score: scoreEntry(entry, entries)
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    const keepCount = Math.max(1, Math.ceil(entries.length * (threshold / 100)));
+    const kept = scored.slice(0, keepCount).map((s) => s.entry);
+    const removed = scored.slice(keepCount).map((s) => s.entry);
+    const prunedTokens = kept.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    return {
+      kept,
+      removed,
+      originalTokens,
+      prunedTokens
+    };
+  }
+  return {
+    prune,
+    scoreEntry
+  };
+}
+
+// src/adapters/claude-code.ts
+var CLAUDE_CODE_PROFILE = {
+  // More aggressive pruning for tool results (they can be verbose)
+  toolResultThreshold: 3,
+  // Keep top 3% of tool results
+  // Preserve conversation turns more aggressively
+  conversationBoost: 1.5,
+  // 50% boost for User/Assistant exchanges
+  // Prioritize recent context (Claude Code sessions are typically focused)
+  recentContextWindow: 10 * 60,
+  // Last 10 minutes gets priority
+  // BTSP patterns specific to Claude Code
+  btspPatterns: [
+    // Error patterns
+    /\b(error|exception|failure|fatal|critical|panic)\b/i,
+    /^\s+at\s+.*\(.*:\d+:\d+\)/m,
+    // Stack traces
+    /^Error:/m,
+    // Git conflict markers
+    /^<<<<<<< /m,
+    /^=======/m,
+    /^>>>>>>> /m,
+    // Tool use patterns (important for context)
+    /<function_calls>/,
+    /<invoke>/,
+    /<tool_use>/,
+    // File operation results (often critical)
+    /ENOENT|EACCES|EISDIR|EEXIST/
+  ]
+};
+function createClaudeCodeAdapter(memory, config) {
+  const pruner = createSparsePruner({
+    threshold: config.pruning.threshold
+  });
+  const scorer = createEngramScorer(config.decay);
+  const states = createConfidenceStates(config.states);
+  const btsp = createBTSPEmbedder();
+  async function optimize(context, options = {}) {
+    const startTime = Date.now();
+    const entries = parseClaudeCodeContext(context);
+    const entriesWithBTSP = entries.map((entry) => {
+      const isBTSP = CLAUDE_CODE_PROFILE.btspPatterns.some(
+        (pattern) => pattern.test(entry.content)
+      );
+      if (isBTSP) {
+        const btspEntry = btsp.createBTSPEntry(entry.content, [...entry.tags, "claude-code"], {
+          originalTimestamp: entry.timestamp
+        });
+        return {
+          ...btspEntry,
+          timestamp: entry.timestamp
+        };
+      }
+      return entry;
+    });
+    const boostedEntries = entriesWithBTSP.map((entry) => {
+      const isConversationTurn = entry.content.trim().startsWith("User:") || entry.content.trim().startsWith("Assistant:");
+      if (isConversationTurn) {
+        return {
+          ...entry,
+          score: entry.score * CLAUDE_CODE_PROFILE.conversationBoost
+        };
+      }
+      return entry;
+    });
+    const scoredEntries = boostedEntries.map((entry) => {
+      const decayScore = scorer.calculateScore(entry);
+      return {
+        ...entry,
+        score: decayScore
+      };
+    });
+    const entriesWithStates = scoredEntries.map((entry) => {
+      const state = states.calculateState(entry);
+      return {
+        ...entry,
+        state
+      };
+    });
+    const pruneResult = pruner.prune(entriesWithStates);
+    if (!options.dryRun) {
+      for (const entry of pruneResult.kept) {
+        await memory.put(entry);
+      }
+      await memory.recordOptimization({
+        timestamp: Date.now(),
+        tokens_before: pruneResult.originalTokens,
+        tokens_after: pruneResult.prunedTokens,
+        entries_pruned: pruneResult.removed.length,
+        duration_ms: Date.now() - startTime
+      });
+    }
+    const optimizedContext = pruneResult.kept.map((entry) => entry.content).join("\n");
+    const stateDistribution = states.getDistribution(pruneResult.kept);
+    const result = {
+      optimizedContext,
+      tokensBefore: pruneResult.originalTokens,
+      tokensAfter: pruneResult.prunedTokens,
+      reduction: pruneResult.originalTokens > 0 ? (pruneResult.originalTokens - pruneResult.prunedTokens) / pruneResult.originalTokens : 0,
+      entriesProcessed: entries.length,
+      entriesKept: pruneResult.kept.length,
+      durationMs: Date.now() - startTime,
+      stateDistribution
+    };
+    if (options.verbose) {
+      result.details = pruneResult.kept.map((entry) => ({
+        id: entry.id,
+        score: entry.score,
+        state: entry.state || "unknown",
+        isBTSP: entry.tags.includes("btsp"),
+        tokens: estimateTokens(entry.content)
+      }));
+    }
+    return result;
+  }
+  return {
+    optimize
+  };
+}
+function parseClaudeCodeContext(context) {
+  const entries = [];
+  const now = Date.now();
+  const lines = context.split("\n");
+  let currentBlock = [];
+  let blockType = "other";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("User:") || trimmed.startsWith("Assistant:")) {
+      if (currentBlock.length > 0) {
+        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+        currentBlock = [];
+      }
+      blockType = "conversation";
+      currentBlock.push(line);
+    } else if (trimmed.includes("<function_calls>") || trimmed.includes("<invoke>") || trimmed.includes("<tool_use>")) {
+      if (currentBlock.length > 0) {
+        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+        currentBlock = [];
+      }
+      blockType = "tool";
+      currentBlock.push(line);
+    } else if (trimmed.includes("<function_results>") || trimmed.includes("</function_results>")) {
+      if (currentBlock.length > 0 && blockType !== "result") {
+        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+        currentBlock = [];
+      }
+      blockType = "result";
+      currentBlock.push(line);
+    } else if (currentBlock.length > 0) {
+      currentBlock.push(line);
+    } else if (trimmed.length > 0) {
+      currentBlock.push(line);
+      blockType = "other";
+    }
+  }
+  if (currentBlock.length > 0) {
+    entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+  }
+  return entries.filter((e) => e.content.trim().length > 0);
+}
+function createEntry(content, type, baseTime) {
+  const tags = [type];
+  let initialScore = 0.5;
+  if (type === "conversation") initialScore = 0.8;
+  if (type === "tool") initialScore = 0.7;
+  if (type === "result") initialScore = 0.4;
+  return {
+    id: randomUUID2(),
+    content,
+    hash: hashContent(content),
+    timestamp: baseTime,
+    score: initialScore,
+    state: initialScore > 0.7 ? "active" : initialScore > 0.3 ? "ready" : "silent",
+    ttl: 24 * 3600,
+    // 24 hours default
+    accessCount: 0,
+    tags,
+    metadata: { type },
+    isBTSP: false
+  };
+}
+
+// src/adapters/generic.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function createGenericAdapter(memory, config) {
+  const pruner = createSparsePruner(config.pruning);
+  const scorer = createEngramScorer(config.decay);
+  const states = createConfidenceStates(config.states);
+  const btsp = createBTSPEmbedder();
+  async function optimize(context, options = {}) {
+    const startTime = Date.now();
+    const lines = context.split("\n").filter((line) => line.trim().length > 0);
+    const entries = lines.map((content) => ({
+      id: randomUUID3(),
+      content,
+      hash: hashContent(content),
+      timestamp: Date.now(),
+      score: btsp.detectBTSP(content) ? 1 : 0.5,
+      // BTSP gets high initial score
+      ttl: config.decay.defaultTTL * 3600,
+      // Convert hours to seconds
+      state: "ready",
+      accessCount: 0,
+      tags: [],
+      metadata: {},
+      isBTSP: btsp.detectBTSP(content)
+    }));
+    const tokensBefore = entries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const scoredEntries = entries.map((entry) => ({
+      ...entry,
+      score: scorer.calculateScore(entry)
+    }));
+    const statedEntries = scoredEntries.map((entry) => states.transition(entry));
+    const pruneResult = pruner.prune(statedEntries);
+    const optimizedEntries = pruneResult.kept.filter(
+      (e) => e.state === "active" || e.state === "ready"
+    );
+    const tokensAfter = optimizedEntries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const optimizedContext = optimizedEntries.map((e) => e.content).join("\n");
+    if (!options.dryRun) {
+      for (const entry of optimizedEntries) {
+        await memory.put(entry);
+      }
+      await memory.recordOptimization({
+        timestamp: Date.now(),
+        tokens_before: tokensBefore,
+        tokens_after: tokensAfter,
+        entries_pruned: entries.length - optimizedEntries.length,
+        duration_ms: Date.now() - startTime
+      });
+    }
+    const distribution = states.getDistribution(optimizedEntries);
+    const result = {
+      optimizedContext,
+      tokensBefore,
+      tokensAfter,
+      reduction: tokensBefore > 0 ? (tokensBefore - tokensAfter) / tokensBefore : 0,
+      entriesProcessed: entries.length,
+      entriesKept: optimizedEntries.length,
+      stateDistribution: distribution,
+      durationMs: Date.now() - startTime
+    };
+    if (options.verbose) {
+      result.details = optimizedEntries.map((e) => ({
+        id: e.id,
+        score: e.score,
+        state: e.state,
+        isBTSP: e.isBTSP,
+        tokens: estimateTokens(e.content)
+      }));
+    }
+    return result;
+  }
+  return {
+    optimize
+  };
+}
+
+// src/core/kv-memory.ts
+import { copyFileSync, existsSync } from "fs";
+import Database from "better-sqlite3";
+function createBackup(dbPath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = `${dbPath}.backup-${timestamp}`;
+  try {
+    copyFileSync(dbPath, backupPath);
+    console.log(`\u2713 Database backed up to: ${backupPath}`);
+    return backupPath;
+  } catch (error) {
+    console.error(`Warning: Could not create backup: ${error}`);
+    return "";
+  }
+}
+async function createKVMemory(dbPath) {
+  let db;
+  try {
+    db = new Database(dbPath);
+    const integrityCheck = db.pragma("quick_check", { simple: true });
+    if (integrityCheck !== "ok") {
+      console.error("\u26A0 Database corruption detected!");
+      if (existsSync(dbPath)) {
+        const backupPath = createBackup(dbPath);
+        if (backupPath) {
+          console.log(`Backup created at: ${backupPath}`);
+        }
+      }
+      console.log("Attempting database recovery...");
+      db.close();
+      db = new Database(dbPath);
+    }
+  } catch (error) {
+    console.error("\u26A0 Database error detected:", error);
+    if (existsSync(dbPath)) {
+      createBackup(dbPath);
+      console.log("Creating new database...");
+    }
+    db = new Database(dbPath);
+  }
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS entries_index (
+      id TEXT PRIMARY KEY NOT NULL,
+      hash TEXT UNIQUE NOT NULL,
+      timestamp INTEGER NOT NULL,
+      score REAL NOT NULL DEFAULT 0.0 CHECK(score >= 0.0 AND score <= 1.0),
+      ttl INTEGER NOT NULL CHECK(ttl >= 0),
+      state TEXT NOT NULL CHECK(state IN ('silent', 'ready', 'active')),
+      accessCount INTEGER NOT NULL DEFAULT 0 CHECK(accessCount >= 0),
+      isBTSP INTEGER NOT NULL DEFAULT 0 CHECK(isBTSP IN (0, 1)),
+      created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS entries_value (
+      id TEXT PRIMARY KEY NOT NULL,
+      content TEXT NOT NULL,
+      tags TEXT,
+      metadata TEXT,
+      FOREIGN KEY (id) REFERENCES entries_index(id) ON DELETE CASCADE
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS optimization_stats (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+      tokens_before INTEGER NOT NULL,
+      tokens_after INTEGER NOT NULL,
+      entries_pruned INTEGER NOT NULL,
+      duration_ms INTEGER NOT NULL
+    );
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_entries_state ON entries_index(state);
+    CREATE INDEX IF NOT EXISTS idx_entries_score ON entries_index(score DESC);
+    CREATE INDEX IF NOT EXISTS idx_entries_hash ON entries_index(hash);
+    CREATE INDEX IF NOT EXISTS idx_entries_timestamp ON entries_index(timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_stats_timestamp ON optimization_stats(timestamp DESC);
+  `);
+  const putIndexStmt = db.prepare(`
+    INSERT OR REPLACE INTO entries_index
+    (id, hash, timestamp, score, ttl, state, accessCount, isBTSP)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const putValueStmt = db.prepare(`
+    INSERT OR REPLACE INTO entries_value
+    (id, content, tags, metadata)
+    VALUES (?, ?, ?, ?)
+  `);
+  const getStmt = db.prepare(`
+    SELECT
+      i.id, i.hash, i.timestamp, i.score, i.ttl, i.state, i.accessCount, i.isBTSP,
+      v.content, v.tags, v.metadata
+    FROM entries_index i
+    JOIN entries_value v ON i.id = v.id
+    WHERE i.id = ?
+  `);
+  const deleteIndexStmt = db.prepare("DELETE FROM entries_index WHERE id = ?");
+  const deleteValueStmt = db.prepare("DELETE FROM entries_value WHERE id = ?");
+  return {
+    async put(entry) {
+      const transaction = db.transaction(() => {
+        putIndexStmt.run(
+          entry.id,
+          entry.hash,
+          entry.timestamp,
+          entry.score,
+          entry.ttl,
+          entry.state,
+          entry.accessCount,
+          entry.isBTSP ? 1 : 0
+        );
+        putValueStmt.run(
+          entry.id,
+          entry.content,
+          JSON.stringify(entry.tags),
+          JSON.stringify(entry.metadata)
+        );
+      });
+      transaction();
+    },
+    async get(id) {
+      const row = getStmt.get(id);
+      if (!row) {
+        return null;
+      }
+      const r = row;
+      return {
+        id: r.id,
+        content: r.content,
+        hash: r.hash,
+        timestamp: r.timestamp,
+        score: r.score,
+        ttl: r.ttl,
+        state: r.state,
+        accessCount: r.accessCount,
+        tags: r.tags ? JSON.parse(r.tags) : [],
+        metadata: r.metadata ? JSON.parse(r.metadata) : {},
+        isBTSP: r.isBTSP === 1
+      };
+    },
+    async query(filters) {
+      let sql = `
+        SELECT
+          i.id, i.hash, i.timestamp, i.score, i.ttl, i.state, i.accessCount, i.isBTSP,
+          v.content, v.tags, v.metadata
+        FROM entries_index i
+        JOIN entries_value v ON i.id = v.id
+        WHERE 1=1
+      `;
+      const params = [];
+      if (filters.state) {
+        sql += " AND i.state = ?";
+        params.push(filters.state);
+      }
+      if (filters.minScore !== void 0) {
+        sql += " AND i.score >= ?";
+        params.push(filters.minScore);
+      }
+      if (filters.maxScore !== void 0) {
+        sql += " AND i.score <= ?";
+        params.push(filters.maxScore);
+      }
+      if (filters.isBTSP !== void 0) {
+        sql += " AND i.isBTSP = ?";
+        params.push(filters.isBTSP ? 1 : 0);
+      }
+      sql += " ORDER BY i.score DESC";
+      if (filters.limit) {
+        sql += " LIMIT ?";
+        params.push(filters.limit);
+      }
+      if (filters.offset) {
+        sql += " OFFSET ?";
+        params.push(filters.offset);
+      }
+      const stmt = db.prepare(sql);
+      const rows = stmt.all(...params);
+      return rows.map((row) => {
+        const r = row;
+        return {
+          id: r.id,
+          content: r.content,
+          hash: r.hash,
+          timestamp: r.timestamp,
+          score: r.score,
+          ttl: r.ttl,
+          state: r.state,
+          accessCount: r.accessCount,
+          tags: r.tags ? JSON.parse(r.tags) : [],
+          metadata: r.metadata ? JSON.parse(r.metadata) : {},
+          isBTSP: r.isBTSP === 1
+        };
+      });
+    },
+    async delete(id) {
+      const transaction = db.transaction(() => {
+        deleteIndexStmt.run(id);
+        deleteValueStmt.run(id);
+      });
+      transaction();
+    },
+    async list() {
+      const stmt = db.prepare("SELECT id FROM entries_index");
+      const rows = stmt.all();
+      return rows.map((r) => r.id);
+    },
+    async compact() {
+      const before = db.prepare("SELECT COUNT(*) as count FROM entries_index").get();
+      db.exec("DELETE FROM entries_index WHERE ttl <= 0");
+      db.exec("VACUUM");
+      const after = db.prepare("SELECT COUNT(*) as count FROM entries_index").get();
+      return before.count - after.count;
+    },
+    async close() {
+      db.close();
+    },
+    async recordOptimization(stats) {
+      const stmt = db.prepare(`
+        INSERT INTO optimization_stats (timestamp, tokens_before, tokens_after, entries_pruned, duration_ms)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+      stmt.run(
+        stats.timestamp,
+        stats.tokens_before,
+        stats.tokens_after,
+        stats.entries_pruned,
+        stats.duration_ms
+      );
+    },
+    async getOptimizationStats() {
+      const stmt = db.prepare(`
+        SELECT id, timestamp, tokens_before, tokens_after, entries_pruned, duration_ms
+        FROM optimization_stats
+        ORDER BY timestamp DESC
+      `);
+      const rows = stmt.all();
+      return rows;
+    },
+    async clearOptimizationStats() {
+      db.exec("DELETE FROM optimization_stats");
+    }
+  };
+}
+
+// src/core/sleep-compressor.ts
+function createSleepCompressor() {
+  const scorer = createEngramScorer({ defaultTTL: 24, decayThreshold: 0.95 });
+  function consolidate(entries) {
+    const startTime = Date.now();
+    const originalCount = entries.length;
+    const now = Date.now();
+    const nonDecayed = entries.filter((entry) => {
+      const ageInSeconds = (now - entry.timestamp) / 1e3;
+      const decay = scorer.calculateDecay(ageInSeconds, entry.ttl);
+      return decay < 0.95;
+    });
+    const decayedRemoved = originalCount - nonDecayed.length;
+    const duplicateGroups = findDuplicates(nonDecayed);
+    const merged = mergeDuplicates(duplicateGroups);
+    const duplicateIds = new Set(duplicateGroups.flatMap((g) => g.entries.map((e) => e.id)));
+    const nonDuplicates = nonDecayed.filter((e) => !duplicateIds.has(e.id));
+    const kept = [...merged, ...nonDuplicates];
+    const removed = entries.filter((e) => !kept.some((k) => k.id === e.id));
+    const duplicatesRemoved = duplicateGroups.reduce((sum, g) => sum + (g.entries.length - 1), 0);
+    return {
+      kept,
+      removed,
+      entriesBefore: originalCount,
+      entriesAfter: kept.length,
+      decayedRemoved,
+      duplicatesRemoved,
+      compressionRatio: originalCount > 0 ? kept.length / originalCount : 0,
+      durationMs: Date.now() - startTime
+    };
+  }
+  function findDuplicates(entries) {
+    const groups = [];
+    const processed = /* @__PURE__ */ new Set();
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry || processed.has(entry.id)) continue;
+      const duplicates = entries.filter((e, idx) => idx !== i && e.hash === entry.hash);
+      if (duplicates.length > 0) {
+        const group = {
+          entries: [entry, ...duplicates],
+          similarity: 1
+          // Exact match
+        };
+        groups.push(group);
+        processed.add(entry.id);
+        for (const dup of duplicates) {
+          processed.add(dup.id);
+        }
+      }
+    }
+    for (let i = 0; i < entries.length; i++) {
+      const entryI = entries[i];
+      if (!entryI || processed.has(entryI.id)) continue;
+      for (let j = i + 1; j < entries.length; j++) {
+        const entryJ = entries[j];
+        if (!entryJ || processed.has(entryJ.id)) continue;
+        const similarity = cosineSimilarity(entryI.content, entryJ.content);
+        if (similarity >= 0.85) {
+          const group = {
+            entries: [entryI, entryJ],
+            similarity
+          };
+          groups.push(group);
+          processed.add(entryI.id);
+          processed.add(entryJ.id);
+          break;
+        }
+      }
+    }
+    return groups;
+  }
+  function mergeDuplicates(groups) {
+    const merged = [];
+    for (const group of groups) {
+      const sorted = [...group.entries].sort((a, b) => b.score - a.score);
+      const best = sorted[0];
+      if (!best) continue;
+      const totalAccessCount = group.entries.reduce((sum, e) => sum + e.accessCount, 0);
+      const allTags = new Set(group.entries.flatMap((e) => e.tags));
+      merged.push({
+        ...best,
+        accessCount: totalAccessCount,
+        tags: Array.from(allTags)
+      });
+    }
+    return merged;
+  }
+  function cosineSimilarity(text1, text2) {
+    const words1 = tokenize(text1);
+    const words2 = tokenize(text2);
+    const vocab = /* @__PURE__ */ new Set([...words1, ...words2]);
+    const vec1 = {};
+    const vec2 = {};
+    for (const word of vocab) {
+      vec1[word] = words1.filter((w) => w === word).length;
+      vec2[word] = words2.filter((w) => w === word).length;
+    }
+    let dotProduct = 0;
+    let mag1 = 0;
+    let mag2 = 0;
+    for (const word of vocab) {
+      const count1 = vec1[word] ?? 0;
+      const count2 = vec2[word] ?? 0;
+      dotProduct += count1 * count2;
+      mag1 += count1 * count1;
+      mag2 += count2 * count2;
+    }
+    mag1 = Math.sqrt(mag1);
+    mag2 = Math.sqrt(mag2);
+    if (mag1 === 0 || mag2 === 0) return 0;
+    return dotProduct / (mag1 * mag2);
+  }
+  function tokenize(text) {
+    return text.toLowerCase().split(/\s+/).filter((word) => word.length > 0);
+  }
+  return {
+    consolidate,
+    findDuplicates,
+    mergeDuplicates
+  };
+}
+
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  pruning: {
+    threshold: 5,
+    aggressiveness: 50
+  },
+  decay: {
+    defaultTTL: 24,
+    decayThreshold: 0.95
+  },
+  states: {
+    activeThreshold: 0.7,
+    readyThreshold: 0.3
+  },
+  agent: "generic",
+  ui: {
+    colors: true,
+    sounds: false,
+    verbose: false
+  },
+  autoConsolidate: null
+};
+
+// src/utils/logger.ts
+function createLogger(verbose = false) {
+  return {
+    debug(message, ...args) {
+      if (verbose) {
+        console.debug(`[DEBUG] ${message}`, ...args);
+      }
+    },
+    info(message, ...args) {
+      console.info(`[INFO] ${message}`, ...args);
+    },
+    warn(message, ...args) {
+      console.warn(`[WARN] ${message}`, ...args);
+    },
+    error(message, ...args) {
+      console.error(`[ERROR] ${message}`, ...args);
+    }
+  };
+}
+export {
+  DEFAULT_CONFIG,
+  createBTSPEmbedder,
+  createClaudeCodeAdapter,
+  createConfidenceStates,
+  createEngramScorer,
+  createGenericAdapter,
+  createKVMemory,
+  createLogger,
+  createSleepCompressor,
+  createSparsePruner,
+  estimateTokens,
+  hashContent
+};
+//# sourceMappingURL=index.js.map