agmon 0.0.0-stage → 0.1.0

package/src/lib/watchers/antigravityWatcher.js

@@ -0,0 +1,180 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { normalizeTrace } from "../traceContract.js";
+
+const TOOL_MAP = {
+  view_file: "read",
+  read_file: "read",
+  replace_file_content: "edit",
+  write_to_file: "edit",
+  call_mcp_tool: "mcp",
+  list_resources: "mcp",
+  invoke_subagent: "agent",
+  grep_search: "search",
+  list_dir: "read",
+  find_by_name: "read",
+  define_subagent: "agent",
+};
+
+function normalizeToolCall(tc) {
+  if (!tc || !tc.name) return { type: "mcp", detail: null };
+  const name = tc.name;
+  const args = tc.args || {};
+
+  // 1. MCP Tools inspection
+  if (name === "call_mcp_tool") {
+    const srv = String(args.ServerName || "").toLowerCase();
+    const tool = String(args.ToolName || "").toLowerCase();
+    if (srv.includes("gitnexus") || tool.includes("cypher") || tool.includes("pdg_query") || tool.includes("impact")) {
+      return { type: "gitnexus", detail: `GitNexus: ${tool}` };
+    }
+    if (srv.includes("playwright") || srv.includes("browser") || tool.startsWith("browser_")) {
+      return { type: "browser", detail: `Browser: ${tool}` };
+    }
+    return { type: "mcp", detail: `MCP: ${srv}/${tool}` };
+  }
+
+  // 2. Terminal commands inspection
+  if (name === "run_command") {
+    const cmd = String(args.CommandLine || "").trim();
+    const cmdLower = cmd.toLowerCase();
+    if (cmdLower.startsWith("docker") || cmdLower.includes("docker exec") || cmdLower.includes("docker-compose")) {
+      return { type: "docker", detail: cmd.length > 50 ? `${cmd.slice(0, 47)}...` : cmd };
+    }
+    if (cmdLower.startsWith("git ") || cmdLower.startsWith("gh ") || cmdLower.includes("git commit") || cmdLower.includes("git push")) {
+      return { type: "git", detail: cmd.length > 50 ? `${cmd.slice(0, 47)}...` : cmd };
+    }
+    if (cmdLower.includes("gitnexus")) {
+      return { type: "gitnexus", detail: cmd.length > 50 ? `${cmd.slice(0, 47)}...` : cmd };
+    }
+    return { type: "bash", detail: cmd.length > 50 ? `${cmd.slice(0, 47)}...` : cmd };
+  }
+
+  // 3. Native tools mapping
+  const mapped = TOOL_MAP[name];
+  const target = args.TargetFile || args.AbsolutePath || args.query || "";
+  const detail = target ? `${name}: ${path.basename(target)}` : name;
+
+  if (mapped) return { type: mapped, detail };
+  if (name.includes("read") || name.includes("find") || name.includes("dir") || name.includes("list")) return { type: "read", detail };
+  if (name.includes("edit") || name.includes("write") || name.includes("patch")) return { type: "edit", detail };
+  if (name.includes("search") || name.includes("grep")) return { type: "search", detail };
+  if (name.includes("agent") || name.includes("message")) return { type: "agent", detail };
+
+  return { type: "mcp", detail };
+}
+
+export async function getAntigravityTraces(maxAgeMs = 2 * 60 * 60 * 1000) {
+  const homeDir = os.homedir();
+  const brainDir = path.join(homeDir, ".gemini", "antigravity-cli", "brain");
+
+  try {
+    const entries = await fs.readdir(brainDir, { withFileTypes: true });
+    const now = Date.now();
+    const traces = [];
+
+    for (const ent of entries) {
+      if (!ent.isDirectory()) continue;
+      const convId = ent.name;
+      const transcriptPath = path.join(brainDir, convId, ".system_generated", "logs", "transcript.jsonl");
+
+      try {
+        const stat = await fs.stat(transcriptPath);
+        const mtime = stat.mtimeMs;
+        if (now - mtime > maxAgeMs) continue;
+
+        const content = await fs.readFile(transcriptPath, "utf-8");
+        const lines = content.trim().split("\n");
+        if (lines.length === 0) continue;
+
+        let totalIn = 0;
+        let totalOut = 0;
+        let totalCached = 0;
+        let lastToolEntry = null;
+        let lastStep = null;
+        const toolSet = new Set();
+        let firstTime = null;
+        let lastTime = null;
+        let activeCommandDetail = null;
+        let detectedCwd = null;
+
+        for (const line of lines) {
+          if (!line) continue;
+          try {
+            const entry = JSON.parse(line);
+            if (!firstTime && entry.created_at) firstTime = new Date(entry.created_at).getTime();
+            if (entry.created_at) lastTime = new Date(entry.created_at).getTime();
+
+            if (entry.input_tokens) totalIn += entry.input_tokens;
+            if (entry.output_tokens) totalOut += entry.output_tokens;
+            if (entry.cache_read_tokens) totalCached += entry.cache_read_tokens;
+
+            if (Array.isArray(entry.tool_calls) && entry.tool_calls.length > 0) {
+              lastToolEntry = entry;
+              for (const tc of entry.tool_calls) {
+                if (tc.args?.Cwd && !detectedCwd) detectedCwd = tc.args.Cwd;
+                if (!detectedCwd && (tc.args?.TargetFile || tc.args?.AbsolutePath)) {
+                  const p = tc.args.TargetFile || tc.args.AbsolutePath;
+                  if (p.includes("/Projects/")) detectedCwd = p.split("/").slice(0, 5).join("/");
+                }
+                const { type, detail } = normalizeToolCall(tc);
+                if (type) toolSet.add(type);
+                if (detail) activeCommandDetail = detail;
+              }
+            }
+            lastStep = entry;
+          } catch {
+            // ignore malformed line
+          }
+        }
+
+        const isRecent = (now - mtime) < 45 * 1000;
+        let state = "done";
+        if (isRecent) {
+          if (lastStep && lastStep.type === "USER_INPUT") state = "pending";
+          else if (lastToolEntry && lastToolEntry.status === "RUNNING") state = "streaming";
+          else state = "streaming";
+        }
+
+        let activeTool = null;
+        if (lastToolEntry && Array.isArray(lastToolEntry.tool_calls) && lastToolEntry.tool_calls.length > 0) {
+          const lastTc = lastToolEntry.tool_calls[lastToolEntry.tool_calls.length - 1];
+          activeTool = normalizeToolCall(lastTc).type;
+        }
+
+        const elapsedMs = (lastTime && firstTime) ? Math.max(0, lastTime - firstTime) : (now - mtime);
+        const rawFolder = detectedCwd ? path.basename(detectedCwd) : `agy-${convId.slice(0, 6)}`;
+        const folderName = rawFolder.replace(/["'\\]/g, "").trim();
+
+        traces.push(normalizeTrace({
+          traceId: `agy-${convId.slice(0, 8)}`,
+          cli: "antigravity",
+          connectionId: `Antigravity (${convId.slice(0, 6)})`,
+          account: folderName,
+          model: "gemini-2.5-pro",
+          provider: "gemini",
+          state,
+          startedAt: firstTime || (now - elapsedMs),
+          elapsedMs,
+          tokens: {
+            input: totalIn || 2500,
+            output: totalOut || 850,
+            cached: totalCached,
+          },
+          cost: 0,
+          status: "200",
+          tools: Array.from(toolSet),
+          activeTool,
+          currentCommand: activeCommandDetail,
+        }));
+      } catch {
+        // file missing or unreadable
+      }
+    }
+
+    return traces;
+  } catch {
+    return [];
+  }
+}

package/src/lib/watchers/claudeWatcher.js

@@ -0,0 +1,190 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { normalizeTrace } from "../traceContract.js";
+
+function normalizeClaudeTool(name, input = {}) {
+  const n = String(name || "").toLowerCase();
+  const cmd = String(input.command || "").trim();
+  const cmdLower = cmd.toLowerCase();
+
+  if (n === "bash") {
+    if (cmdLower.startsWith("docker") || cmdLower.includes("docker exec")) {
+      return { type: "docker", detail: cmd.length > 50 ? `${cmd.slice(0, 47)}...` : cmd };
+    }
+    if (cmdLower.startsWith("git ") || cmdLower.startsWith("gh ")) {
+      return { type: "git", detail: cmd.length > 50 ? `${cmd.slice(0, 47)}...` : cmd };
+    }
+    if (cmdLower.includes("gitnexus")) {
+      return { type: "gitnexus", detail: cmd.length > 50 ? `${cmd.slice(0, 47)}...` : cmd };
+    }
+    return { type: "bash", detail: cmd.length > 50 ? `${cmd.slice(0, 47)}...` : cmd };
+  }
+
+  if (n.includes("read") || n.includes("view") || n.includes("glob")) {
+    const file = input.file_path || input.path || "";
+    return { type: "read", detail: file ? `Read: ${path.basename(file)}` : "Read file" };
+  }
+
+  if (n.includes("edit") || n.includes("write") || n.includes("patch") || n.includes("replace")) {
+    const file = input.file_path || input.path || "";
+    return { type: "edit", detail: file ? `Edit: ${path.basename(file)}` : "Edit file" };
+  }
+
+  if (n.includes("grep") || n.includes("search")) {
+    return { type: "search", detail: input.pattern ? `Search: ${input.pattern}` : "Search" };
+  }
+
+  if (n.includes("agent") || n.includes("task")) {
+    return { type: "agent", detail: "Subagent Task" };
+  }
+
+  if (n.includes("browser") || n.includes("playwright")) {
+    return { type: "browser", detail: "Browser automation" };
+  }
+
+  if (n.includes("gitnexus")) {
+    return { type: "gitnexus", detail: "GitNexus query" };
+  }
+
+  return { type: "mcp", detail: name };
+}
+
+function detectProvider(modelName) {
+  const m = String(modelName || "").toLowerCase();
+  if (m.includes("claude")) return "anthropic";
+  if (m.includes("gemini")) return "gemini";
+  if (m.includes("gpt") || m.includes("o1") || m.includes("o3")) return "openai";
+  if (m.includes("minimax")) return "minimax";
+  if (m.includes("deepseek")) return "deepseek";
+  return "anthropic";
+}
+
+export async function getClaudeTraces(maxAgeMs = 3 * 60 * 60 * 1000) {
+  const homeDir = os.homedir();
+  const sessionsDir = path.join(homeDir, ".claude", "sessions");
+  const projectsDir = path.join(homeDir, ".claude", "projects");
+
+  try {
+    const sessionFiles = await fs.readdir(sessionsDir).catch(() => []);
+    const now = Date.now();
+    const traces = [];
+
+    for (const f of sessionFiles) {
+      if (!f.endsWith(".json")) continue;
+      try {
+        const rawMeta = await fs.readFile(path.join(sessionsDir, f), "utf-8");
+        const meta = JSON.parse(rawMeta);
+        const { pid, sessionId, cwd, startedAt, updatedAt, status, name } = meta;
+
+        // Skip very old sessions
+        const lastActive = updatedAt || startedAt || 0;
+        if (now - lastActive > maxAgeMs) continue;
+
+        // Find associated jsonl transcript in projects folder
+        let transcriptPath = null;
+        try {
+          const projectFolders = await fs.readdir(projectsDir);
+          for (const pf of projectFolders) {
+            const candidate = path.join(projectsDir, pf, `${sessionId}.jsonl`);
+            try {
+              await fs.access(candidate);
+              transcriptPath = candidate;
+              break;
+            } catch {
+              // try next
+            }
+          }
+        } catch {
+          // ignore
+        }
+
+        let totalIn = 0;
+        let totalOut = 0;
+        let totalCached = 0;
+        let model = "claude-3-7-sonnet";
+        let activeTool = null;
+        let activeCommand = null;
+        const toolSet = new Set();
+        let lastTimestamp = lastActive;
+
+        if (transcriptPath) {
+          try {
+            const content = await fs.readFile(transcriptPath, "utf-8");
+            const lines = content.trim().split("\n");
+            for (const line of lines) {
+              if (!line) continue;
+              try {
+                const entry = JSON.parse(line);
+                if (entry.timestamp) lastTimestamp = new Date(entry.timestamp).getTime();
+
+                const msg = entry.message;
+                if (msg) {
+                  if (msg.model) model = msg.model;
+                  const u = msg.usage;
+                  if (u) {
+                    if (u.input_tokens) totalIn += u.input_tokens;
+                    if (u.output_tokens) totalOut += u.output_tokens;
+                    if (u.cache_read_input_tokens) totalCached += u.cache_read_input_tokens;
+                  }
+
+                  if (Array.isArray(msg.content)) {
+                    for (const block of msg.content) {
+                      if (block.type === "tool_use") {
+                        const { type, detail } = normalizeClaudeTool(block.name, block.input);
+                        toolSet.add(type);
+                        activeTool = type;
+                        if (detail) activeCommand = detail;
+                      }
+                    }
+                  }
+                }
+              } catch {
+                // ignore malformed line
+              }
+            }
+          } catch {
+            // unreadable transcript
+          }
+        }
+
+        const isRecent = (now - lastActive) < 60 * 1000;
+        let state = "done";
+        if (status === "running" || status === "working") state = "streaming";
+        else if (isRecent) state = "streaming";
+        else if (status === "idle") state = "pending";
+
+        const workspaceName = cwd ? path.basename(cwd) : (name || "Claude Workspace");
+        const elapsedMs = Math.max(0, (lastTimestamp || now) - (startedAt || now));
+
+        traces.push(normalizeTrace({
+          traceId: `claude-${pid || sessionId.slice(0, 6)}`,
+          cli: "claude",
+          connectionId: `Claude (${name || pid})`,
+          account: workspaceName,
+          model,
+          provider: detectProvider(model),
+          state,
+          startedAt: startedAt || now,
+          elapsedMs,
+          tokens: {
+            input: totalIn || 3200,
+            output: totalOut || 1100,
+            cached: totalCached,
+          },
+          cost: 0,
+          status: "200",
+          tools: Array.from(toolSet),
+          activeTool,
+          currentCommand: activeCommand,
+        }));
+      } catch {
+        // ignore single session error
+      }
+    }
+
+    return traces;
+  } catch {
+    return [];
+  }
+}

package/src/lib/watchers/watcherManager.js

@@ -0,0 +1,41 @@
+import { getAntigravityTraces } from "./antigravityWatcher.js";
+import { getClaudeTraces } from "./claudeWatcher.js";
+import { extractProviders } from "../traceContract.js";
+
+/**
+ * WatcherManager aggregates traces across all installed CLI watchers
+ * (Antigravity, Claude Code, etc.) with automatic fallback and caching.
+ */
+let cachedTraces = [];
+let lastFetchTime = 0;
+const CACHE_TTL_MS = 1500; // 1.5s cache to avoid reading disks too frequently
+
+export async function getAllLiveTraces(force = false) {
+  const now = Date.now();
+  if (!force && now - lastFetchTime < CACHE_TTL_MS && cachedTraces.length > 0) {
+    return cachedTraces;
+  }
+
+  const [agyList, claudeList] = await Promise.all([
+    getAntigravityTraces().catch(() => []),
+    getClaudeTraces().catch(() => []),
+  ]);
+
+  const combined = [...agyList, ...claudeList];
+
+  // Sort: active/streaming/pending first, then by most recent startedAt
+  combined.sort((a, b) => {
+    const activeA = (a.state === "streaming" || a.state === "pending") ? 1 : 0;
+    const activeB = (b.state === "streaming" || b.state === "pending") ? 1 : 0;
+    if (activeA !== activeB) return activeB - activeA;
+    return (b.startedAt || 0) - (a.startedAt || 0);
+  });
+
+  cachedTraces = combined;
+  lastFetchTime = now;
+  return combined;
+}
+
+export function getProvidersFromTraces(traces) {
+  return extractProviders(traces);
+}