agenthud 0.8.4 → 0.9.0

package/dist/templates/summary-prompt.md

@@ -0,0 +1,12 @@
+The following is an activity log of work done with Claude Code. Summarize it concisely in English using the format below.
+
+## Completed Work
+- (What was accomplished — focus on Response entries)
+
+## Notable Changes
+- (Which files were modified and how — from Edit/Write entries)
+
+## Commits
+- (Summary of the ◆ commit lines)
+
+Activity log:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenthud",
-  "version": "0.8.4",
+  "version": "0.9.0",
   "description": "CLI tool to monitor agent status in real-time. Works with Claude Code, multi-agent workflows, and any AI agent system.",
   "type": "module",
   "main": "dist/index.js",

package/scripts/diff-heap.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// Compare two heap snapshots and show which object types grew the most.
+
+import { readFileSync } from "node:fs";
+
+const earlyPath = process.argv[2] ?? "/tmp/agenthud-early.heapsnapshot";
+const latePath = process.argv[3] ?? "/tmp/agenthud-late.heapsnapshot";
+
+interface Snapshot {
+  snapshot: {
+    node_count: number;
+    meta: {
+      node_fields: string[];
+      node_types: (string | string[])[];
+    };
+  };
+  nodes: number[];
+  strings: string[];
+}
+
+function countByType(path: string): Map<string, { count: number; size: number }> {
+  const raw = JSON.parse(readFileSync(path, "utf-8")) as Snapshot;
+  const fields = raw.snapshot.meta.node_fields;
+  const typeEnum = raw.snapshot.meta.node_types[fields.indexOf("type")] as string[];
+  const fieldCount = fields.length;
+  const nameIdx = fields.indexOf("name");
+  const typeIdx = fields.indexOf("type");
+  const sizeIdx = fields.indexOf("self_size");
+
+  const counts = new Map<string, { count: number; size: number }>();
+  for (let i = 0; i < raw.nodes.length; i += fieldCount) {
+    const type = typeEnum[raw.nodes[i + typeIdx]];
+    const name = raw.strings[raw.nodes[i + nameIdx]];
+    const size = raw.nodes[i + sizeIdx];
+    const key = `${type}|${name}`;
+    const entry = counts.get(key) ?? { count: 0, size: 0 };
+    entry.count++;
+    entry.size += size;
+    counts.set(key, entry);
+  }
+  return counts;
+}
+
+const early = countByType(earlyPath);
+const late = countByType(latePath);
+
+interface Diff {
+  key: string;
+  earlyCount: number;
+  lateCount: number;
+  countDelta: number;
+  sizeDelta: number;
+}
+const diffs: Diff[] = [];
+
+for (const [key, lateVal] of late) {
+  const earlyVal = early.get(key) ?? { count: 0, size: 0 };
+  diffs.push({
+    key,
+    earlyCount: earlyVal.count,
+    lateCount: lateVal.count,
+    countDelta: lateVal.count - earlyVal.count,
+    sizeDelta: lateVal.size - earlyVal.size,
+  });
+}
+
+diffs.sort((a, b) => b.sizeDelta - a.sizeDelta);
+console.log("Top growers by total size delta:");
+console.log("size_delta_kb\tcount_delta\tearly\tlate\ttype|name");
+for (const d of diffs.slice(0, 40)) {
+  console.log(
+    `${(d.sizeDelta / 1024).toFixed(0).padStart(8)}\t${d.countDelta.toString().padStart(8)}\t${d.earlyCount.toString().padStart(5)}\t${d.lateCount.toString().padStart(5)}\t${d.key}`,
+  );
+}

package/scripts/memcheck-minimal.tsx

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// Minimal Ink test: only spinner-style re-renders, no other state.
+
+import { Text } from "ink";
+import { render } from "ink-testing-library";
+import React, { useEffect, useState } from "react";
+
+const seconds = Number(process.argv[2] ?? 60);
+const mb = (b: number) => (b / 1024 / 1024).toFixed(1);
+const printMem = (label: string) => {
+  const m = process.memoryUsage();
+  console.log(
+    `${label.padEnd(20)} rss=${mb(m.rss)}MB heap=${mb(m.heapUsed)}/${mb(m.heapTotal)}MB ext=${mb(m.external)}MB`,
+  );
+};
+
+function App() {
+  const [i, setI] = useState(0);
+  useEffect(() => {
+    const t = setInterval(() => setI((v) => v + 1), 100);
+    return () => clearInterval(t);
+  }, []);
+  return React.createElement(Text, null, `tick ${i}`);
+}
+
+printMem("start");
+const instance = render(React.createElement(App));
+printMem("after render");
+
+const iv = setInterval(() => {
+  if (global.gc) global.gc();
+  printMem(`t=${process.uptime().toFixed(0)}s`);
+}, 5_000);
+
+setTimeout(() => {
+  clearInterval(iv);
+  instance.unmount();
+  if (global.gc) global.gc();
+  printMem("end");
+  process.exit(0);
+}, seconds * 1000);

