@ulrichc1/sparn 1.1.0 → 1.2.0

package/dist/mcp/index.js

@@ -0,0 +1,934 @@
+#!/usr/bin/env node
+
+// src/mcp/index.ts
+import { mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// 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/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+// src/adapters/generic.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/generic.ts
+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: randomUUID2(),
+      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/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,
+  realtime: {
+    tokenBudget: 5e4,
+    autoOptimizeThreshold: 8e4,
+    watchPatterns: ["**/*.jsonl"],
+    pidFile: ".sparn/daemon.pid",
+    logFile: ".sparn/daemon.log",
+    debounceMs: 5e3,
+    incremental: true,
+    windowSize: 500,
+    consolidationInterval: null
+  }
+};
+
+// src/mcp/server.ts
+function createSparnMcpServer(options) {
+  const { memory, config = DEFAULT_CONFIG } = options;
+  const server = new McpServer({
+    name: "sparn",
+    version: "1.1.1"
+  });
+  registerOptimizeTool(server, memory, config);
+  registerStatsTool(server, memory);
+  registerConsolidateTool(server, memory);
+  return server;
+}
+function registerOptimizeTool(server, memory, config) {
+  server.registerTool(
+    "sparn_optimize",
+    {
+      title: "Sparn Optimize",
+      description: "Optimize context using neuroscience-inspired pruning. Applies BTSP detection, engram scoring, confidence states, and sparse pruning to reduce token usage while preserving important information.",
+      inputSchema: {
+        context: z.string().describe("The context text to optimize"),
+        dryRun: z.boolean().optional().default(false).describe("If true, do not persist changes to the memory store"),
+        verbose: z.boolean().optional().default(false).describe("If true, include per-entry details in the response"),
+        threshold: z.number().min(0).max(100).optional().describe("Custom pruning threshold (1-100, overrides config)")
+      }
+    },
+    async ({ context, dryRun, verbose, threshold }) => {
+      try {
+        const effectiveConfig = threshold ? { ...config, pruning: { ...config.pruning, threshold } } : config;
+        const adapter = createGenericAdapter(memory, effectiveConfig);
+        const result = await adapter.optimize(context, {
+          dryRun,
+          verbose,
+          threshold
+        });
+        const response = {
+          optimizedContext: result.optimizedContext,
+          tokensBefore: result.tokensBefore,
+          tokensAfter: result.tokensAfter,
+          reduction: `${(result.reduction * 100).toFixed(1)}%`,
+          entriesProcessed: result.entriesProcessed,
+          entriesKept: result.entriesKept,
+          durationMs: result.durationMs,
+          stateDistribution: result.stateDistribution,
+          ...verbose && result.details ? { details: result.details } : {}
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ error: message })
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerStatsTool(server, memory) {
+  server.registerTool(
+    "sparn_stats",
+    {
+      title: "Sparn Stats",
+      description: "Get optimization statistics including total commands run, tokens saved, and average reduction percentage.",
+      inputSchema: {
+        reset: z.boolean().optional().default(false).describe("If true, reset all optimization statistics")
+      }
+    },
+    async ({ reset }) => {
+      try {
+        if (reset) {
+          await memory.clearOptimizationStats();
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    message: "Optimization statistics have been reset.",
+                    totalCommands: 0,
+                    totalTokensSaved: 0,
+                    averageReduction: "0.0%"
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+        const stats = await memory.getOptimizationStats();
+        const totalCommands = stats.length;
+        const totalTokensSaved = stats.reduce(
+          (sum, s) => sum + (s.tokens_before - s.tokens_after),
+          0
+        );
+        const averageReduction = totalCommands > 0 ? stats.reduce((sum, s) => {
+          const reduction = s.tokens_before > 0 ? (s.tokens_before - s.tokens_after) / s.tokens_before : 0;
+          return sum + reduction;
+        }, 0) / totalCommands : 0;
+        const recentOptimizations = stats.slice(0, 10).map((s) => ({
+          timestamp: new Date(s.timestamp).toISOString(),
+          tokensBefore: s.tokens_before,
+          tokensAfter: s.tokens_after,
+          entriesPruned: s.entries_pruned,
+          durationMs: s.duration_ms,
+          reduction: `${((s.tokens_before - s.tokens_after) / Math.max(s.tokens_before, 1) * 100).toFixed(1)}%`
+        }));
+        const response = {
+          totalCommands,
+          totalTokensSaved,
+          averageReduction: `${(averageReduction * 100).toFixed(1)}%`,
+          recentOptimizations
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ error: message })
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerConsolidateTool(server, memory) {
+  server.registerTool(
+    "sparn_consolidate",
+    {
+      title: "Sparn Consolidate",
+      description: "Run memory consolidation (sleep replay). Removes decayed entries and merges duplicates to reclaim space. Inspired by the neuroscience principle of sleep-based memory consolidation."
+    },
+    async () => {
+      try {
+        const allIds = await memory.list();
+        const allEntries = await Promise.all(
+          allIds.map(async (id) => {
+            const entry = await memory.get(id);
+            return entry;
+          })
+        );
+        const entries = allEntries.filter((e) => e !== null);
+        const compressor = createSleepCompressor();
+        const result = compressor.consolidate(entries);
+        for (const removed of result.removed) {
+          await memory.delete(removed.id);
+        }
+        for (const kept of result.kept) {
+          await memory.put(kept);
+        }
+        await memory.compact();
+        const response = {
+          entriesBefore: result.entriesBefore,
+          entriesAfter: result.entriesAfter,
+          decayedRemoved: result.decayedRemoved,
+          duplicatesRemoved: result.duplicatesRemoved,
+          compressionRatio: `${(result.compressionRatio * 100).toFixed(1)}%`,
+          durationMs: result.durationMs,
+          vacuumCompleted: true
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(response, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ error: message })
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/index.ts
+async function main() {
+  const dbPath = resolve(process.env["SPARN_DB_PATH"] ?? ".sparn/memory.db");
+  mkdirSync(dirname(dbPath), { recursive: true });
+  const memory = await createKVMemory(dbPath);
+  const server = createSparnMcpServer({ memory });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Sparn MCP server running on stdio");
+  const shutdown = async () => {
+    console.error("Shutting down Sparn MCP server...");
+    await server.close();
+    await memory.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+  console.error("Fatal error in Sparn MCP server:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map