@ulrichc1/sparn 1.0.1 → 1.1.0

package/dist/daemon/index.js

@@ -0,0 +1,880 @@
+// src/daemon/index.ts
+import { appendFileSync, existsSync, unlinkSync } from "fs";
+
+// src/daemon/session-watcher.ts
+import { readdirSync, statSync as statSync2, watch } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+
+// src/utils/context-parser.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/utils/context-parser.ts
+function parseClaudeCodeContext(context) {
+  const entries = [];
+  const now = Date.now();
+  const lines = context.split("\n");
+  let currentBlock = [];
+  let blockType = "other";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("User:") || trimmed.startsWith("Assistant:")) {
+      if (currentBlock.length > 0) {
+        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+        currentBlock = [];
+      }
+      blockType = "conversation";
+      currentBlock.push(line);
+    } else if (trimmed.includes("<function_calls>") || trimmed.includes("<invoke>") || trimmed.includes("<tool_use>")) {
+      if (currentBlock.length > 0) {
+        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+        currentBlock = [];
+      }
+      blockType = "tool";
+      currentBlock.push(line);
+    } else if (trimmed.includes("<function_results>") || trimmed.includes("</function_results>")) {
+      if (currentBlock.length > 0 && blockType !== "result") {
+        entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+        currentBlock = [];
+      }
+      blockType = "result";
+      currentBlock.push(line);
+    } else if (currentBlock.length > 0) {
+      currentBlock.push(line);
+    } else if (trimmed.length > 0) {
+      currentBlock.push(line);
+      blockType = "other";
+    }
+  }
+  if (currentBlock.length > 0) {
+    entries.push(createEntry(currentBlock.join("\n"), blockType, now));
+  }
+  return entries.filter((e) => e.content.trim().length > 0);
+}
+function createEntry(content, type, baseTime) {
+  const tags = [type];
+  let initialScore = 0.5;
+  if (type === "conversation") initialScore = 0.8;
+  if (type === "tool") initialScore = 0.7;
+  if (type === "result") initialScore = 0.4;
+  return {
+    id: randomUUID(),
+    content,
+    hash: hashContent(content),
+    timestamp: baseTime,
+    score: initialScore,
+    state: initialScore > 0.7 ? "active" : initialScore > 0.3 ? "ready" : "silent",
+    ttl: 24 * 3600,
+    // 24 hours default
+    accessCount: 0,
+    tags,
+    metadata: { type },
+    isBTSP: false
+  };
+}
+
+// src/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/engram-scorer.ts
+function createEngramScorer(config2) {
+  const { defaultTTL } = config2;
+  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/core/budget-pruner.ts
+function createBudgetPruner(config2) {
+  const { tokenBudget, decay } = config2;
+  const engramScorer = createEngramScorer(decay);
+  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 calculateTFIDF(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 getStateMultiplier(entry) {
+    if (entry.isBTSP) return 2;
+    switch (entry.state) {
+      case "active":
+        return 2;
+      case "ready":
+        return 1;
+      case "silent":
+        return 0.5;
+      default:
+        return 1;
+    }
+  }
+  function priorityScore(entry, allEntries) {
+    const tfidf = calculateTFIDF(entry, allEntries);
+    const currentScore = engramScorer.calculateScore(entry);
+    const engramDecay = 1 - currentScore;
+    const stateMultiplier = getStateMultiplier(entry);
+    return tfidf * (1 - engramDecay) * stateMultiplier;
+  }
+  function pruneToFit(entries, budget = tokenBudget) {
+    if (entries.length === 0) {
+      return {
+        kept: [],
+        removed: [],
+        originalTokens: 0,
+        prunedTokens: 0,
+        budgetUtilization: 0
+      };
+    }
+    const originalTokens = entries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const btspEntries = entries.filter((e) => e.isBTSP);
+    const regularEntries = entries.filter((e) => !e.isBTSP);
+    const btspTokens = btspEntries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const scored = regularEntries.map((entry) => ({
+      entry,
+      score: priorityScore(entry, entries),
+      tokens: estimateTokens(entry.content)
+    }));
+    scored.sort((a, b) => b.score - a.score);
+    const kept = [...btspEntries];
+    const removed = [];
+    let currentTokens = btspTokens;
+    for (const item of scored) {
+      if (currentTokens + item.tokens <= budget) {
+        kept.push(item.entry);
+        currentTokens += item.tokens;
+      } else {
+        removed.push(item.entry);
+      }
+    }
+    const budgetUtilization = budget > 0 ? currentTokens / budget : 0;
+    return {
+      kept,
+      removed,
+      originalTokens,
+      prunedTokens: currentTokens,
+      budgetUtilization
+    };
+  }
+  return {
+    pruneToFit,
+    priorityScore
+  };
+}
+
+// src/core/metrics.ts
+function createMetricsCollector() {
+  const optimizations = [];
+  let daemonMetrics = {
+    startTime: Date.now(),
+    sessionsWatched: 0,
+    totalOptimizations: 0,
+    totalTokensSaved: 0,
+    averageLatency: 0,
+    memoryUsage: 0
+  };
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  function recordOptimization(metric) {
+    optimizations.push(metric);
+    daemonMetrics.totalOptimizations++;
+    daemonMetrics.totalTokensSaved += metric.tokensBefore - metric.tokensAfter;
+    if (metric.cacheHitRate > 0) {
+      const hits = Math.round(metric.entriesProcessed * metric.cacheHitRate);
+      cacheHits += hits;
+      cacheMisses += metric.entriesProcessed - hits;
+    }
+    daemonMetrics.averageLatency = (daemonMetrics.averageLatency * (daemonMetrics.totalOptimizations - 1) + metric.duration) / daemonMetrics.totalOptimizations;
+    if (optimizations.length > 1e3) {
+      optimizations.shift();
+    }
+  }
+  function updateDaemon(metric) {
+    daemonMetrics = {
+      ...daemonMetrics,
+      ...metric
+    };
+  }
+  function calculatePercentile(values, percentile) {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.ceil(percentile / 100 * sorted.length) - 1;
+    return sorted[index] || 0;
+  }
+  function getSnapshot() {
+    const totalRuns = optimizations.length;
+    const totalDuration = optimizations.reduce((sum, m) => sum + m.duration, 0);
+    const totalTokensSaved = optimizations.reduce(
+      (sum, m) => sum + (m.tokensBefore - m.tokensAfter),
+      0
+    );
+    const totalTokensBefore = optimizations.reduce((sum, m) => sum + m.tokensBefore, 0);
+    const averageReduction = totalTokensBefore > 0 ? totalTokensSaved / totalTokensBefore : 0;
+    const durations = optimizations.map((m) => m.duration);
+    const totalCacheQueries = cacheHits + cacheMisses;
+    const hitRate = totalCacheQueries > 0 ? cacheHits / totalCacheQueries : 0;
+    return {
+      timestamp: Date.now(),
+      optimization: {
+        totalRuns,
+        totalDuration,
+        totalTokensSaved,
+        averageReduction,
+        p50Latency: calculatePercentile(durations, 50),
+        p95Latency: calculatePercentile(durations, 95),
+        p99Latency: calculatePercentile(durations, 99)
+      },
+      cache: {
+        hitRate,
+        totalHits: cacheHits,
+        totalMisses: cacheMisses,
+        size: optimizations.reduce((sum, m) => sum + m.entriesKept, 0)
+      },
+      daemon: {
+        uptime: Date.now() - daemonMetrics.startTime,
+        sessionsWatched: daemonMetrics.sessionsWatched,
+        memoryUsage: daemonMetrics.memoryUsage
+      }
+    };
+  }
+  function exportMetrics() {
+    return JSON.stringify(getSnapshot(), null, 2);
+  }
+  function reset() {
+    optimizations.length = 0;
+    cacheHits = 0;
+    cacheMisses = 0;
+    daemonMetrics = {
+      startTime: Date.now(),
+      sessionsWatched: 0,
+      totalOptimizations: 0,
+      totalTokensSaved: 0,
+      averageLatency: 0,
+      memoryUsage: 0
+    };
+  }
+  return {
+    recordOptimization,
+    updateDaemon,
+    getSnapshot,
+    export: exportMetrics,
+    reset
+  };
+}
+var globalMetrics = null;
+function getMetrics() {
+  if (!globalMetrics) {
+    globalMetrics = createMetricsCollector();
+  }
+  return globalMetrics;
+}
+
+// src/core/incremental-optimizer.ts
+function createIncrementalOptimizer(config2) {
+  const pruner = createBudgetPruner(config2);
+  const { fullOptimizationInterval } = config2;
+  let state = {
+    entryCache: /* @__PURE__ */ new Map(),
+    documentFrequency: /* @__PURE__ */ new Map(),
+    totalDocuments: 0,
+    updateCount: 0,
+    lastFullOptimization: Date.now()
+  };
+  function tokenize(text) {
+    return text.toLowerCase().split(/\s+/).filter((word) => word.length > 0);
+  }
+  function updateDocumentFrequency(entries, remove = false) {
+    for (const entry of entries) {
+      const tokens = tokenize(entry.content);
+      const uniqueTerms = [...new Set(tokens)];
+      for (const term of uniqueTerms) {
+        const current = state.documentFrequency.get(term) || 0;
+        const updated = remove ? Math.max(0, current - 1) : current + 1;
+        if (updated === 0) {
+          state.documentFrequency.delete(term);
+        } else {
+          state.documentFrequency.set(term, updated);
+        }
+      }
+    }
+    state.totalDocuments += remove ? -entries.length : entries.length;
+    state.totalDocuments = Math.max(0, state.totalDocuments);
+  }
+  function getCachedEntry(hash) {
+    const cached = state.entryCache.get(hash);
+    if (!cached) return null;
+    return cached.entry;
+  }
+  function cacheEntry(entry, score) {
+    state.entryCache.set(entry.hash, {
+      entry,
+      score,
+      timestamp: Date.now()
+    });
+  }
+  function optimizeIncremental(newEntries, budget) {
+    const startTime = Date.now();
+    state.updateCount++;
+    if (state.updateCount >= fullOptimizationInterval) {
+      const allEntries2 = Array.from(state.entryCache.values()).map((c) => c.entry);
+      return optimizeFull([...allEntries2, ...newEntries], budget);
+    }
+    const uncachedEntries = [];
+    const cachedEntries = [];
+    for (const entry of newEntries) {
+      const cached = getCachedEntry(entry.hash);
+      if (cached) {
+        cachedEntries.push(cached);
+      } else {
+        uncachedEntries.push(entry);
+      }
+    }
+    if (uncachedEntries.length > 0) {
+      updateDocumentFrequency(uncachedEntries, false);
+    }
+    const allEntries = [...cachedEntries, ...uncachedEntries];
+    for (const entry of uncachedEntries) {
+      const score = pruner.priorityScore(entry, allEntries);
+      cacheEntry(entry, score);
+    }
+    const currentEntries = Array.from(state.entryCache.values()).map((c) => c.entry);
+    const tokensBefore = currentEntries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    const result = pruner.pruneToFit(currentEntries, budget);
+    const tokensAfter = result.kept.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    for (const removed of result.removed) {
+      state.entryCache.delete(removed.hash);
+    }
+    if (result.removed.length > 0) {
+      updateDocumentFrequency(result.removed, true);
+    }
+    const duration = Date.now() - startTime;
+    const cacheHitRate = newEntries.length > 0 ? cachedEntries.length / newEntries.length : 0;
+    getMetrics().recordOptimization({
+      timestamp: Date.now(),
+      duration,
+      tokensBefore,
+      tokensAfter,
+      entriesProcessed: newEntries.length,
+      entriesKept: result.kept.length,
+      cacheHitRate,
+      memoryUsage: process.memoryUsage().heapUsed
+    });
+    return result;
+  }
+  function optimizeFull(allEntries, budget) {
+    const startTime = Date.now();
+    const tokensBefore = allEntries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    state.entryCache.clear();
+    state.documentFrequency.clear();
+    state.totalDocuments = 0;
+    state.updateCount = 0;
+    state.lastFullOptimization = Date.now();
+    updateDocumentFrequency(allEntries, false);
+    for (const entry of allEntries) {
+      const score = pruner.priorityScore(entry, allEntries);
+      cacheEntry(entry, score);
+    }
+    const result = pruner.pruneToFit(allEntries, budget);
+    const tokensAfter = result.kept.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    for (const removed of result.removed) {
+      state.entryCache.delete(removed.hash);
+    }
+    if (result.removed.length > 0) {
+      updateDocumentFrequency(result.removed, true);
+    }
+    const duration = Date.now() - startTime;
+    getMetrics().recordOptimization({
+      timestamp: Date.now(),
+      duration,
+      tokensBefore,
+      tokensAfter,
+      entriesProcessed: allEntries.length,
+      entriesKept: result.kept.length,
+      cacheHitRate: 0,
+      // Full optimization has no cache hits
+      memoryUsage: process.memoryUsage().heapUsed
+    });
+    return result;
+  }
+  function getState() {
+    return {
+      entryCache: new Map(state.entryCache),
+      documentFrequency: new Map(state.documentFrequency),
+      totalDocuments: state.totalDocuments,
+      updateCount: state.updateCount,
+      lastFullOptimization: state.lastFullOptimization
+    };
+  }
+  function restoreState(restoredState) {
+    state = {
+      entryCache: new Map(restoredState.entryCache),
+      documentFrequency: new Map(restoredState.documentFrequency),
+      totalDocuments: restoredState.totalDocuments,
+      updateCount: restoredState.updateCount,
+      lastFullOptimization: restoredState.lastFullOptimization
+    };
+  }
+  function reset() {
+    state = {
+      entryCache: /* @__PURE__ */ new Map(),
+      documentFrequency: /* @__PURE__ */ new Map(),
+      totalDocuments: 0,
+      updateCount: 0,
+      lastFullOptimization: Date.now()
+    };
+  }
+  function getStats() {
+    return {
+      cachedEntries: state.entryCache.size,
+      uniqueTerms: state.documentFrequency.size,
+      totalDocuments: state.totalDocuments,
+      updateCount: state.updateCount,
+      lastFullOptimization: state.lastFullOptimization
+    };
+  }
+  return {
+    optimizeIncremental,
+    optimizeFull,
+    getState,
+    restoreState,
+    reset,
+    getStats
+  };
+}
+
+// src/core/context-pipeline.ts
+function createContextPipeline(config2) {
+  const optimizer = createIncrementalOptimizer(config2);
+  const { windowSize, tokenBudget } = config2;
+  let totalIngested = 0;
+  let evictedEntries = 0;
+  let currentEntries = [];
+  let budgetUtilization = 0;
+  function ingest(content, metadata = {}) {
+    const newEntries = parseClaudeCodeContext(content);
+    if (newEntries.length === 0) return 0;
+    const entriesWithMetadata = newEntries.map((entry) => ({
+      ...entry,
+      metadata: { ...entry.metadata, ...metadata }
+    }));
+    const result = optimizer.optimizeIncremental(entriesWithMetadata, tokenBudget);
+    totalIngested += newEntries.length;
+    evictedEntries += result.removed.length;
+    currentEntries = result.kept;
+    budgetUtilization = result.budgetUtilization;
+    if (currentEntries.length > windowSize) {
+      const sorted = [...currentEntries].sort((a, b) => b.timestamp - a.timestamp);
+      const toKeep = sorted.slice(0, windowSize);
+      const toRemove = sorted.slice(windowSize);
+      currentEntries = toKeep;
+      evictedEntries += toRemove.length;
+    }
+    return newEntries.length;
+  }
+  function getContext() {
+    const sorted = [...currentEntries].sort((a, b) => a.timestamp - b.timestamp);
+    return sorted.map((e) => e.content).join("\n\n");
+  }
+  function getEntries() {
+    return [...currentEntries].sort((a, b) => a.timestamp - b.timestamp);
+  }
+  function getStats() {
+    const optimizerStats = optimizer.getStats();
+    const currentTokens = currentEntries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    return {
+      totalIngested,
+      currentEntries: currentEntries.length,
+      currentTokens,
+      budgetUtilization,
+      evictedEntries,
+      optimizer: {
+        cachedEntries: optimizerStats.cachedEntries,
+        uniqueTerms: optimizerStats.uniqueTerms,
+        updateCount: optimizerStats.updateCount
+      }
+    };
+  }
+  function clear() {
+    totalIngested = 0;
+    evictedEntries = 0;
+    currentEntries = [];
+    budgetUtilization = 0;
+    optimizer.reset();
+  }
+  return {
+    ingest,
+    getContext,
+    getEntries,
+    getStats,
+    clear
+  };
+}
+
+// src/daemon/file-tracker.ts
+import { readFileSync, statSync } from "fs";
+function createFileTracker() {
+  const positions = /* @__PURE__ */ new Map();
+  function readNewLines(filePath) {
+    try {
+      const stats = statSync(filePath);
+      const currentSize = stats.size;
+      const currentModified = stats.mtimeMs;
+      let pos = positions.get(filePath);
+      if (!pos) {
+        pos = {
+          path: filePath,
+          position: 0,
+          partialLine: "",
+          lastModified: currentModified,
+          lastSize: 0
+        };
+        positions.set(filePath, pos);
+      }
+      if (currentSize < pos.lastSize || currentSize === pos.position) {
+        if (currentSize < pos.lastSize) {
+          pos.position = 0;
+          pos.partialLine = "";
+        }
+        return [];
+      }
+      const buffer = Buffer.alloc(currentSize - pos.position);
+      const fd = readFileSync(filePath);
+      fd.copy(buffer, 0, pos.position, currentSize);
+      const newContent = (pos.partialLine + buffer.toString("utf-8")).split("\n");
+      const partialLine = newContent.pop() || "";
+      pos.position = currentSize;
+      pos.partialLine = partialLine;
+      pos.lastModified = currentModified;
+      pos.lastSize = currentSize;
+      return newContent.filter((line) => line.trim().length > 0);
+    } catch (_error) {
+      return [];
+    }
+  }
+  function getPosition(filePath) {
+    return positions.get(filePath) || null;
+  }
+  function resetPosition(filePath) {
+    positions.delete(filePath);
+  }
+  function clearAll() {
+    positions.clear();
+  }
+  function getTrackedFiles() {
+    return Array.from(positions.keys());
+  }
+  return {
+    readNewLines,
+    getPosition,
+    resetPosition,
+    clearAll,
+    getTrackedFiles
+  };
+}
+
+// src/daemon/session-watcher.ts
+function createSessionWatcher(config2) {
+  const { config: sparnConfig, onOptimize, onError } = config2;
+  const { realtime, decay, states } = sparnConfig;
+  const pipelines = /* @__PURE__ */ new Map();
+  const fileTracker = createFileTracker();
+  const watchers = [];
+  const debounceTimers = /* @__PURE__ */ new Map();
+  function getProjectsDir() {
+    return join(homedir(), ".claude", "projects");
+  }
+  function getSessionId(filePath) {
+    const filename = filePath.split(/[/\\]/).pop() || "";
+    return filename.replace(/\.jsonl$/, "");
+  }
+  function getPipeline(sessionId) {
+    let pipeline = pipelines.get(sessionId);
+    if (!pipeline) {
+      pipeline = createContextPipeline({
+        tokenBudget: realtime.tokenBudget,
+        decay,
+        states,
+        windowSize: realtime.windowSize,
+        fullOptimizationInterval: 50
+        // Full re-optimization every 50 incremental updates
+      });
+      pipelines.set(sessionId, pipeline);
+    }
+    return pipeline;
+  }
+  function handleFileChange(filePath) {
+    const existingTimer = debounceTimers.get(filePath);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(() => {
+      try {
+        const newLines = fileTracker.readNewLines(filePath);
+        if (newLines.length === 0) return;
+        const content = newLines.join("\n");
+        const sessionId = getSessionId(filePath);
+        const pipeline = getPipeline(sessionId);
+        pipeline.ingest(content, { sessionId, filePath });
+        const stats = pipeline.getStats();
+        if (stats.currentTokens >= realtime.autoOptimizeThreshold) {
+          getMetrics().updateDaemon({
+            sessionsWatched: pipelines.size,
+            memoryUsage: process.memoryUsage().heapUsed
+          });
+          if (onOptimize) {
+            const sessionStats = computeSessionStats(sessionId, pipeline);
+            onOptimize(sessionId, sessionStats);
+          }
+        }
+      } catch (error) {
+        if (onError) {
+          onError(error instanceof Error ? error : new Error(String(error)));
+        }
+      } finally {
+        debounceTimers.delete(filePath);
+      }
+    }, realtime.debounceMs);
+    debounceTimers.set(filePath, timer);
+  }
+  function findJsonlFiles(dir) {
+    const files = [];
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const stat = statSync2(fullPath);
+        if (stat.isDirectory()) {
+          files.push(...findJsonlFiles(fullPath));
+        } else if (entry.endsWith(".jsonl")) {
+          const matches = realtime.watchPatterns.some((pattern) => {
+            const regex = new RegExp(
+              pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/\\\\]*").replace(/\./g, "\\.")
+            );
+            return regex.test(fullPath);
+          });
+          if (matches) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch (_error) {
+    }
+    return files;
+  }
+  function computeSessionStats(sessionId, pipeline) {
+    const stats = pipeline.getStats();
+    const entries = pipeline.getEntries();
+    const totalTokens = entries.reduce((sum, e) => sum + estimateTokens(e.content), 0);
+    return {
+      sessionId,
+      totalTokens: stats.totalIngested,
+      optimizedTokens: stats.currentTokens,
+      reduction: totalTokens > 0 ? (totalTokens - stats.currentTokens) / totalTokens : 0,
+      entryCount: stats.currentEntries,
+      budgetUtilization: stats.budgetUtilization
+    };
+  }
+  async function start() {
+    const projectsDir = getProjectsDir();
+    const jsonlFiles = findJsonlFiles(projectsDir);
+    const watchedDirs = /* @__PURE__ */ new Set();
+    for (const file of jsonlFiles) {
+      const dir = dirname(file);
+      if (!watchedDirs.has(dir)) {
+        const watcher2 = watch(dir, { recursive: false }, (_eventType, filename) => {
+          if (filename?.endsWith(".jsonl")) {
+            const fullPath = join(dir, filename);
+            handleFileChange(fullPath);
+          }
+        });
+        watchers.push(watcher2);
+        watchedDirs.add(dir);
+      }
+    }
+    const projectsWatcher = watch(projectsDir, { recursive: true }, (_eventType, filename) => {
+      if (filename?.endsWith(".jsonl")) {
+        const fullPath = join(projectsDir, filename);
+        handleFileChange(fullPath);
+      }
+    });
+    watchers.push(projectsWatcher);
+    getMetrics().updateDaemon({
+      startTime: Date.now(),
+      sessionsWatched: jsonlFiles.length,
+      memoryUsage: process.memoryUsage().heapUsed
+    });
+  }
+  function stop() {
+    for (const watcher2 of watchers) {
+      watcher2.close();
+    }
+    watchers.length = 0;
+    for (const timer of debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    debounceTimers.clear();
+    pipelines.clear();
+    fileTracker.clearAll();
+  }
+  function getStats() {
+    const stats = [];
+    for (const [sessionId, pipeline] of pipelines.entries()) {
+      stats.push(computeSessionStats(sessionId, pipeline));
+    }
+    return stats;
+  }
+  function getSessionStats(sessionId) {
+    const pipeline = pipelines.get(sessionId);
+    if (!pipeline) return null;
+    return computeSessionStats(sessionId, pipeline);
+  }
+  function optimizeSession(sessionId) {
+    const pipeline = pipelines.get(sessionId);
+    if (!pipeline) return;
+    const entries = pipeline.getEntries();
+    pipeline.clear();
+    pipeline.ingest(entries.map((e) => e.content).join("\n\n"));
+    if (onOptimize) {
+      const stats = computeSessionStats(sessionId, pipeline);
+      onOptimize(sessionId, stats);
+    }
+  }
+  return {
+    start,
+    stop,
+    getStats,
+    getSessionStats,
+    optimizeSession
+  };
+}
+
+// src/daemon/index.ts
+var configJson = process.env["SPARN_CONFIG"];
+var pidFile = process.env["SPARN_PID_FILE"];
+var logFile = process.env["SPARN_LOG_FILE"];
+if (!configJson || !pidFile || !logFile) {
+  console.error("Daemon: Missing required environment variables");
+  process.exit(1);
+}
+var config = JSON.parse(configJson);
+function log(message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const logMessage = `[${timestamp}] ${message}
+`;
+  if (logFile) {
+    try {
+      appendFileSync(logFile, logMessage, "utf-8");
+    } catch {
+    }
+  }
+}
+function cleanup() {
+  log("Daemon shutting down");
+  if (pidFile && existsSync(pidFile)) {
+    try {
+      unlinkSync(pidFile);
+    } catch {
+    }
+  }
+  watcher.stop();
+  process.exit(0);
+}
+process.on("SIGTERM", cleanup);
+process.on("SIGINT", cleanup);
+process.on("SIGHUP", cleanup);
+process.on("uncaughtException", (error) => {
+  log(`Uncaught exception: ${error.message}`);
+  cleanup();
+});
+process.on("unhandledRejection", (reason) => {
+  log(`Unhandled rejection: ${reason}`);
+  cleanup();
+});
+log("Daemon starting");
+var watcher = createSessionWatcher({
+  config,
+  onOptimize: (sessionId, stats) => {
+    log(
+      `Optimized session ${sessionId}: ${stats.optimizedTokens} tokens (${Math.round(stats.reduction * 100)}% reduction)`
+    );
+  },
+  onError: (error) => {
+    log(`Error: ${error.message}`);
+  }
+});
+watcher.start().then(() => {
+  log("Daemon ready - watching Claude Code sessions");
+}).catch((error) => {
+  log(`Failed to start: ${error.message}`);
+  cleanup();
+});
+setInterval(() => {
+}, 6e4);
+//# sourceMappingURL=index.js.map