sentinelayer-cli 0.6.2 → 0.8.1

package/src/daemon/ingest-refresh.js

@@ -1,6 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
 import { collectCodebaseIngest, generateCodebaseIngest } from "../ingest/engine.js";
+import { createAgentEvent } from "../events/schema.js";
+import {
+  buildAstSnapshot,
+  detectAstDrift,
+  writeAstSnapshot,
+} from "./ast-drift.js";
 
 /**
  * Pulse Ingest Refresh — periodic codebase re-index.
@@ -54,26 +60,64 @@ export function detectIngestDrift(targetPath) {
  * Run a budget-gated ingest refresh.
  * Aborts if refresh takes longer than maxDurationMs.
  *
+ * Drift detection (#A11, spec §5.7): when `driftMode` is "ast" we use the
+ * AST signature diff (new exports / imports, removed files, renamed
+ * signatures); otherwise we fall back to the quick file-count heuristic for
+ * backward compatibility. AST mode writes a snapshot after every refresh so
+ * subsequent runs can diff against it.
+ *
  * @param {string} targetPath
  * @param {object} [options]
  * @param {number} [options.maxDurationMs] - Max refresh time (default 30s)
+ * @param {"file-count"|"ast"} [options.driftMode="file-count"]
  * @param {function} [options.onEvent] - Event callback
  * @returns {Promise<{ refreshed: boolean, reason: string, durationMs: number }>}
  */
 export async function refreshIngestIfNeeded(targetPath, options = {}) {
   const maxDurationMs = options.maxDurationMs || DEFAULT_MAX_DURATION_MS;
-  const drift = detectIngestDrift(targetPath);
+  const driftMode = options.driftMode === "ast" ? "ast" : "file-count";
+  let astOutcome = null;
+
+  if (driftMode === "ast") {
+    astOutcome = await detectAstDrift({ rootPath: targetPath });
+    if (!astOutcome.driftDetected) {
+      return {
+        refreshed: false,
+        reason: "no_drift",
+        durationMs: 0,
+        driftMode,
+        astReason: astOutcome.reason || null,
+      };
+    }
+  }
+
+  const drift =
+    driftMode === "file-count"
+      ? detectIngestDrift(targetPath)
+      : {
+          changed: true,
+          currentFileCount: 0,
+          lastFileCount: 0,
+          delta: 0,
+          astReason: astOutcome?.reason || null,
+        };
 
   if (!drift.changed) {
-    return { refreshed: false, reason: "no_drift", durationMs: 0, ...drift };
+    return {
+      refreshed: false,
+      reason: "no_drift",
+      durationMs: 0,
+      driftMode,
+      ...drift,
+    };
   }
 
   if (options.onEvent) {
-    options.onEvent({
-      stream: "sl_event",
+    options.onEvent(createAgentEvent({
       event: "ingest_refresh_start",
+      agentId: "daemon-ingest-refresh",
       payload: { delta: drift.delta, currentFiles: drift.currentFileCount, lastFiles: drift.lastFileCount },
-    });
+    }));
   }
 
   const startMs = Date.now();
@@ -81,11 +125,11 @@ export async function refreshIngestIfNeeded(targetPath, options = {}) {
   // Budget gate: abort if taking too long
   const timeout = setTimeout(() => {
     if (options.onEvent) {
-      options.onEvent({
-        stream: "sl_event",
+      options.onEvent(createAgentEvent({
         event: "ingest_refresh_timeout",
+        agentId: "daemon-ingest-refresh",
         payload: { maxDurationMs, elapsed: Date.now() - startMs },
-      });
+      }));
     }
   }, maxDurationMs);
 
@@ -103,22 +147,37 @@ export async function refreshIngestIfNeeded(targetPath, options = {}) {
 
     const durationMs = Date.now() - startMs;
 
+    // On AST mode, persist the new snapshot so the next run diffs against
+    // what we just observed, not against a stale baseline.
+    if (driftMode === "ast" && astOutcome?.currentSnapshot) {
+      try {
+        await writeAstSnapshot({
+          rootPath: targetPath,
+          snapshot: astOutcome.currentSnapshot,
+        });
+      } catch {
+        // Snapshot write is best-effort — the refresh itself succeeded.
+      }
+    }
+
     if (options.onEvent) {
-      options.onEvent({
-        stream: "sl_event",
+      options.onEvent(createAgentEvent({
         event: "ingest_refresh_complete",
+        agentId: "daemon-ingest-refresh",
         payload: {
           durationMs,
           filesScanned: ingest?.summary?.filesScanned || 0,
           delta: drift.delta,
+          driftMode,
         },
-      });
+      }));
     }
 
     return {
       refreshed: true,
       reason: "drift_detected",
       durationMs,
+      driftMode,
       filesScanned: ingest?.summary?.filesScanned || 0,
       ...drift,
     };
@@ -193,3 +252,12 @@ function countFilesQuick(rootPath) {
   walk(rootPath);
   return count;
 }
+
+// AST-based drift detection surface (#A11). Re-exported here so callers that
+// already import from daemon/ingest-refresh.js can opt in without reaching
+// into the ast-drift module directly.
+export {
+  buildAstSnapshot,
+  detectAstDrift,
+  writeAstSnapshot,
+} from "./ast-drift.js";