@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-62V2AFVG.js

@@ -0,0 +1,422 @@
+import {
+  mapWithConcurrency
+} from "./chunk-SZ6AYUIZ.js";
+import {
+  DEFAULT_WALK_IGNORE_DIRS,
+  watchProjectTree
+} from "./chunk-TYW2GI5I.js";
+
+// src/chronicle/context.ts
+import { randomUUID } from "node:crypto";
+function createChronicleContext(scope, traceId = randomUUID()) {
+  return {
+    scope: { ...scope },
+    correlation: { traceId, spanId: randomUUID() }
+  };
+}
+function childChronicleContext(parent, overrides = {}) {
+  return {
+    scope: { ...parent.scope, ...overrides.scope },
+    correlation: {
+      ...parent.correlation,
+      ...overrides.correlation,
+      traceId: parent.correlation.traceId,
+      parentSpanId: parent.correlation.spanId,
+      spanId: overrides.correlation?.spanId ?? randomUUID()
+    }
+  };
+}
+
+// src/chronicle/file-observer.ts
+import { createHash } from "node:crypto";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+var DEFAULT_EXCLUDED = [
+  ...DEFAULT_WALK_IGNORE_DIRS,
+  ".wrongstack",
+  ".claude",
+  ".temp_files"
+];
+var SCAN_HASH_CONCURRENCY = 32;
+var DEFAULT_FULL_RESCAN_MIN_INTERVAL_MS = 3e4;
+var MAX_RECENT_TOOL_MUTATIONS = 500;
+async function startChronicleFileObserver(options) {
+  const root = path.resolve(options.projectRoot);
+  const excluded = new Set(options.excludedDirectories ?? DEFAULT_EXCLUDED);
+  const excludedPaths = normalizeExcludedPaths(root, options.excludedPaths ?? []);
+  const debounceMs = options.debounceMs ?? 120;
+  const maxHashBytes = options.maxHashBytes ?? 8 * 1024 * 1024;
+  const known = (await scanProject(root, excluded, excludedPaths, maxHashBytes, options.onError)).files;
+  const recentToolMutations = /* @__PURE__ */ new Map();
+  const noteToolMutation = (hint) => {
+    const absolute = path.isAbsolute(hint.path) ? path.normalize(hint.path) : path.resolve(root, hint.path);
+    const relative2 = normalizeRelative(path.relative(root, absolute));
+    if (relative2.startsWith("../") || isExcluded(relative2, excluded, excludedPaths)) return;
+    recentToolMutations.set(relative2, {
+      at: hint.at ?? Date.now(),
+      toolUseId: hint.toolUseId,
+      toolName: hint.toolName,
+      agentId: hint.agentId,
+      sessionId: hint.sessionId
+    });
+    if (recentToolMutations.size > MAX_RECENT_TOOL_MUTATIONS) {
+      const overflow = recentToolMutations.size - MAX_RECENT_TOOL_MUTATIONS;
+      const keys = [...recentToolMutations.keys()];
+      for (let i = 0; i < overflow && i < keys.length; i++) {
+        recentToolMutations.delete(keys[i]);
+      }
+    }
+  };
+  const offToolProgress = options.events?.on("tool.progress", (event) => {
+    if (event.event.type !== "file_changed" || !event.event.path) return;
+    noteToolMutation({
+      path: event.event.path,
+      toolUseId: event.id,
+      toolName: event.name,
+      agentId: event.agentId,
+      sessionId: event.sessionId
+    });
+  });
+  const pending = /* @__PURE__ */ new Set();
+  let timer;
+  let closed = false;
+  let flushTail = null;
+  const minFullRescanIntervalMs = options.minFullRescanIntervalMs ?? DEFAULT_FULL_RESCAN_MIN_INTERVAL_MS;
+  let lastFullScanAt = Date.now();
+  let fullRescanTimer;
+  const bumpDebounce = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = void 0;
+      drainPending();
+    }, debounceMs);
+  };
+  const requestFullRescan = () => {
+    if (closed) return;
+    const since = Date.now() - lastFullScanAt;
+    if (since >= minFullRescanIntervalMs) {
+      pending.add("*");
+      bumpDebounce();
+      return;
+    }
+    if (fullRescanTimer) return;
+    fullRescanTimer = setTimeout(() => {
+      fullRescanTimer = void 0;
+      if (closed) return;
+      pending.add("*");
+      bumpDebounce();
+    }, minFullRescanIntervalMs - since);
+    if (typeof fullRescanTimer.unref === "function") fullRescanTimer.unref();
+  };
+  const schedule = (filename) => {
+    if (closed) return;
+    if (filename === null) {
+      requestFullRescan();
+      return;
+    }
+    const relative2 = normalizeRelative(String(filename));
+    if (!relative2 || isExcluded(relative2, excluded, excludedPaths)) return;
+    pending.add(relative2);
+    bumpDebounce();
+  };
+  const reconcile = async (changedPaths) => {
+    const wantsFullScan = changedPaths.includes("*");
+    if (wantsFullScan) lastFullScanAt = Date.now();
+    const fullScan = wantsFullScan ? await scanProject(root, excluded, excludedPaths, maxHashBytes, options.onError, known) : void 0;
+    const candidates = (fullScan ? unionKeys(known, fullScan.files) : changedPaths).filter(
+      (relative2) => !isExcluded(relative2, excluded, excludedPaths)
+    );
+    const changes = [];
+    for (const relative2 of candidates) {
+      const before = known.get(relative2);
+      const cached = fullScan?.files.get(relative2);
+      const after = cached ?? (fullScan?.complete ? void 0 : await fingerprint(path.join(root, relative2), maxHashBytes));
+      if (sameFingerprint(before, after)) continue;
+      changes.push({ relative: relative2, before, after });
+    }
+    const deleted = changes.filter((change) => change.before && !change.after);
+    const created = changes.filter((change) => !change.before && change.after);
+    const consumed = /* @__PURE__ */ new Set();
+    const journalWrites = [];
+    for (const from of deleted) {
+      const match = created.find(
+        (to) => !consumed.has(to.relative) && from.before?.hash !== void 0 && from.before.hash === to.after?.hash
+      );
+      if (!match) continue;
+      consumed.add(from.relative);
+      consumed.add(match.relative);
+      known.delete(from.relative);
+      known.set(match.relative, match.after);
+      journalWrites.push(
+        recordMutation(
+          options,
+          "file.external.renamed",
+          match.relative,
+          match.after,
+          {
+            operation: "rename",
+            previousPath: from.relative,
+            previousResourceId: resourceId(from.relative),
+            actor: "external"
+          },
+          mutationAttribution(match.relative, recentToolMutations)
+        )
+      );
+    }
+    for (const change of changes) {
+      if (consumed.has(change.relative)) continue;
+      if (!change.after) {
+        known.delete(change.relative);
+        journalWrites.push(
+          recordMutation(
+            options,
+            "file.external.deleted",
+            change.relative,
+            change.before,
+            {
+              operation: "delete",
+              actor: "external",
+              previousHash: change.before?.hash,
+              previousSize: change.before?.size
+            },
+            mutationAttribution(change.relative, recentToolMutations)
+          )
+        );
+      } else if (!change.before) {
+        known.set(change.relative, change.after);
+        journalWrites.push(
+          recordMutation(
+            options,
+            "file.external.created",
+            change.relative,
+            change.after,
+            {
+              operation: "write",
+              actor: "external"
+            },
+            mutationAttribution(change.relative, recentToolMutations)
+          )
+        );
+      } else {
+        known.set(change.relative, change.after);
+        journalWrites.push(
+          recordMutation(
+            options,
+            "file.external.modified",
+            change.relative,
+            change.after,
+            {
+              operation: "edit",
+              actor: "external",
+              previousHash: change.before.hash,
+              previousSize: change.before.size
+            },
+            mutationAttribution(change.relative, recentToolMutations)
+          )
+        );
+      }
+    }
+    await Promise.all(journalWrites);
+  };
+  const drainPending = () => {
+    if (flushTail) return flushTail;
+    const drain = (async () => {
+      while (pending.size > 0) {
+        const paths = [...pending];
+        pending.clear();
+        await reconcile(paths).catch((error) => options.onError?.(error));
+      }
+    })().finally(() => {
+      if (flushTail === drain) flushTail = null;
+      if (!closed && pending.size > 0) drainPending();
+    });
+    flushTail = drain;
+    return drain;
+  };
+  let watcher;
+  try {
+    watcher = watchProjectTree(root, (event) => schedule(event.filename), {
+      onError: (error) => options.onError?.(error)
+    });
+  } catch (error) {
+    options.onError?.(error);
+    throw error;
+  }
+  return {
+    get watchedFiles() {
+      return known.size;
+    },
+    noteToolMutation,
+    async close() {
+      if (closed) return;
+      closed = true;
+      offToolProgress?.();
+      watcher.close();
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      if (fullRescanTimer) {
+        clearTimeout(fullRescanTimer);
+        fullRescanTimer = void 0;
+      }
+      if (pending.size > 0) drainPending();
+      await flushTail;
+      recentToolMutations.clear();
+    }
+  };
+}
+async function recordMutation(options, eventType, relativePath, state, attributes, attribution) {
+  const context = typeof options.context === "function" ? options.context() : options.context;
+  const operation = attributes["operation"];
+  options.events?.emit("file.activity", {
+    filePath: path.join(options.projectRoot, relativePath),
+    operation,
+    phase: "changed",
+    source: attribution ? "tool" : "external",
+    at: Date.now(),
+    sessionId: context.scope.sessionId,
+    traceId: context.correlation.traceId,
+    agentId: attribution?.agentId ?? context.scope.agentId,
+    ...attribution ? { toolUseId: attribution.toolUseId, toolName: attribution.toolName } : {}
+  });
+  const input = {
+    eventType: attribution ? eventType.replace(".external.", ".tool.") : eventType,
+    scope: {
+      ...context.scope,
+      ...attribution?.sessionId ? { sessionId: attribution.sessionId } : {},
+      ...attribution?.agentId ? { agentId: attribution.agentId } : {}
+    },
+    correlation: {
+      ...context.correlation,
+      ...attribution ? { toolCallId: attribution.toolUseId } : {}
+    },
+    outcome: "success",
+    resource: {
+      kind: "file",
+      id: resourceId(relativePath),
+      path: normalizeRelative(relativePath),
+      ...state?.hash ? { contentHashAfter: state.hash } : {}
+    },
+    attributes: {
+      ...attributes,
+      actor: attribution ? "agent" : attributes["actor"],
+      source: attribution ? "tool" : "external",
+      toolName: attribution?.toolName,
+      size: state?.size,
+      mtimeMs: state?.mtimeMs,
+      observedBy: "fs.watch"
+    }
+  };
+  await options.journal.append(input);
+}
+function mutationAttribution(relativePath, recent) {
+  const value = recent.get(relativePath);
+  if (!value) return void 0;
+  recent.delete(relativePath);
+  return Date.now() - value.at <= 2e3 ? value : void 0;
+}
+async function scanProject(root, excluded, excludedPaths, maxHashBytes, onError, previous) {
+  const result = /* @__PURE__ */ new Map();
+  const dirs = [""];
+  let complete = true;
+  while (dirs.length > 0) {
+    const relativeDir = dirs.pop();
+    try {
+      const entries = await fsp.readdir(path.join(root, relativeDir), { withFileTypes: true });
+      const filePaths = [];
+      for (const entry of entries) {
+        const relative2 = normalizeRelative(path.join(relativeDir, entry.name));
+        if (isExcluded(relative2, excluded, excludedPaths)) continue;
+        if (entry.isDirectory()) {
+          dirs.push(relative2);
+        } else if (entry.isFile()) {
+          filePaths.push(relative2);
+        }
+      }
+      const fingerprints = await mapWithConcurrency(
+        filePaths,
+        SCAN_HASH_CONCURRENCY,
+        async (relative2) => {
+          try {
+            const value = await fingerprint(
+              path.join(root, relative2),
+              maxHashBytes,
+              previous?.get(relative2)
+            );
+            return value ? [relative2, value] : null;
+          } catch (error) {
+            complete = false;
+            onError?.(error);
+            return null;
+          }
+        }
+      );
+      for (const entry of fingerprints) {
+        if (entry) result.set(entry[0], entry[1]);
+      }
+    } catch (error) {
+      complete = false;
+      onError?.(error);
+    }
+  }
+  return { files: result, complete };
+}
+async function fingerprint(filePath, maxHashBytes, previous) {
+  try {
+    const stat2 = await fsp.stat(filePath);
+    if (!stat2.isFile()) return void 0;
+    const base = { size: stat2.size, mtimeMs: stat2.mtimeMs };
+    if (previous?.hash !== void 0 && previous.size === stat2.size && previous.mtimeMs === stat2.mtimeMs) {
+      base.hash = previous.hash;
+      return base;
+    }
+    if (stat2.size <= maxHashBytes) {
+      base.hash = createHash("sha256").update(await fsp.readFile(filePath)).digest("hex");
+    }
+    return base;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
+      return void 0;
+    throw error;
+  }
+}
+function sameFingerprint(a, b) {
+  if (!a || !b) return a === b;
+  if (a.hash !== void 0 && b.hash !== void 0) return a.hash === b.hash;
+  return a.size === b.size && a.mtimeMs === b.mtimeMs;
+}
+function isExcluded(relative2, excluded, excludedPaths) {
+  const normalized = normalizeRelative(relative2);
+  if (normalized.split("/").some((segment) => excluded.has(segment))) return true;
+  for (const prefix of excludedPaths) {
+    if (normalized === prefix || normalized.startsWith(`${prefix}/`)) return true;
+  }
+  return false;
+}
+function normalizeExcludedPaths(root, values) {
+  const result = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const relative2 = path.isAbsolute(value) ? path.relative(root, path.resolve(value)) : value;
+    const normalized = normalizeRelative(relative2).replace(/\/+$/u, "");
+    if (!normalized || normalized === "." || normalized.startsWith("../")) continue;
+    result.add(normalized);
+  }
+  return result;
+}
+function normalizeRelative(value) {
+  return value.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+function resourceId(relativePath) {
+  return `file_${createHash("sha256").update(normalizeRelative(relativePath)).digest("hex").slice(0, 24)}`;
+}
+function unionKeys(a, b) {
+  return [.../* @__PURE__ */ new Set([...a.keys(), ...b.keys()])];
+}
+
+export {
+  createChronicleContext,
+  childChronicleContext,
+  startChronicleFileObserver
+};
+//# sourceMappingURL=chunk-62V2AFVG.js.map