@ulrichc1/sparn 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,1868 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/cli/ui/colors.ts
+var colors_exports = {};
+__export(colors_exports, {
+  bold: () => bold,
+  brainPink: () => brainPink,
+  dim: () => dim,
+  errorRed: () => errorRed,
+  neuralCyan: () => neuralCyan,
+  synapseViolet: () => synapseViolet
+});
+import chalk from "chalk";
+var neuralCyan, synapseViolet, errorRed, brainPink, dim, bold;
+var init_colors = __esm({
+  "src/cli/ui/colors.ts"() {
+    "use strict";
+    init_esm_shims();
+    neuralCyan = chalk.hex("#00D4AA");
+    synapseViolet = chalk.hex("#7B61FF");
+    errorRed = chalk.hex("#FF6B6B");
+    brainPink = chalk.hex("#FF6B9D");
+    dim = chalk.dim;
+    bold = chalk.bold;
+  }
+});
+
+// src/cli/ui/banner.ts
+function getBanner(version) {
+  const versionStr = version ? synapseViolet(`v${version}`) : "";
+  return `${neuralCyan(BANNER)}
+${brainPink(TAGLINE)}
+${versionStr ? `${versionStr}
+` : ""}`;
+}
+var BANNER, TAGLINE;
+var init_banner = __esm({
+  "src/cli/ui/banner.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_colors();
+    BANNER = `
+   ____  ____  ___    ____  _   __
+  / ___\\/ __ \\/ _ \\  / __ \\/ | / /
+  \\__ \\/ /_/ / /_\\ \\/ /_/ /  |/ /
+ ___/ / ____/ __ _/ _, _/ /|  /
+/____/_/   /_/ |_/_/ |_/_/ |_/
+`;
+    TAGLINE = "\u{1F9E0} Neuroscience-inspired context optimization";
+  }
+});
+
+// src/core/kv-memory.ts
+var kv_memory_exports = {};
+__export(kv_memory_exports, {
+  createKVMemory: () => createKVMemory
+});
+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");
+    }
+  };
+}
+var init_kv_memory = __esm({
+  "src/core/kv-memory.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/types/config.ts
+var DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/types/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    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/cli/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  displayInitSuccess: () => displayInitSuccess,
+  initCommand: () => initCommand
+});
+import { readFileSync } from "fs";
+import { access, mkdir, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dump as dumpYAML } from "js-yaml";
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    const __filename2 = fileURLToPath2(import.meta.url);
+    const __dirname2 = dirname(__filename2);
+    const pkg = JSON.parse(readFileSync(join(__dirname2, "../../../package.json"), "utf-8"));
+    return pkg.version;
+  }
+}
+async function initCommand(options = {}) {
+  const startTime = Date.now();
+  const cwd = options.cwd || process.cwd();
+  const sparnDir = join(cwd, ".sparn");
+  const configPath = join(sparnDir, "config.yaml");
+  const dbPath = join(sparnDir, "memory.db");
+  const exists = await checkExists(sparnDir);
+  if (exists && !options.force) {
+    throw new Error(
+      ".sparn/ directory already exists. Use --force to overwrite or run from a different directory."
+    );
+  }
+  await mkdir(sparnDir, { recursive: true });
+  const configYAML = dumpYAML(DEFAULT_CONFIG, {
+    indent: 2,
+    lineWidth: 100
+  });
+  const configWithComments = `# Sparn Configuration
+# See https://github.com/ulrichc1/sparn for documentation
+
+${configYAML}`;
+  await writeFile(configPath, configWithComments, "utf8");
+  const memory = await createKVMemory(dbPath);
+  await memory.close();
+  const durationMs = Date.now() - startTime;
+  return {
+    configPath,
+    dbPath,
+    durationMs
+  };
+}
+function displayInitSuccess(result) {
+  console.log(getBanner(VERSION));
+  console.log(`
+${brainPink("\u2501".repeat(60))}`);
+  console.log(brainPink("  \u{1F9E0} Sparn Initialized Successfully!"));
+  console.log(brainPink("\u2501".repeat(60)));
+  console.log(`
+  ${neuralCyan("Config:")}   ${dim(result.configPath)}`);
+  console.log(`  ${neuralCyan("Database:")} ${dim(result.dbPath)}`);
+  console.log(`  ${neuralCyan("Time:")}     ${dim(`${result.durationMs}ms`)}`);
+  console.log(
+    `
+  ${brainPink("\u2192")} Run ${neuralCyan("'sparn optimize'")} to start optimizing context!`
+  );
+  console.log(`${brainPink("\u2501".repeat(60))}
+`);
+}
+async function checkExists(path2) {
+  try {
+    await access(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var VERSION;
+var init_init = __esm({
+  "src/cli/commands/init.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_kv_memory();
+    init_config();
+    init_banner();
+    init_colors();
+    VERSION = getVersion();
+  }
+});
+
+// src/cli/ui/progress.ts
+var progress_exports = {};
+__export(progress_exports, {
+  createConsolidateSpinner: () => createConsolidateSpinner,
+  createInitSpinner: () => createInitSpinner,
+  createOptimizeSpinner: () => createOptimizeSpinner,
+  createStatsSpinner: () => createStatsSpinner,
+  showConsolidationSummary: () => showConsolidationSummary,
+  showInitSuccess: () => showInitSuccess,
+  showTokenSavings: () => showTokenSavings
+});
+import ora from "ora";
+function createOptimizeSpinner(text) {
+  return ora({
+    text,
+    color: "cyan",
+    spinner: "dots12"
+  });
+}
+function createConsolidateSpinner(text) {
+  return ora({
+    text,
+    color: "magenta",
+    spinner: "material"
+  });
+}
+function createStatsSpinner(text) {
+  return ora({
+    text,
+    color: "yellow",
+    spinner: "bouncingBar"
+  });
+}
+function createInitSpinner(text) {
+  return ora({
+    text,
+    color: "green",
+    spinner: "star"
+  });
+}
+function showTokenSavings(tokensBefore, tokensAfter, reduction) {
+  const saved = tokensBefore - tokensAfter;
+  const reductionPercent = (reduction * 100).toFixed(1);
+  console.log(`
+${brainPink("\u2501".repeat(60))}`);
+  console.log(neuralCyan("  \u{1F4CA} Token Optimization Results"));
+  console.log(brainPink("\u2501".repeat(60)));
+  console.log(`  ${synapseViolet("Before:")}  ${tokensBefore.toLocaleString()} tokens`);
+  console.log(`  ${neuralCyan("After:")}   ${tokensAfter.toLocaleString()} tokens`);
+  console.log(brainPink("  \u2193".repeat(30)));
+  console.log(`  ${brainPink("Saved:")}   ${saved.toLocaleString()} tokens (${reductionPercent}%)`);
+  const barLength = 40;
+  const savedBars = Math.floor(reduction * barLength);
+  const keptBars = barLength - savedBars;
+  const progressBar = neuralCyan("\u2588".repeat(keptBars)) + brainPink("\u2591".repeat(savedBars));
+  console.log(`  [${progressBar}] ${reductionPercent}% reduced`);
+  if (reduction >= 0.9) {
+    console.log(`
+  ${brainPink("\u2728 OUTSTANDING!")} Mind-blowing 90%+ reduction!`);
+  } else if (reduction >= 0.7) {
+    console.log(`
+  ${neuralCyan("\u{1F389} EXCELLENT!")} Strong 70%+ token savings!`);
+  } else if (reduction >= 0.5) {
+    console.log(`
+  ${synapseViolet("\u{1F44D} GOOD!")} Solid 50%+ optimization!`);
+  } else if (reduction > 0) {
+    console.log(`
+  ${neuralCyan("\u2713")} Tokens optimized successfully!`);
+  }
+  console.log(`${brainPink("\u2501".repeat(60))}
+`);
+}
+function showConsolidationSummary(entriesBefore, entriesAfter, decayed, duplicates, durationMs) {
+  const removed = entriesBefore - entriesAfter;
+  const compressionRatio = entriesBefore > 0 ? (removed / entriesBefore * 100).toFixed(1) : "0.0";
+  console.log(`
+${brainPink("\u2501".repeat(60))}`);
+  console.log(neuralCyan("  \u{1F9F9} Memory Consolidation Complete"));
+  console.log(brainPink("\u2501".repeat(60)));
+  console.log(`  ${synapseViolet("Before:")}     ${entriesBefore.toLocaleString()} entries`);
+  console.log(`  ${neuralCyan("After:")}      ${entriesAfter.toLocaleString()} entries`);
+  console.log(brainPink("  \u2193".repeat(30)));
+  console.log(`  ${brainPink("Decayed:")}    ${decayed.toLocaleString()} removed`);
+  console.log(`  ${brainPink("Duplicates:")} ${duplicates.toLocaleString()} merged`);
+  console.log(`  ${neuralCyan("Total:")}      ${removed.toLocaleString()} entries freed`);
+  console.log(`  ${synapseViolet("Time:")}       ${durationMs}ms`);
+  const barLength = 40;
+  const compressionBars = Math.floor(removed / entriesBefore * barLength);
+  const keptBars = barLength - compressionBars;
+  const progressBar = neuralCyan("\u2588".repeat(keptBars)) + brainPink("\u2591".repeat(compressionBars));
+  console.log(`  [${progressBar}] ${compressionRatio}% compressed`);
+  if (removed > 0) {
+    console.log(`
+  ${brainPink("\u2728")} Memory optimized and ready for peak performance!`);
+  } else {
+    console.log(`
+  ${neuralCyan("\u2713")} Memory already optimal!`);
+  }
+  console.log(`${brainPink("\u2501".repeat(60))}
+`);
+}
+function showInitSuccess(message) {
+  console.log(`
+${brainPink("\u2501".repeat(60))}`);
+  console.log(brainPink("  \u{1F9E0} Sparn Initialized Successfully!"));
+  console.log(brainPink("\u2501".repeat(60)));
+  console.log(`  ${neuralCyan(message)}`);
+  console.log(`${brainPink("\u2501".repeat(60))}
+`);
+}
+var init_progress = __esm({
+  "src/cli/ui/progress.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_colors();
+  }
+});
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+var init_hash = __esm({
+  "src/utils/hash.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/core/btsp-embedder.ts
+import { randomUUID } from "crypto";
+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
+  };
+}
+var init_btsp_embedder = __esm({
+  "src/core/btsp-embedder.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_hash();
+  }
+});
+
+// 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
+  };
+}
+var init_confidence_states = __esm({
+  "src/core/confidence-states.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// 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
+  };
+}
+var init_engram_scorer = __esm({
+  "src/core/engram-scorer.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// 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);
+}
+var init_tokenizer = __esm({
+  "src/utils/tokenizer.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// 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
+  };
+}
+var init_sparse_pruner = __esm({
+  "src/core/sparse-pruner.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_tokenizer();
+  }
+});
+
+// src/adapters/generic.ts
+import { randomUUID as randomUUID2 } 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: 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
+  };
+}
+var init_generic = __esm({
+  "src/adapters/generic.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_btsp_embedder();
+    init_confidence_states();
+    init_engram_scorer();
+    init_sparse_pruner();
+    init_hash();
+    init_tokenizer();
+  }
+});
+
+// src/cli/commands/optimize.ts
+var optimize_exports = {};
+__export(optimize_exports, {
+  optimizeCommand: () => optimizeCommand
+});
+import { readFile, writeFile as writeFile2 } from "fs/promises";
+async function optimizeCommand(options) {
+  const { memory, dryRun = false, verbose = false } = options;
+  let input;
+  if (options.inputFile) {
+    input = await readFile(options.inputFile, "utf-8");
+  } else if (options.input) {
+    input = options.input;
+  } else {
+    throw new Error("No input provided. Use --input or --input-file");
+  }
+  const adapter = createGenericAdapter(memory, DEFAULT_CONFIG);
+  const result = await adapter.optimize(input, { dryRun, verbose });
+  if (options.outputFile) {
+    await writeFile2(options.outputFile, result.optimizedContext, "utf-8");
+  }
+  return {
+    ...result,
+    output: result.optimizedContext,
+    outputFile: options.outputFile
+  };
+}
+var init_optimize = __esm({
+  "src/cli/commands/optimize.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_generic();
+    init_config();
+  }
+});
+
+// src/cli/commands/stats.ts
+var stats_exports = {};
+__export(stats_exports, {
+  statsCommand: () => statsCommand
+});
+async function statsCommand(options) {
+  const { memory, graph, reset, confirmReset, json } = options;
+  if (reset) {
+    if (confirmReset) {
+      await memory.clearOptimizationStats();
+      return {
+        totalCommands: 0,
+        totalTokensSaved: 0,
+        averageReduction: 0,
+        resetConfirmed: true
+      };
+    }
+  }
+  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 result = {
+    totalCommands,
+    totalTokensSaved,
+    averageReduction
+  };
+  if (graph && totalCommands > 0) {
+    result.graph = generateBarChart(stats);
+  }
+  if (json) {
+    result.json = JSON.stringify(
+      {
+        totalCommands,
+        totalTokensSaved,
+        averageReduction: Math.round(averageReduction * 1e3) / 10,
+        // Convert to percentage
+        optimizations: stats.map((s) => ({
+          timestamp: s.timestamp,
+          tokensBefore: s.tokens_before,
+          tokensAfter: s.tokens_after,
+          entriesPruned: s.entries_pruned,
+          durationMs: s.duration_ms,
+          reduction: Math.round((s.tokens_before - s.tokens_after) / s.tokens_before * 1e3) / 10
+        }))
+      },
+      null,
+      2
+    );
+  }
+  return result;
+}
+function generateBarChart(stats) {
+  const maxBars = 20;
+  const recentStats = stats.slice(0, maxBars);
+  const lines = [];
+  lines.push("\nOptimization History (most recent first):\n");
+  const maxReduction = Math.max(...recentStats.map((s) => s.tokens_before - s.tokens_after));
+  for (let i = 0; i < recentStats.length; i++) {
+    const s = recentStats[i];
+    if (!s) continue;
+    const reduction = s.tokens_before - s.tokens_after;
+    const reductionPct = s.tokens_before > 0 ? reduction / s.tokens_before * 100 : 0;
+    const barLength = Math.round(reduction / maxReduction * 40);
+    const bar = "\u2588".repeat(barLength);
+    const date = new Date(s.timestamp);
+    const timeStr = date.toLocaleTimeString();
+    lines.push(`${timeStr} \u2502 ${bar} ${reductionPct.toFixed(1)}%`);
+  }
+  return lines.join("\n");
+}
+var init_stats = __esm({
+  "src/cli/commands/stats.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/commands/relay.ts
+var relay_exports = {};
+__export(relay_exports, {
+  relayCommand: () => relayCommand
+});
+import { spawn } from "child_process";
+async function relayCommand(options) {
+  const { command, args, memory, silent = false } = options;
+  const { stdout, stderr, exitCode } = await executeCommand(command, args);
+  const originalOutput = stdout + stderr;
+  const adapter = createGenericAdapter(memory, DEFAULT_CONFIG);
+  const optimizationResult = await adapter.optimize(originalOutput, {
+    dryRun: true,
+    // Don't save relay outputs to memory
+    verbose: false
+  });
+  const result = {
+    exitCode,
+    originalOutput,
+    optimizedOutput: optimizationResult.optimizedContext,
+    tokensBefore: optimizationResult.tokensBefore,
+    tokensAfter: optimizationResult.tokensAfter,
+    reduction: optimizationResult.reduction
+  };
+  if (!silent && result.tokensBefore > 0) {
+    const reductionPct = (result.reduction * 100).toFixed(1);
+    result.summary = `\u{1F4CA} ${result.tokensBefore} \u2192 ${result.tokensAfter} tokens (${reductionPct}% reduction)`;
+  }
+  return result;
+}
+function executeCommand(command, args) {
+  return new Promise((resolve2) => {
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve2({
+        stdout,
+        stderr,
+        exitCode: code ?? 0
+      });
+    });
+    child.on("error", (error) => {
+      resolve2({
+        stdout,
+        stderr: error.message,
+        exitCode: 1
+      });
+    });
+  });
+}
+var init_relay = __esm({
+  "src/cli/commands/relay.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_generic();
+    init_config();
+  }
+});
+
+// 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
+  };
+}
+var init_sleep_compressor = __esm({
+  "src/core/sleep-compressor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_engram_scorer();
+  }
+});
+
+// src/cli/commands/consolidate.ts
+var consolidate_exports = {};
+__export(consolidate_exports, {
+  consolidateCommand: () => consolidateCommand
+});
+async function consolidateCommand(options) {
+  const { memory } = options;
+  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();
+  return {
+    entriesBefore: result.entriesBefore,
+    entriesAfter: result.entriesAfter,
+    decayedRemoved: result.decayedRemoved,
+    duplicatesRemoved: result.duplicatesRemoved,
+    compressionRatio: result.compressionRatio,
+    durationMs: result.durationMs,
+    vacuumCompleted: true
+  };
+}
+var init_consolidate = __esm({
+  "src/cli/commands/consolidate.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sleep_compressor();
+  }
+});
+
+// src/cli/commands/config.ts
+var config_exports = {};
+__export(config_exports, {
+  configCommand: () => configCommand
+});
+import { readFileSync as readFileSync2, writeFileSync } from "fs";
+import { load as parseYAML, dump as stringifyYAML } from "js-yaml";
+async function configCommand(options) {
+  const { configPath, subcommand, key, value, json } = options;
+  try {
+    const configYAML = readFileSync2(configPath, "utf-8");
+    const config = parseYAML(configYAML);
+    if (!subcommand) {
+      if (json) {
+        return {
+          success: true,
+          json: JSON.stringify(config, null, 2)
+        };
+      }
+      return {
+        success: true,
+        editorPath: configPath,
+        message: `Config file: ${configPath}`
+      };
+    }
+    if (subcommand === "get") {
+      if (!key) {
+        return {
+          success: false,
+          error: "Key required for get command"
+        };
+      }
+      const schema = CONFIG_SCHEMA[key];
+      if (!schema) {
+        return {
+          success: false,
+          error: `Invalid key: ${key}. Run 'sparn config' to see available keys.`
+        };
+      }
+      const retrievedValue = getNestedValue(
+        config,
+        schema.path
+      );
+      if (json) {
+        return {
+          success: true,
+          value: retrievedValue,
+          json: JSON.stringify({ key, value: retrievedValue }, null, 2)
+        };
+      }
+      return {
+        success: true,
+        value: retrievedValue,
+        message: String(retrievedValue)
+      };
+    }
+    if (subcommand === "set") {
+      if (!key) {
+        return {
+          success: false,
+          error: "Key required for set command"
+        };
+      }
+      if (value === void 0) {
+        return {
+          success: false,
+          error: "Value required for set command"
+        };
+      }
+      const schema = CONFIG_SCHEMA[key];
+      if (!schema) {
+        return {
+          success: false,
+          error: `Invalid key: ${key}. Run 'sparn config' to see available keys.`
+        };
+      }
+      const parsedValue = schema.parse(value);
+      if (!schema.validate(parsedValue)) {
+        return {
+          success: false,
+          error: `Invalid value for ${key}: ${schema.errorMessage}`
+        };
+      }
+      setNestedValue(config, schema.path, parsedValue);
+      const updatedYAML = stringifyYAML(config);
+      writeFileSync(configPath, updatedYAML, "utf-8");
+      return {
+        success: true,
+        message: `Config updated: ${key} = ${parsedValue}`
+      };
+    }
+    return {
+      success: false,
+      error: `Unknown subcommand: ${subcommand}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function getNestedValue(obj, path2) {
+  let current = obj;
+  for (const key of path2) {
+    if (current && typeof current === "object" && !Array.isArray(current) && key in current) {
+      current = current[key];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function setNestedValue(obj, path2, value) {
+  let current = obj;
+  for (let i = 0; i < path2.length - 1; i++) {
+    const key = path2[i];
+    if (!key) continue;
+    if (!current[key] || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  const lastKey = path2[path2.length - 1];
+  if (lastKey) {
+    current[lastKey] = value;
+  }
+}
+var CONFIG_SCHEMA;
+var init_config2 = __esm({
+  "src/cli/commands/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    CONFIG_SCHEMA = {
+      "pruning.threshold": {
+        path: ["pruning", "threshold"],
+        validate: (v) => typeof v === "number" && v >= 1 && v <= 100,
+        errorMessage: "threshold must be between 1-100",
+        parse: (v) => Number.parseInt(v, 10)
+      },
+      "pruning.aggressiveness": {
+        path: ["pruning", "aggressiveness"],
+        validate: (v) => typeof v === "number" && v >= 0 && v <= 100,
+        errorMessage: "aggressiveness must be between 0-100",
+        parse: (v) => Number.parseInt(v, 10)
+      },
+      "decay.defaultTTL": {
+        path: ["decay", "defaultTTL"],
+        validate: (v) => typeof v === "number" && v > 0,
+        errorMessage: "defaultTTL must be a positive number (hours)",
+        parse: (v) => Number.parseFloat(v)
+      },
+      "decay.decayThreshold": {
+        path: ["decay", "decayThreshold"],
+        validate: (v) => typeof v === "number" && v >= 0 && v <= 1,
+        errorMessage: "decayThreshold must be between 0.0-1.0",
+        parse: (v) => Number.parseFloat(v)
+      },
+      "states.activeThreshold": {
+        path: ["states", "activeThreshold"],
+        validate: (v) => typeof v === "number" && v >= 0 && v <= 1,
+        errorMessage: "activeThreshold must be between 0.0-1.0",
+        parse: (v) => Number.parseFloat(v)
+      },
+      "states.readyThreshold": {
+        path: ["states", "readyThreshold"],
+        validate: (v) => typeof v === "number" && v >= 0 && v <= 1,
+        errorMessage: "readyThreshold must be between 0.0-1.0",
+        parse: (v) => Number.parseFloat(v)
+      },
+      agent: {
+        path: ["agent"],
+        validate: (v) => v === "claude-code" || v === "generic",
+        errorMessage: 'agent must be "claude-code" or "generic"',
+        parse: (v) => v
+      },
+      "ui.colors": {
+        path: ["ui", "colors"],
+        validate: (v) => typeof v === "boolean",
+        errorMessage: "colors must be true or false",
+        parse: (v) => v === "true"
+      },
+      "ui.sounds": {
+        path: ["ui", "sounds"],
+        validate: (v) => typeof v === "boolean",
+        errorMessage: "sounds must be true or false",
+        parse: (v) => v === "true"
+      },
+      "ui.verbose": {
+        path: ["ui", "verbose"],
+        validate: (v) => typeof v === "boolean",
+        errorMessage: "verbose must be true or false",
+        parse: (v) => v === "true"
+      },
+      autoConsolidate: {
+        path: ["autoConsolidate"],
+        validate: (v) => v === null || typeof v === "number" && v > 0,
+        errorMessage: "autoConsolidate must be a positive number (hours) or null",
+        parse: (v) => v === "null" ? null : Number.parseFloat(v)
+      }
+    };
+  }
+});
+
+// src/cli/index.ts
+init_esm_shims();
+init_banner();
+import { spawn as spawn2 } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, join as join2, resolve } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { Command } from "commander";
+function getVersion2() {
+  try {
+    const pkg = JSON.parse(readFileSync3(join2(process.cwd(), "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    const __filename2 = fileURLToPath3(import.meta.url);
+    const __dirname2 = dirname2(__filename2);
+    const pkg = JSON.parse(readFileSync3(join2(__dirname2, "../../package.json"), "utf-8"));
+    return pkg.version;
+  }
+}
+var VERSION2 = getVersion2();
+async function handleError(error, context) {
+  const { errorRed: errorRed2, synapseViolet: synapseViolet2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  const errorMsg = error instanceof Error ? error.message : String(error);
+  const stack = error instanceof Error ? error.stack : void 0;
+  console.error(errorRed2("\n\u2717 Error:"), errorMsg);
+  if (context) {
+    console.error(errorRed2("Context:"), context);
+  }
+  if (errorMsg.includes("SQLITE") || errorMsg.includes("database")) {
+    console.error(synapseViolet2("\n\u{1F4A1} Database issue detected:"));
+    console.error("  Try running: rm -rf .sparn/ && sparn init");
+    console.error("  This will reinitialize your Sparn database.\n");
+  }
+  if (errorMsg.includes("EACCES") || errorMsg.includes("permission")) {
+    console.error(synapseViolet2("\n\u{1F4A1} Permission issue detected:"));
+    console.error("  Check file permissions in .sparn/ directory");
+    console.error("  Try: chmod -R u+rw .sparn/\n");
+  }
+  if (errorMsg.includes("ENOENT") || errorMsg.includes("no such file")) {
+    console.error(synapseViolet2("\n\u{1F4A1} File not found:"));
+    console.error("  Make sure you have run: sparn init");
+    console.error("  Or check that the specified file exists.\n");
+  }
+  if (errorMsg.includes("out of memory") || errorMsg.includes("heap")) {
+    console.error(synapseViolet2("\n\u{1F4A1} Memory issue detected:"));
+    console.error("  Try processing smaller chunks of context");
+    console.error("  Or increase Node.js memory: NODE_OPTIONS=--max-old-space-size=4096\n");
+  }
+  if (process.env["SPARN_DEBUG"] === "true" && stack) {
+    console.error(errorRed2("\nStack trace:"));
+    console.error(stack);
+  } else {
+    console.error("  Run with SPARN_DEBUG=true for stack trace\n");
+  }
+  process.exit(1);
+}
+process.on("unhandledRejection", (reason) => {
+  void handleError(reason, "Unhandled promise rejection");
+});
+process.on("uncaughtException", (error) => {
+  void handleError(error, "Uncaught exception");
+});
+var program = new Command();
+program.name("sparn").description("Neuroscience-inspired context optimization for AI coding agents").version(VERSION2, "-v, --version", "Output the current version").helpOption("-h, --help", "Display help for command");
+program.command("init").description("Initialize Sparn in the current project").option("-f, --force", "Force overwrite if .sparn/ already exists").addHelpText(
+  "after",
+  `
+Examples:
+  $ sparn init                  # Initialize in current directory
+  $ sparn init --force          # Overwrite existing .sparn/ directory
+
+Files Created:
+  .sparn/config.yaml            # Configuration with neuroscience parameters
+  .sparn/memory.db              # SQLite database for context storage
+
+Next Steps:
+  After initialization, use 'sparn optimize' to start optimizing context.
+`
+).action(async (options) => {
+  const { initCommand: initCommand2, displayInitSuccess: displayInitSuccess2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+  const { createInitSpinner: createInitSpinner2 } = await Promise.resolve().then(() => (init_progress(), progress_exports));
+  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  const spinner = createInitSpinner2("\u{1F9E0} Initializing Sparn...");
+  try {
+    spinner.start();
+    spinner.text = "\u{1F4C1} Creating .sparn/ directory...";
+    const result = await initCommand2({ force: options.force });
+    spinner.succeed(neuralCyan2("Sparn initialized successfully!"));
+    displayInitSuccess2(result);
+  } catch (error) {
+    spinner.fail(errorRed2("Initialization failed"));
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("optimize").description("Optimize context memory using neuroscience principles").option("-i, --input <file>", "Input file path").option("-o, --output <file>", "Output file path").option("--dry-run", "Run without saving to memory").option("--verbose", "Show detailed per-entry scores").addHelpText(
+  "after",
+  `
+Examples:
+  $ sparn optimize -i context.txt -o optimized.txt    # Optimize file
+  $ cat context.txt | sparn optimize                  # Optimize from stdin
+  $ sparn optimize -i context.txt --dry-run           # Preview without saving
+  $ sparn optimize -i context.txt --verbose           # Show entry scores
+
+How It Works:
+  1. Sparse Coding: Keeps only 2-5% most relevant context
+  2. Engram Theory: Applies decay to old memories
+  3. Multi-State Synapses: Classifies as silent/ready/active
+  4. BTSP: Locks critical events (errors, stack traces)
+  5. Sleep Replay: Consolidates and compresses
+
+Typical Results:
+  \u2022 60-90% token reduction
+  \u2022 Preserved task-critical information
+  \u2022 Enhanced AI agent focus
+`
+).action(async (options) => {
+  const { createKVMemory: createKVMemory2 } = await Promise.resolve().then(() => (init_kv_memory(), kv_memory_exports));
+  const { optimizeCommand: optimizeCommand2 } = await Promise.resolve().then(() => (init_optimize(), optimize_exports));
+  const { createOptimizeSpinner: createOptimizeSpinner2, showTokenSavings: showTokenSavings2 } = await Promise.resolve().then(() => (init_progress(), progress_exports));
+  const { neuralCyan: neuralCyan2, synapseViolet: synapseViolet2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  const spinner = createOptimizeSpinner2("\u{1F9E0} Initializing optimization...");
+  try {
+    spinner.start();
+    let input;
+    if (!options.input && process.stdin.isTTY === false) {
+      spinner.text = "\u{1F4D6} Reading context from stdin...";
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      input = Buffer.concat(chunks).toString("utf-8");
+    } else if (options.input) {
+      spinner.text = `\u{1F4D6} Reading context from ${options.input}...`;
+    }
+    spinner.text = "\u{1F4BE} Loading memory database...";
+    const dbPath = resolve(process.cwd(), ".sparn/memory.db");
+    const memory = await createKVMemory2(dbPath);
+    spinner.text = "\u26A1 Applying neuroscience principles...";
+    const result = await optimizeCommand2({
+      input,
+      inputFile: options.input,
+      outputFile: options.output,
+      memory,
+      dryRun: options.dryRun || false,
+      verbose: options.verbose || false
+    });
+    spinner.succeed(neuralCyan2(`Optimization complete in ${result.durationMs}ms!`));
+    showTokenSavings2(result.tokensBefore, result.tokensAfter, result.reduction);
+    console.log(synapseViolet2("  Entry Distribution:"));
+    console.log(`    \u2022 Processed: ${result.entriesProcessed}`);
+    console.log(`    \u2022 Kept: ${result.entriesKept}`);
+    console.log(`    \u2022 Active: ${result.stateDistribution.active}`);
+    console.log(`    \u2022 Ready: ${result.stateDistribution.ready}`);
+    console.log(`    \u2022 Silent: ${result.stateDistribution.silent}
+`);
+    if (options.verbose && result.details) {
+      console.log(neuralCyan2("  \u{1F4CB} Entry Details:"));
+      for (const detail of result.details) {
+        console.log(
+          `    ${detail.id.substring(0, 8)}: score=${detail.score.toFixed(2)}, state=${detail.state}, tokens=${detail.tokens}`
+        );
+      }
+      console.log();
+    }
+    if (!options.output) {
+      console.log(result.output);
+    }
+    await memory.close();
+  } catch (error) {
+    spinner.fail(errorRed2("Optimization failed"));
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("stats").description("View optimization statistics").option("--graph", "Display ASCII bar chart of optimization history").option("--reset", "Clear all optimization statistics").option("--json", "Output statistics in JSON format").addHelpText(
+  "after",
+  `
+Examples:
+  $ sparn stats                 # View summary statistics
+  $ sparn stats --graph         # Show ASCII chart of optimization history
+  $ sparn stats --json          # Output as JSON for automation
+  $ sparn stats --reset         # Clear all statistics (with confirmation)
+
+Tracked Metrics:
+  \u2022 Total optimizations performed
+  \u2022 Total tokens saved across all runs
+  \u2022 Average reduction percentage
+  \u2022 Per-run token before/after counts
+  \u2022 Optimization duration
+`
+).action(async (options) => {
+  const { createKVMemory: createKVMemory2 } = await Promise.resolve().then(() => (init_kv_memory(), kv_memory_exports));
+  const { statsCommand: statsCommand2 } = await Promise.resolve().then(() => (init_stats(), stats_exports));
+  const { createStatsSpinner: createStatsSpinner2 } = await Promise.resolve().then(() => (init_progress(), progress_exports));
+  const { neuralCyan: neuralCyan2, synapseViolet: synapseViolet2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  const spinner = options.graph ? createStatsSpinner2("\u{1F4CA} Generating statistics...") : null;
+  try {
+    if (spinner) spinner.start();
+    if (spinner) spinner.text = "\u{1F4BE} Loading optimization history...";
+    const dbPath = resolve(process.cwd(), ".sparn/memory.db");
+    const memory = await createKVMemory2(dbPath);
+    let confirmReset = false;
+    if (options.reset) {
+      if (spinner) spinner.stop();
+      console.log(synapseViolet2("Warning: This will clear all optimization statistics."));
+      confirmReset = true;
+    }
+    if (spinner) spinner.text = "\u{1F4C8} Calculating statistics...";
+    const result = await statsCommand2({
+      memory,
+      graph: options.graph || false,
+      reset: options.reset || false,
+      confirmReset,
+      json: options.json || false
+    });
+    if (spinner) spinner.succeed(neuralCyan2("Statistics ready!"));
+    if (options.json) {
+      console.log(result.json);
+    } else if (options.reset && result.resetConfirmed) {
+      console.log(neuralCyan2("\n\u2713 Statistics cleared\n"));
+    } else {
+      console.log(neuralCyan2("\n\u{1F4CA} Optimization Statistics\n"));
+      console.log(`  Total optimizations: ${result.totalCommands}`);
+      console.log(`  Total tokens saved: ${result.totalTokensSaved.toLocaleString()}`);
+      console.log(`  Average reduction: ${(result.averageReduction * 100).toFixed(1)}%`);
+      if (options.graph && result.graph) {
+        console.log(result.graph);
+      }
+      console.log();
+    }
+    await memory.close();
+  } catch (error) {
+    if (spinner) spinner.fail(errorRed2("Statistics failed"));
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("relay <command> [args...]").description("Proxy a CLI command through optimization").option("--silent", "Suppress token savings summary").addHelpText(
+  "after",
+  `
+Examples:
+  $ sparn relay git log         # Run 'git log' and optimize output
+  $ sparn relay npm test        # Run 'npm test' and optimize output
+  $ sparn relay gh pr view 123  # Optimize GitHub CLI output
+  $ sparn relay ls -la --silent # Suppress optimization summary
+
+Use Cases:
+  \u2022 Wrap verbose CLI commands (git log, gh pr view)
+  \u2022 Optimize test runner output
+  \u2022 Compress build logs
+  \u2022 Filter CI/CD output for AI agent consumption
+
+The relay command passes the exit code from the wrapped command.
+`
+).action(async (command, args, options) => {
+  const { createKVMemory: createKVMemory2 } = await Promise.resolve().then(() => (init_kv_memory(), kv_memory_exports));
+  const { relayCommand: relayCommand2 } = await Promise.resolve().then(() => (init_relay(), relay_exports));
+  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const dbPath = resolve(process.cwd(), ".sparn/memory.db");
+    const memory = await createKVMemory2(dbPath);
+    const result = await relayCommand2({
+      command,
+      args: args || [],
+      memory,
+      silent: options.silent || false
+    });
+    console.log(result.optimizedOutput);
+    if (result.summary) {
+      console.error(neuralCyan2(`
+${result.summary}
+`));
+    }
+    await memory.close();
+    process.exit(result.exitCode);
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("consolidate").description("Consolidate memory: remove decayed entries and merge duplicates").addHelpText(
+  "after",
+  `
+Examples:
+  $ sparn consolidate           # Run memory consolidation
+
+What It Does:
+  1. Remove Decayed Entries: Deletes entries that have fully decayed
+  2. Merge Duplicates: Combines identical content entries
+  3. VACUUM Database: Reclaims disk space from deletions
+  4. Update Statistics: Tracks consolidation metrics
+
+When to Run:
+  \u2022 After long-running sessions
+  \u2022 Before important optimizations
+  \u2022 When database size grows large
+  \u2022 As part of nightly maintenance
+
+Typical Results:
+  \u2022 20-40% database size reduction
+  \u2022 Faster query performance
+  \u2022 Cleaner memory organization
+`
+).action(async () => {
+  const { createKVMemory: createKVMemory2 } = await Promise.resolve().then(() => (init_kv_memory(), kv_memory_exports));
+  const { consolidateCommand: consolidateCommand2 } = await Promise.resolve().then(() => (init_consolidate(), consolidate_exports));
+  const { createConsolidateSpinner: createConsolidateSpinner2, showConsolidationSummary: showConsolidationSummary2 } = await Promise.resolve().then(() => (init_progress(), progress_exports));
+  const { neuralCyan: neuralCyan2, synapseViolet: synapseViolet2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  const spinner = createConsolidateSpinner2("\u{1F9F9} Initializing memory consolidation...");
+  try {
+    spinner.start();
+    spinner.text = "\u{1F4BE} Loading memory database...";
+    const dbPath = resolve(process.cwd(), ".sparn/memory.db");
+    const memory = await createKVMemory2(dbPath);
+    spinner.text = "\u{1F50D} Identifying decayed entries...";
+    const result = await consolidateCommand2({ memory });
+    spinner.succeed(neuralCyan2(`Consolidation complete in ${result.durationMs}ms!`));
+    showConsolidationSummary2(
+      result.entriesBefore,
+      result.entriesAfter,
+      result.decayedRemoved,
+      result.duplicatesRemoved,
+      result.durationMs
+    );
+    if (result.vacuumCompleted) {
+      console.log(synapseViolet2("  \u2713 Database VACUUM completed\n"));
+    } else {
+      console.log(errorRed2("  \u2717 Database VACUUM failed\n"));
+    }
+    await memory.close();
+  } catch (error) {
+    spinner.fail(errorRed2("Consolidation failed"));
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("config [subcommand] [key] [value]").description("View or modify configuration").option("--json", "Output result as JSON").addHelpText(
+  "after",
+  `
+Examples:
+  $ sparn config                        # Open config in $EDITOR
+  $ sparn config get pruning.threshold  # Get specific value
+  $ sparn config set pruning.threshold 3 # Set value
+  $ sparn config --json                 # View full config as JSON
+
+Configuration Keys:
+  pruning.threshold                     # Sparse coding threshold (2-5%)
+  decay.halfLife                        # Engram decay half-life (hours)
+  decay.minScore                        # Minimum decay score (0.0-1.0)
+  states.activeThreshold                # Active state threshold
+  states.readyThreshold                 # Ready state threshold
+  embedding.model                       # BTSP embedding model
+  embedding.dimensions                  # Embedding vector size
+
+The config file is located at .sparn/config.yaml
+`
+).action(async (subcommand, key, value, options) => {
+  const { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
+  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const configPath = resolve(process.cwd(), ".sparn/config.yaml");
+    const result = await configCommand2({
+      configPath,
+      subcommand,
+      key,
+      value,
+      json: options.json || false
+    });
+    if (!result.success) {
+      console.error(errorRed2("Error:"), result.error);
+      process.exit(1);
+    }
+    if (result.editorPath && !options.json) {
+      const editor = process.env["EDITOR"] || "vim";
+      console.log(neuralCyan2(`
+\u{1F4DD} Opening config in ${editor}...
+`));
+      const child = spawn2(editor, [result.editorPath], {
+        stdio: "inherit"
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          console.log(neuralCyan2("\n\u2713 Config edited\n"));
+        }
+        process.exit(code ?? 0);
+      });
+      return;
+    }
+    if (result.json) {
+      console.log(result.json);
+    } else if (result.message) {
+      console.log(result.message);
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.on("option:version", () => {
+  console.log(getBanner(VERSION2));
+  process.exit(0);
+});
+program.parse();
+//# sourceMappingURL=index.js.map