npm - agent-dag - Versions diffs - 1.0.0 - Mend

agent-dag 1.0.0

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 (10) hide show

package/LICENSE +21 -0
package/README.md +31 -0
package/bin/ccgraph.js +121 -0
package/dist/web/assets/index-CbRJ5PCq.css +1 -0
package/dist/web/assets/index-ChObhKsa.js +57 -0
package/dist/web/index.html +14 -0
package/hook/hook.js +96 -0
package/package.json +58 -0
package/src/server/index.mjs +250 -0
package/src/server/installer.mjs +116 -0

package/dist/web/index.html ADDED Viewed

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>ccgraph</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-ChObhKsa.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CbRJ5PCq.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/hook/hook.js ADDED Viewed

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+// ccgraph hook forwarder. Claude Code invokes this as a command hook.
+// It reads stdin (CC event JSON), finds the matching ccgraph server via
+// per-workspace discovery files in ~/.claude/ccgraph/, and forwards the
+// payload to it via HTTP POST. Dead instances are cleaned up.
+"use strict";
+const fs = require("fs");
+const path = require("path");
+const http = require("http");
+const os = require("os");
+// Hard cap so a stuck server can never wedge Claude Code.
+setTimeout(() => process.exit(0), 1500);
+const DIR = path.join(os.homedir(), ".claude", "ccgraph");
+const IS_WIN = process.platform === "win32";
+function normPath(p) {
+  let r = path.resolve(p);
+  try { r = fs.realpathSync(r); } catch {}
+  return r;
+}
+function isAlive(pid) {
+  // process.kill(pid, 0) works on Windows in Node 18+:
+  //   ESRCH => no such process, EPERM => exists but not ours (still alive).
+  try { process.kill(pid, 0); return true; }
+  catch (e) { return e && e.code === "EPERM"; }
+}
+let input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", c => { input += c; });
+process.stdin.on("end", () => {
+  let cwd;
+  try { cwd = JSON.parse(input).cwd; } catch { return process.exit(0); }
+  if (!cwd) return process.exit(0);
+  const resolvedCwd = normPath(cwd);
+  let files;
+  try {
+    files = fs.readdirSync(DIR).filter(f => f.endsWith(".json"));
+  } catch { return process.exit(0); }
+  if (!files.length) return process.exit(0);
+  const matches = [];
+  for (const file of files) {
+    let d;
+    try { d = JSON.parse(fs.readFileSync(path.join(DIR, file), "utf8")); } catch { continue; }
+    if (typeof d.workspace !== "string" || !d.pid || !d.port) continue;
+    if (!isAlive(d.pid)) {
+      try { fs.unlinkSync(path.join(DIR, file)); } catch {}
+      continue;
+    }
+    // Empty workspace = match-all (used by `ccgraph --all`).
+    if (d.workspace === "") {
+      matches.push({ d, wsLen: 0 });
+      continue;
+    }
+    const ws = normPath(d.workspace);
+    if (resolvedCwd === ws || resolvedCwd.startsWith(ws + path.sep)) {
+      matches.push({ d, wsLen: ws.length });
+    }
+  }
+  if (!matches.length) return process.exit(0);
+  // Most specific workspace wins.
+  matches.sort((a, b) => b.wsLen - a.wsLen);
+  const bestLen = matches[0].wsLen;
+  const targets = matches.filter(m => m.wsLen === bestLen);
+  let pending = targets.length;
+  const done = () => { if (--pending <= 0) process.exit(0); };
+  for (const { d } of targets) {
+    let settled = false;
+    const finish = () => { if (settled) return; settled = true; done(); };
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port: d.port,
+      path: "/api/event",
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      timeout: 1000,
+    }, res => { res.resume(); res.on("end", finish); });
+    req.on("error", finish);
+    req.on("timeout", () => req.destroy());
+    req.write(input);
+    req.end();
+  }
+});

package/package.json ADDED Viewed