package/scripts/memcheck-ui.tsx

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// Render App with ink-testing-library and watch memory while time passes.
+// Spinner re-renders every 100ms, so this simulates the watch loop.
+
+import { writeHeapSnapshot } from "node:v8";
+import { render } from "ink-testing-library";
+import React from "react";
+import { App } from "../src/ui/App.js";
+
+const seconds = Number(process.argv[2] ?? 60);
+const mb = (b: number) => (b / 1024 / 1024).toFixed(1);
+
+const printMem = (label: string) => {
+  const m = process.memoryUsage();
+  console.log(
+    `${label.padEnd(20)} rss=${mb(m.rss)}MB heap=${mb(m.heapUsed)}/${mb(m.heapTotal)}MB ext=${mb(m.external)}MB`,
+  );
+};
+
+printMem("start");
+
+const instance = render(React.createElement(App, { mode: "watch" }));
+
+printMem("after render");
+
+const interval = setInterval(() => {
+  if (global.gc) global.gc();
+  printMem(`t=${process.uptime().toFixed(0)}s`);
+}, 5_000);
+
+// Snapshot at start (after warm-up) and end so we can diff
+setTimeout(() => {
+  if (global.gc) global.gc();
+  const p = writeHeapSnapshot("/tmp/agenthud-early.heapsnapshot");
+  console.log(`early snapshot: ${p}`);
+}, 5_000);
+
+setTimeout(() => {
+  clearInterval(interval);
+  if (global.gc) global.gc();
+  const p = writeHeapSnapshot("/tmp/agenthud-late.heapsnapshot");
+  console.log(`late snapshot: ${p}`);
+  instance.unmount();
+  if (global.gc) global.gc();
+  printMem("end");
+  process.exit(0);
+}, seconds * 1000);

package/scripts/memcheck.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// Run data-layer loop and watch memory growth.
+// Usage: tsx scripts/memcheck.ts [iterations]
+
+import { loadGlobalConfig } from "../src/config/globalConfig.js";
+import { parseGitCommits } from "../src/data/gitCommits.js";
+import { parseSessionHistory } from "../src/data/sessionHistory.js";
+import { discoverSessions } from "../src/data/sessions.js";
+
+const iterations = Number(process.argv[2] ?? 1000);
+
+const mb = (b: number) => (b / 1024 / 1024).toFixed(1);
+const printMem = (label: string) => {
+  const m = process.memoryUsage();
+  console.log(
+    `${label.padEnd(20)} rss=${mb(m.rss)}MB heap=${mb(m.heapUsed)}/${mb(m.heapTotal)}MB ext=${mb(m.external)}MB`,
+  );
+};
+
+const config = loadGlobalConfig();
+printMem("start");
+
+const tree = discoverSessions(config);
+const session = tree.sessions[0];
+if (!session) {
+  console.error("No sessions found");
+  process.exit(1);
+}
+console.log(`Using session: ${session.projectName}/${session.id}`);
+console.log(`File: ${session.filePath}`);
+
+printMem("after discover");
+
+for (let i = 1; i <= iterations; i++) {
+  // Simulate what refresh() + git effect do every cycle
+  discoverSessions(config);
+  parseSessionHistory(session.filePath);
+  if (session.projectPath) {
+    const today = new Date();
+    const day = new Date(today.getFullYear(), today.getMonth(), today.getDate());
+    parseGitCommits(session.projectPath, day);
+  }
+
+  if (i % 100 === 0) {
+    if (global.gc) global.gc();
+    printMem(`iter ${i}`);
+  }
+}
+
+if (global.gc) global.gc();
+printMem("end");