npm - agent-dag - Versions diffs - 1.12.0 → 1.14.2 - Mend

agent-dag 1.12.0 → 1.14.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/bin/agent-dag.js +6 -2
package/dist/web/assets/index-Bwj0xSAo.css +1 -0
package/dist/web/assets/index-CkZuDTIx.js +62 -0
package/dist/web/index.html +2 -2
package/package.json +1 -1
package/src/server/index.mjs +140 -0
package/dist/web/assets/index-CMpk9bSy.js +0 -62
package/dist/web/assets/index-Ch4BS-lV.css +0 -1

package/dist/web/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>agent-dag</title>
     <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Ctext y='84' font-size='84'%3E%E2%97%89%3C/text%3E%3C/svg%3E" />
-    <script type="module" crossorigin src="/assets/index-CMpk9bSy.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Ch4BS-lV.css">
+    <script type="module" crossorigin src="/assets/index-CkZuDTIx.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Bwj0xSAo.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.12.0",
+  "version": "1.14.2",
   "description": "Live DAG of Claude Code agents — watch parallel subagents fork, call tools, and return on one calm canvas.",
   "type": "module",
   "bin": {

package/src/server/index.mjs CHANGED Viewed

@@ -198,6 +198,145 @@ function maybeResolveUsage(payload) {
     .finally(() => pendingUsageReads.delete(sid));
 }
+// ─── Context enrichment ──────────────────────────────────────────────────
+// Approximation of `/context` since CC doesn't expose its breakdown via
+// hooks. We scan the transcript JSONL for message counts (user / assistant
+// / tool_use / tool_result / system-reminders) and walk up from cwd for
+// any CLAUDE.md files in scope. Token totals come from UsageObserved; this
+// scan is purely structural ("what does the context contain").
+const lastContextReadAt = new Map();
+const pendingContextReads = new Set();
+const CONTEXT_READ_THROTTLE_MS = 4000;
+async function readContextFromTranscript(path) {
+  try {
+    const s = await stat(path);
+    if (s.size === 0) return null;
+    const fh = await open(path, "r");
+    let buf;
+    try { buf = Buffer.alloc(s.size); await fh.read(buf, 0, s.size, 0); }
+    finally { await fh.close(); }
+    const text = buf.toString("utf8");
+    const breakdown = {
+      msgsUser: 0,
+      msgsAssistant: 0,
+      toolUses: 0,
+      toolResults: 0,
+      systemReminders: 0,
+      currentContextTokens: 0,
+    };
+    breakdown.msgsUser       = (text.match(/"type"\s*:\s*"user"/g) ?? []).length;
+    breakdown.msgsAssistant  = (text.match(/"type"\s*:\s*"assistant"/g) ?? []).length;
+    breakdown.toolUses       = (text.match(/"type"\s*:\s*"tool_use"/g) ?? []).length;
+    breakdown.toolResults    = (text.match(/"type"\s*:\s*"tool_result"/g) ?? []).length;
+    breakdown.systemReminders = (text.match(/<system-reminder>/g) ?? []).length;
+    // Current context size = input + cache_read + cache_create on the LAST
+    // usage block. Each assistant message's usage describes the context
+    // window for THAT call; summing across calls double-counts cached
+    // prefixes and explodes past the real ceiling. Take the most recent.
+    const re = /"usage"\s*:\s*\{([^}]+)\}/g;
+    const grab = (blob, key) => {
+      const km = blob.match(new RegExp(`"${key}"\\s*:\\s*(\\d+)`));
+      return km ? Number(km[1]) : 0;
+    };
+    let lastBlob = null;
+    for (const m of text.matchAll(re)) lastBlob = m[1];
+    if (lastBlob) {
+      breakdown.currentContextTokens =
+        grab(lastBlob, "input_tokens") +
+        grab(lastBlob, "cache_read_input_tokens") +
+        grab(lastBlob, "cache_creation_input_tokens");
+    }
+    return breakdown;
+  } catch { return null; }
+}
+/** Encode an absolute path the way CC stores it under
+ *  ~/.claude/projects/<slug>/. Drive letters, colons, and path separators
+ *  are flattened to "-" so the slug survives as a single directory name. */
+function ccProjectSlug(cwd) {
+  if (!cwd) return "";
+  // Replace path separators and the Windows drive colon. Match CC's own
+  // encoding: every \\ /  :  →  -  (no collapsing of adjacent dashes).
+  return resolve(cwd).replace(/[\\/:]/g, "-");
+}
+async function scanClaudeMdFiles(cwd) {
+  if (!cwd || typeof cwd !== "string") return [];
+  const found = [];
+  const seen = new Set();
+  const home = homedir();
+  const push = async (p) => {
+    if (seen.has(p)) return;
+    seen.add(p);
+    try {
+      const s = await stat(p);
+      if (s.isFile() && s.size > 0) found.push({ path: p, bytes: s.size });
+    } catch {}
+  };
+  // Walk up from cwd to filesystem root. At each dir, check for the
+  // canonical CC memory filenames plus CLAUDE.local.md (user-private).
+  let dir = resolve(cwd);
+  for (let depth = 0; depth < 16; depth++) {
+    for (const rel of [
+      "CLAUDE.md",
+      "CLAUDE.local.md",
+      join(".claude", "CLAUDE.md"),
+      join(".claude", "CLAUDE.local.md"),
+    ]) {
+      await push(join(dir, rel));
+    }
+    const parent = pdirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  // User-global memory.
+  await push(join(home, ".claude", "CLAUDE.md"));
+  await push(join(home, ".claude", "CLAUDE.local.md"));
+  // Per-project auto-memory: ~/.claude/projects/<slug>/memory/*.md
+  // (plus MEMORY.md index). CC injects these into context for sessions
+  // whose cwd matches the slug.
+  const slug = ccProjectSlug(cwd);
+  if (slug) {
+    const memDir = join(home, ".claude", "projects", slug, "memory");
+    try {
+      const entries = await readdir(memDir);
+      for (const f of entries) {
+        if (f.toLowerCase().endsWith(".md")) await push(join(memDir, f));
+      }
+    } catch {}
+  }
+  return found;
+}
+function maybeResolveContext(payload) {
+  if (!payload || typeof payload !== "object") return;
+  const sid = payload.session_id;
+  const tp = payload.transcript_path;
+  const cwd = payload.cwd;
+  if (!sid || !tp) return;
+  if (pendingContextReads.has(sid)) return;
+  const now = Date.now();
+  const last = lastContextReadAt.get(sid) ?? 0;
+  if (now - last < CONTEXT_READ_THROTTLE_MS) return;
+  lastContextReadAt.set(sid, now);
+  pendingContextReads.add(sid);
+  Promise.all([readContextFromTranscript(tp), scanClaudeMdFiles(cwd)])
+    .then(([breakdown, claudeMdFiles]) => {
+      if (!breakdown && (!claudeMdFiles || claudeMdFiles.length === 0)) return;
+      pushEvent({
+        hook_event_name: "ContextObserved",
+        session_id: sid,
+        context: {
+          ...(breakdown ?? {}),
+          claudeMdFiles: claudeMdFiles ?? [],
+        },
+      }, "internal");
+    })
+    .catch(() => {})
+    .finally(() => pendingContextReads.delete(sid));
+}
 function pushEvent(raw, source, opts = {}) {
   // Synchronous enrichment: if we already know this session's model, stamp
   // it on the payload so the client's recursive scanner picks it up.
@@ -235,6 +374,7 @@ function pushEvent(raw, source, opts = {}) {
   if (source === "hook" && !opts.replay) {
     maybeResolveModel(raw);
     maybeResolveUsage(raw);
+    maybeResolveContext(raw);
   }
   return evt;