@@ -0,0 +1,58 @@
+{
+  "name": "agent-dag",
+  "version": "1.0.0",
+  "description": "Live DAG of Claude Code agents — watch parallel subagents fork, call tools, and return on one calm canvas.",
+  "type": "module",
+  "bin": {
+    "agent-dag": "bin/ccgraph.js"
+  },
+  "files": [
+    "bin",
+    "hook",
+    "src/server",
+    "dist/web",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "dev:web": "vite",
+    "build:web": "vite build",
+    "dev:server": "node src/server/index.mjs",
+    "start": "node bin/ccgraph.js",
+    "build": "vite build",
+    "prepublishOnly": "vite build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude-code",
+    "claude",
+    "anthropic",
+    "agents",
+    "subagents",
+    "visualization",
+    "dashboard",
+    "hooks",
+    "observability",
+    "dag",
+    "graph",
+    "live"
+  ],
+  "author": "Bargan Constantin",
+  "license": "MIT",
+  "dependencies": {
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.4",
+    "dagre": "^0.8.5",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "reactflow": "^11.11.4",
+    "typescript": "^5.6.3",
+    "vite": "^6.0.0"
+  }
+}

package/src/server/index.mjs ADDED Viewed

@@ -0,0 +1,250 @@
+// ccgraph server: HTTP ingest + SSE broadcast + static file serving.
+// Single-file pure Node HTTP server, zero deps.
+import { createServer } from "node:http";
+import { readFile, stat, mkdir, appendFile, open, truncate, readdir, unlink } from "node:fs/promises";
+import { createReadStream, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { extname, join, resolve, dirname as pdirname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname } from "node:path";
+import { createInterface } from "node:readline";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = resolve(__dirname, "..", "..");
+const WEB_DIST = resolve(PKG_ROOT, "dist", "web");
+const MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js":   "application/javascript; charset=utf-8",
+  ".mjs":  "application/javascript; charset=utf-8",
+  ".css":  "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg":  "image/svg+xml",
+  ".png":  "image/png",
+  ".jpg":  "image/jpeg",
+  ".woff2": "font/woff2",
+  ".map":  "application/json",
+};
+const MAX_BUFFER = 2000;            // recent events kept for late SSE subscribers
+const events = [];                  // ring buffer
+let nextSeq = 1;
+const sseClients = new Set();       // res handles
+let persistPath = null;             // absolute path to events.jsonl, or null
+function pushEvent(raw, source, opts = {}) {
+  const seq = nextSeq++;
+  const evt = {
+    seq,
+    receivedAt: opts.receivedAt ?? Date.now(),
+    source,
+    payload: raw,
+  };
+  events.push(evt);
+  if (events.length > MAX_BUFFER) events.splice(0, events.length - MAX_BUFFER);
+  const line = `id: ${seq}\nevent: hook\ndata: ${JSON.stringify(evt)}\n\n`;
+  for (const res of sseClients) {
+    try { res.write(line); } catch {}
+  }
+  if (persistPath && !opts.replay) {
+    // Fire-and-forget append. JSONL = newline-delimited JSON.
+    appendFile(persistPath, JSON.stringify(evt) + "\n", "utf8").catch(() => {});
+  }
+  return evt;
+}
+async function replayLog(filePath) {
+  if (!existsSync(filePath)) return 0;
+  let count = 0;
+  const rl = createInterface({ input: createReadStream(filePath, { encoding: "utf8" }) });
+  for await (const line of rl) {
+    if (!line) continue;
+    try {
+      const evt = JSON.parse(line);
+      if (evt && typeof evt === "object" && evt.payload) {
+        pushEvent(evt.payload, evt.source ?? "replay", { receivedAt: evt.receivedAt, replay: true });
+        count++;
+      }
+    } catch { /* skip corrupt line */ }
+  }
+  return count;
+}
+function send(res, status, body, headers = {}) {
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+    ...headers,
+  });
+  res.end(typeof body === "string" ? body : JSON.stringify(body));
+}
+async function serveStatic(req, res, url) {
+  // Strip leading slash, default to index.html
+  let rel = url.pathname.replace(/^\/+/, "");
+  if (rel === "" || rel.endsWith("/")) rel = `${rel}index.html`;
+  const filePath = join(WEB_DIST, rel);
+  if (!filePath.startsWith(WEB_DIST)) return send(res, 403, { error: "forbidden" });
+  try {
+    const s = await stat(filePath);
+    if (s.isDirectory()) return send(res, 404, { error: "not found" });
+    const buf = await readFile(filePath);
+    res.writeHead(200, {
+      "Content-Type": MIME[extname(filePath).toLowerCase()] ?? "application/octet-stream",
+      "Cache-Control": "no-cache",
+    });
+    res.end(buf);
+  } catch {
+    // SPA fallback to index.html for client-side routes
+    try {
+      const idx = await readFile(join(WEB_DIST, "index.html"));
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(idx);
+    } catch {
+      send(res, 404, { error: "ui not built. run `pnpm build` or `npm run build`." });
+    }
+  }
+}
+function handleEventIngest(req, res) {
+  let body = "";
+  req.setEncoding("utf8");
+  req.on("data", c => {
+    body += c;
+    if (body.length > 5_000_000) {
+      req.destroy();
+    }
+  });
+  req.on("end", () => {
+    let parsed;
+    try { parsed = JSON.parse(body); }
+    catch { return send(res, 400, { error: "invalid json" }); }
+    const evt = pushEvent(parsed, "hook");
+    send(res, 200, { ok: true, seq: evt.seq });
+  });
+  req.on("error", () => send(res, 400, { error: "bad request" }));
+}
+function handleSse(req, res) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache, no-transform",
+    "Connection": "keep-alive",
+    "X-Accel-Buffering": "no",
+  });
+  res.write(`retry: 1500\n\n`);
+  // Resume: replay events after Last-Event-ID
+  const lastId = Number(req.headers["last-event-id"] ?? 0);
+  for (const e of events) {
+    if (e.seq <= lastId) continue;
+    res.write(`id: ${e.seq}\nevent: hook\ndata: ${JSON.stringify(e)}\n\n`);
+  }
+  sseClients.add(res);
+  const ping = setInterval(() => {
+    try { res.write(`: ping\n\n`); } catch {}
+  }, 15000);
+  req.on("close", () => {
+    clearInterval(ping);
+    sseClients.delete(res);
+  });
+}
+function handleHealth(_req, res) {
+  send(res, 200, {
+    ok: true,
+    name: "ccgraph",
+    seq: nextSeq - 1,
+    clients: sseClients.size,
+    uptimeMs: Math.round(process.uptime() * 1000),
+  });
+}
+function isProcessAlive(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch (e) { return e && e.code === "EPERM"; }
+}
+async function sweepStaleDiscovery() {
+  const dir = join(homedir(), ".claude", "ccgraph");
+  let files;
+  try { files = await readdir(dir); } catch { return 0; }
+  let removed = 0;
+  for (const f of files) {
+    if (!f.endsWith(".json")) continue;
+    const p = join(dir, f);
+    try {
+      const d = JSON.parse(await readFile(p, "utf8"));
+      if (d && typeof d.pid === "number" && !isProcessAlive(d.pid)) {
+        await unlink(p).catch(() => {});
+        removed++;
+      }
+    } catch { /* corrupt — leave it */ }
+  }
+  return removed;
+}
+export async function startServer({ port = 4317, host = "127.0.0.1", persist = null } = {}) {
+  const removed = await sweepStaleDiscovery();
+  if (removed > 0) console.log(`  swept ${removed} stale discovery file(s)`);
+  if (persist) {
+    persistPath = resolve(persist);
+    try { await mkdir(pdirname(persistPath), { recursive: true }); } catch {}
+    const replayed = await replayLog(persistPath);
+    if (replayed > 0) {
+      // Don't broadcast replays as live; SSE clients catch up via Last-Event-ID
+      // already. Just keep the buffer + seq counter primed.
+    }
+  }
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? host}`);
+    if (req.method === "POST" && url.pathname === "/api/event") return handleEventIngest(req, res);
+    if (req.method === "GET"  && url.pathname === "/api/health") return handleHealth(req, res);
+    if (req.method === "GET"  && url.pathname === "/events")     return handleSse(req, res);
+    if (req.method === "GET" && url.pathname === "/api/events") {
+      const since = Number(url.searchParams.get("since") ?? 0);
+      return send(res, 200, events.filter(e => e.seq > since));
+    }
+    // POST /api/clear — wipe in-memory buffer + persistence file (UI reset)
+    if (req.method === "POST" && url.pathname === "/api/clear") {
+      events.length = 0;
+      if (persistPath) truncate(persistPath, 0).catch(() => {});
+      pushEvent({ hook_event_name: "__clear", cwd: "" }, "internal");
+      return send(res, 200, { ok: true });
+    }
+    if (req.method === "GET") return serveStatic(req, res, url);
+    send(res, 405, { error: "method not allowed" });
+  });
+  return new Promise((resolveStart, rejectStart) => {
+    server.once("error", rejectStart);
+    server.listen(port, host, () => {
+      server.removeListener("error", rejectStart);
+      resolveStart(server);
+    });
+  });
+}
+// Allow running this file directly for dev.
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const port = Number(process.env.CCGRAPH_PORT ?? 4317);
+  startServer({ port }).then(s => {
+    const addr = s.address();
+    const p = typeof addr === "object" && addr ? addr.port : port;
+    console.log(`ccgraph server: http://127.0.0.1:${p}`);
+  }).catch(e => {
+    console.error("ccgraph server failed:", e.message);
+    process.exit(1);
+  });
+}

