@ulrichc1/sparn 1.1.0 → 1.2.0

package/dist/index.cjs

@@ -47,6 +47,7 @@ __export(src_exports, {
   createLogger: () => createLogger,
   createSessionWatcher: () => createSessionWatcher,
   createSleepCompressor: () => createSleepCompressor,
+  createSparnMcpServer: () => createSparnMcpServer,
   createSparsePruner: () => createSparsePruner,
   estimateTokens: () => estimateTokens,
   hashContent: () => hashContent,
@@ -55,6 +56,10 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
 // src/core/btsp-embedder.ts
 var import_node_crypto2 = require("crypto");
 
@@ -1366,6 +1371,7 @@ function createSleepCompressor() {
 var import_node_child_process = require("child_process");
 var import_node_fs2 = require("fs");
 var import_node_path = require("path");
+var import_node_url = require("url");
 function createDaemonCommand() {
   function isDaemonRunning(pidFile) {
     if (!(0, import_node_fs2.existsSync)(pidFile)) {
@@ -1412,6 +1418,8 @@ function createDaemonCommand() {
       };
     }
     try {
+      const __filename2 = (0, import_node_url.fileURLToPath)(importMetaUrl);
+      const __dirname = (0, import_node_path.dirname)(__filename2);
       const daemonPath = (0, import_node_path.join)(__dirname, "index.js");
       const child = (0, import_node_child_process.fork)(daemonPath, [], {
         detached: true,
@@ -1761,6 +1769,10 @@ function createSessionWatcher(config) {
   };
 }
 
+// src/mcp/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_zod = require("zod");
+
 // src/types/config.ts
 var DEFAULT_CONFIG = {
   pruning: {
@@ -1790,10 +1802,217 @@ var DEFAULT_CONFIG = {
     logFile: ".sparn/daemon.log",
     debounceMs: 5e3,
     incremental: true,
-    windowSize: 500
+    windowSize: 500,
+    consolidationInterval: null
   }
 };
 
+// src/mcp/server.ts
+function createSparnMcpServer(options) {
+  const { memory, config = DEFAULT_CONFIG } = options;
+  const server = new import_mcp.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: import_zod.z.string().describe("The context text to optimize"),
+        dryRun: import_zod.z.boolean().optional().default(false).describe("If true, do not persist changes to the memory store"),
+        verbose: import_zod.z.boolean().optional().default(false).describe("If true, include per-entry details in the response"),
+        threshold: import_zod.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: import_zod.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/utils/logger.ts
 function createLogger(verbose = false) {
   return {
@@ -1832,6 +2051,7 @@ function createLogger(verbose = false) {
   createLogger,
   createSessionWatcher,
   createSleepCompressor,
+  createSparnMcpServer,
   createSparsePruner,
   estimateTokens,
   hashContent,