package/src/server/installer.mjs ADDED Viewed

@@ -0,0 +1,116 @@
+// Idempotent hook installer for ~/.claude/settings.json.
+// Adds a single command-hook entry per CC hook event pointing at our forwarder.
+// Re-runs are safe (entries are tagged with __ccgraph and de-duped).
+import { readFile, writeFile, mkdir, copyFile, unlink } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = resolve(__dirname, "..", "..");
+const HOME = homedir();
+const CLAUDE_DIR = join(HOME, ".claude");
+const SETTINGS = join(CLAUDE_DIR, "settings.json");
+const CCGRAPH_DIR = join(CLAUDE_DIR, "ccgraph");
+export const HOOK_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "SubagentStart",
+  "SubagentStop",
+  "Stop",
+  "SessionEnd",
+  "Notification",
+];
+const MARK_KEY = "__ccgraph";
+function hookCommand(installedHookPath) {
+  // process.execPath = absolute path to current node (works on Win + *nix).
+  const node = process.execPath;
+  return `"${node}" "${installedHookPath}"`;
+}
+async function ensureDir(p) {
+  if (!existsSync(p)) await mkdir(p, { recursive: true });
+}
+async function readJsonSafe(p) {
+  try { return JSON.parse(await readFile(p, "utf8")); } catch { return null; }
+}
+async function installHookScript() {
+  await ensureDir(CCGRAPH_DIR);
+  const src = join(PKG_ROOT, "hook", "hook.js");
+  const dst = join(CCGRAPH_DIR, "hook.js");
+  await copyFile(src, dst);
+  return dst;
+}
+function buildHookEntry(command) {
+  return {
+    [MARK_KEY]: true,
+    hooks: [{ type: "command", command, timeout: 2 }],
+  };
+}
+function dedupeOurEntries(group) {
+  if (!Array.isArray(group)) return [];
+  return group.filter(g => !(g && typeof g === "object" && g[MARK_KEY] === true));
+}
+export async function installHooks() {
+  const hookPath = await installHookScript();
+  const command = hookCommand(hookPath);
+  await ensureDir(CLAUDE_DIR);
+  const current = (await readJsonSafe(SETTINGS)) ?? {};
+  current.hooks = current.hooks ?? {};
+  for (const evt of HOOK_EVENTS) {
+    const cleaned = dedupeOurEntries(current.hooks[evt]);
+    cleaned.push(buildHookEntry(command));
+    current.hooks[evt] = cleaned;
+  }
+  await writeFile(SETTINGS, JSON.stringify(current, null, 2) + "\n", "utf8");
+  return { settingsPath: SETTINGS, hookPath, events: HOOK_EVENTS };
+}
+export async function uninstallHooks() {
+  const current = await readJsonSafe(SETTINGS);
+  if (!current?.hooks) return { changed: false };
+  let changed = false;
+  for (const evt of Object.keys(current.hooks)) {
+    const cleaned = dedupeOurEntries(current.hooks[evt]);
+    if (cleaned.length !== (current.hooks[evt]?.length ?? 0)) changed = true;
+    if (cleaned.length === 0) delete current.hooks[evt];
+    else current.hooks[evt] = cleaned;
+  }
+  if (changed) await writeFile(SETTINGS, JSON.stringify(current, null, 2) + "\n", "utf8");
+  return { changed };
+}
+export async function writeDiscovery({ port, workspace }) {
+  await ensureDir(CCGRAPH_DIR);
+  const file = join(CCGRAPH_DIR, `${process.pid}.json`);
+  const data = {
+    pid: process.pid,
+    port,
+    workspace: workspace ?? "",
+    startedAt: new Date().toISOString(),
+  };
+  await writeFile(file, JSON.stringify(data, null, 2) + "\n", "utf8");
+  return file;
+}
+export async function removeDiscovery(file) {
+  try { await unlink(file); } catch {}
+}
+export { CCGRAPH_DIR, SETTINGS };