agenthud 0.8.4 → 0.8.5

package/README.md

@@ -130,6 +130,23 @@ Output is written to stdout in Markdown format:
 **`--include` types:** `response`, `bash`, `edit`, `thinking`, `read`, `glob`, `user`  
 Default: `response,bash,edit,thinking`
 
+## Summary
+
+Generate an LLM-based summary of a day's activity using the `claude` CLI:
+
+```bash
+agenthud summary                          # today
+agenthud summary --date 2026-05-14        # past date (cached on second run)
+agenthud summary --date 2026-05-14 --force # ignore cache
+agenthud summary --prompt "커밋만 요약해"  # override prompt
+```
+
+Results are saved to `~/.agenthud/summaries/YYYY-MM-DD.md`. Past dates are cached and returned instantly on re-run. Today's date is always regenerated since activity is still growing.
+
+**Prompt customization:** The summary uses `~/.agenthud/summary-prompt.md`, which is auto-created from a built-in template on first run. Edit it freely or override per-call with `--prompt`.
+
+**Requires:** [`@anthropic-ai/claude-code`](https://www.npmjs.com/package/@anthropic-ai/claude-code) installed and authenticated (`npm i -g @anthropic-ai/claude-code`).
+
 ## Configuration
 
 Optional. Create `~/.agenthud/config.yaml`:

package/dist/index.js

@@ -14,4 +14,5 @@ Error: Node.js ${MIN_NODE_VERSION}+ is required (current: ${process.version})
   console.error("  https://nodejs.org/\n");
   process.exit(1);
 }
-import("./main-WBZ2KBF2.js");
+if (!process.env.NODE_ENV) process.env.NODE_ENV = "production";
+import("./main-LOBTW45O.js");

package/dist/{main-WBZ2KBF2.js → main-LOBTW45O.js}

@@ -1,6 +1,6 @@
 // src/main.ts
-import { existsSync as existsSync5, rmSync } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, rmSync } from "fs";
+import { join as join6 } from "path";
 import { createInterface } from "readline";
 import { render } from "ink";
 import React from "react";
@@ -35,7 +35,8 @@ var KNOWN_REPORT_FLAGS = /* @__PURE__ */ new Set([
   "--detail-limit",
   "--with-git"
 ]);
-var KNOWN_SUBCOMMANDS = /* @__PURE__ */ new Set(["report"]);
+var KNOWN_SUMMARY_FLAGS = /* @__PURE__ */ new Set(["--date", "--prompt", "--force"]);
+var KNOWN_SUBCOMMANDS = /* @__PURE__ */ new Set(["report", "summary"]);
 function getHelp() {
   return `Usage: agenthud [options]
 
@@ -48,7 +49,7 @@ Options:
   -h, --help                    Show this help message
 
 Commands:
-  report [--date DATE] [--include TYPES]
+  report [--date DATE] [--include TYPES] [--format FORMAT] [--detail-limit N] [--with-git]
                                 Print activity report for a date (default: today)
     --date YYYY-MM-DD|today     Date to report on
     --include TYPES             Comma-separated types or "all"
@@ -58,6 +59,12 @@ Commands:
     --detail-limit N            Max chars per activity detail (default: 120, 0 = unlimited)
     --with-git                  Append today's git commits from cwd to report
 
+  summary [--date DATE] [--prompt TEXT] [--force]
+                                Generate LLM summary of daily activity via claude CLI
+    --date YYYY-MM-DD|today     Date to summarize (default: today)
+    --prompt TEXT               Override prompt for this run
+    --force                     Regenerate even if cached (past dates)
+
 Environment:
   CLAUDE_PROJECTS_DIR           Path to Claude projects directory
                                 (default: ~/.claude/projects)
@@ -170,6 +177,53 @@ function parseArgs(args) {
       reportError
     };
   }
+  if (args[0] === "summary") {
+    const rest = args.slice(1);
+    let summaryDate = todayLocalMidnight();
+    let summaryPrompt;
+    let summaryForce = false;
+    let summaryError;
+    for (let i = 0; i < rest.length; i++) {
+      const arg = rest[i];
+      if (!arg.startsWith("-")) continue;
+      if (!KNOWN_SUMMARY_FLAGS.has(arg)) {
+        summaryError = `Unknown option: "${arg}". Run agenthud --help for usage.`;
+        break;
+      }
+      if (arg === "--date" || arg === "--prompt") i++;
+    }
+    const dateIdx = rest.indexOf("--date");
+    if (dateIdx !== -1) {
+      const dateStr = rest[dateIdx + 1];
+      if (!dateStr) {
+        summaryError = "Invalid date: missing value for --date";
+      } else {
+        const parsed = parseLocalMidnight(dateStr);
+        if (!parsed) {
+          summaryError = `Invalid date: "${dateStr}". Use YYYY-MM-DD or "today".`;
+        } else {
+          summaryDate = parsed;
+        }
+      }
+    }
+    const promptIdx = rest.indexOf("--prompt");
+    if (promptIdx !== -1) {
+      const val = rest[promptIdx + 1];
+      if (!val) {
+        summaryError = "Invalid --prompt: missing value";
+      } else {
+        summaryPrompt = val;
+      }
+    }
+    if (rest.includes("--force")) summaryForce = true;
+    return {
+      mode: "summary",
+      summaryDate,
+      summaryPrompt,
+      summaryForce,
+      summaryError
+    };
+  }
   if (args[0] && !args[0].startsWith("-") && !KNOWN_SUBCOMMANDS.has(args[0])) {
     return {
       mode: "watch",
@@ -317,11 +371,12 @@ function formatDateString(date) {
   return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
 }
 function getCommitDetail(projectPath, hash) {
+  if (!projectPath) return null;
   try {
-    return execSync(`git show --stat --no-color ${hash}`, {
-      cwd: projectPath,
-      encoding: "utf-8"
-    }).trim();
+    return execSync(
+      `git --git-dir="${projectPath}/.git" show --stat --no-color ${hash}`,
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
   } catch {
     return null;
   }
@@ -333,8 +388,8 @@ function parseGitCommits(projectPath, startDate, endDate) {
   let raw;
   try {
     raw = execSync(
-      `git log --format="%ct|%h|%s" --after="${start} 00:00:00" --before="${end} 23:59:59"`,
-      { cwd: projectPath, encoding: "utf-8" }
+      `git --git-dir="${projectPath}/.git" log --format="%ct|%h|%s" --after="${start} 00:00:00" --before="${end} 23:59:59"`,
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
     ).trim();
   } catch {
     return [];
@@ -615,6 +670,19 @@ function generateReport(sessions, options2) {
   return lines.join("\n").trimEnd();
 }
 
+// src/data/summaryRunner.ts
+import { spawn } from "child_process";
+import {
+  copyFileSync,
+  createWriteStream,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync5
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
 // src/data/sessions.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
@@ -834,9 +902,129 @@ function discoverSessions(config) {
   };
 }
 
+// src/data/summaryRunner.ts
+function summariesDir() {
+  const dir = join4(homedir3(), ".agenthud", "summaries");
+  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+  return dir;
+}
+function userPromptPath() {
+  return join4(homedir3(), ".agenthud", "summary-prompt.md");
+}
+function templatePath() {
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  return join4(here, "templates", "summary-prompt.md");
+}
+function dateKey(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function cachePath(date) {
+  return join4(summariesDir(), `${dateKey(date)}.md`);
+}
+function isSameLocalDay2(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function ensureUserPromptFile() {
+  const p = userPromptPath();
+  if (existsSync4(p)) return;
+  const dir = dirname2(p);
+  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+  try {
+    copyFileSync(templatePath(), p);
+  } catch {
+  }
+}
+function resolvePrompt(override) {
+  if (override) return override;
+  const p = userPromptPath();
+  if (existsSync4(p)) {
+    try {
+      return readFileSync5(p, "utf-8");
+    } catch {
+    }
+  }
+  try {
+    return readFileSync5(templatePath(), "utf-8");
+  } catch {
+    return "Summarize the activity log below.";
+  }
+}
+async function runSummary(options2) {
+  ensureUserPromptFile();
+  const isToday = isSameLocalDay2(options2.date, options2.today);
+  const cached = cachePath(options2.date);
+  if (!isToday && !options2.force && existsSync4(cached)) {
+    try {
+      const content = readFileSync5(cached, "utf-8");
+      process.stdout.write(content);
+      if (!content.endsWith("\n")) process.stdout.write("\n");
+      return 0;
+    } catch {
+    }
+  }
+  const config = loadGlobalConfig();
+  const sessions = discoverSessions(config);
+  const reportMarkdown = generateReport(sessions.sessions, {
+    date: options2.date,
+    include: ["response", "bash", "edit", "thinking"],
+    format: "markdown",
+    detailLimit: 0,
+    withGit: true
+  });
+  const prompt = resolvePrompt(options2.prompt);
+  return new Promise((resolve) => {
+    const proc = spawn("claude", ["-p", prompt], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let cacheStream = null;
+    cacheStream = createWriteStream(cached, { encoding: "utf-8" });
+    cacheStream.on("error", (err) => {
+      process.stderr.write(
+        `agenthud: warning: cannot write cache (${err.message})
+`
+      );
+      cacheStream = null;
+    });
+    let stderrBuf = "";
+    proc.on("error", (err) => {
+      if (err.code === "ENOENT") {
+        process.stderr.write(
+          "Error: claude CLI not found. Install: npm i -g @anthropic-ai/claude-code\n"
+        );
+        resolve(1);
+      } else {
+        process.stderr.write(`Error: ${err.message}
+`);
+        resolve(1);
+      }
+    });
+    proc.stdout.on("data", (chunk) => {
+      process.stdout.write(chunk);
+      cacheStream?.write(chunk);
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderrBuf += chunk.toString();
+      process.stderr.write(chunk);
+    });
+    proc.on("close", (code) => {
+      cacheStream?.end();
+      if (code !== 0) {
+        const lower = stderrBuf.toLowerCase();
+        if (lower.includes("not authenticated") || lower.includes("login") || lower.includes(" auth")) {
+          process.stderr.write(
+            "\nHint: claude appears to be unauthenticated. Run: claude\n"
+          );
+        }
+      }
+      resolve(code ?? 1);
+    });
+    proc.stdin.end(reportMarkdown);
+  });
+}
+
 // src/ui/App.tsx
-import { existsSync as existsSync4, watch, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync5, watch, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
 import { Box as Box4, Text as Text4, useApp, useInput, useStdout } from "ink";
 import { useCallback, useEffect as useEffect2, useMemo, useRef, useState as useState2 } from "react";
 
@@ -1251,7 +1439,7 @@ function useSpinner(active, intervalMs = 100) {
 }
 
 // src/ui/SessionTreePanel.tsx
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { Box as Box3, Text as Text3 } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
 function formatElapsed(lastModifiedMs) {
@@ -1277,7 +1465,7 @@ function getStatusColor(status) {
   }
 }
 function formatProjectPath(projectPath) {
-  const home = homedir3();
+  const home = homedir4();
   const raw = projectPath.startsWith(home) ? `~${projectPath.slice(home.length)}` : projectPath;
   return raw;
 }
@@ -1651,9 +1839,11 @@ function App({ mode }) {
     allFlatRef.current = allFlat;
   }, [allFlat]);
   const activitiesLengthRef = useRef(0);
+  const activitiesRef = useRef(activities);
   useEffect2(() => {
     activitiesLengthRef.current = activities.length;
-  }, [activities.length]);
+    activitiesRef.current = activities;
+  }, [activities]);
   useEffect2(() => {
     const node = allFlatRef.current.find((s) => s.id === selectedId);
     if (node?.filePath) {
@@ -1677,7 +1867,7 @@ function App({ mode }) {
     const node = allFlatRef.current.find((s) => s.id === selectedId);
     if (!node?.projectPath) return;
     const load = () => {
-      const acts = node.filePath ? parseSessionHistory(node.filePath) : [];
+      const acts = activitiesRef.current;
       const today = /* @__PURE__ */ new Date();
       const todayMidnight = new Date(
         today.getFullYear(),
@@ -1697,9 +1887,12 @@ function App({ mode }) {
       const commits = parseGitCommits(node.projectPath, startDate, endDate);
       setGitActivities(commits);
     };
-    load();
+    const initial = setTimeout(load, 100);
     const timer = setInterval(load, 3e4);
-    return () => clearInterval(timer);
+    return () => {
+      clearTimeout(initial);
+      clearInterval(timer);
+    };
   }, [selectedId, isWatchMode]);
   const refresh = useCallback(() => {
     const freshConfig = loadGlobalConfig();
@@ -1729,7 +1922,7 @@ function App({ mode }) {
   useEffect2(() => {
     if (!isWatchMode) return;
     const projectsDir = getProjectsDir();
-    const usePolling = process.platform === "linux" || !existsSync4(projectsDir);
+    const usePolling = process.platform === "linux" || !existsSync5(projectsDir);
     if (usePolling) {
       const timer = setInterval(
         () => refreshRef.current(),
@@ -1757,8 +1950,14 @@ function App({ mode }) {
     };
   }, [isWatchMode, config.refreshIntervalMs]);
   const filterPresets = config.filterPresets;
-  const activePreset = filterPresets[filterIndex % filterPresets.length] ?? [];
-  const filterLabel = activePreset.length === 0 ? "all" : activePreset.join("+");
+  const activePreset = useMemo(
+    () => filterPresets[filterIndex % filterPresets.length] ?? [],
+    [filterPresets, filterIndex]
+  );
+  const filterLabel = useMemo(
+    () => activePreset.length === 0 ? "all" : activePreset.join("+"),
+    [activePreset]
+  );
   const mergedActivities = useMemo(() => {
     const merged = [...activities, ...gitActivities].sort(
       (a, b) => a.timestamp.getTime() - b.timestamp.getTime()
@@ -1779,7 +1978,7 @@ function App({ mode }) {
     if (!activities.length || !selectedId) return;
     ensureLogDir(config.logDir);
     const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    const filePath = join4(
+    const filePath = join5(
       config.logDir,
       `${date}-${selectedId.slice(0, 8)}.txt`
     );
@@ -2093,8 +2292,8 @@ if (options.command === "version") {
   console.log(getVersion());
   process.exit(0);
 }
-var legacyConfig = join5(process.cwd(), ".agenthud", "config.yaml");
-if (existsSync5(legacyConfig)) {
+var legacyConfig = join6(process.cwd(), ".agenthud", "config.yaml");
+if (existsSync6(legacyConfig)) {
   console.log(
     "The project-level config file (.agenthud/config.yaml) is no longer supported."
   );
@@ -2133,6 +2332,20 @@ if (options.mode === "report") {
 `);
   process.exit(0);
 }
+if (options.mode === "summary") {
+  if (options.summaryError) {
+    process.stderr.write(`agenthud: ${options.summaryError}
+`);
+    process.exit(1);
+  }
+  const exitCode = await runSummary({
+    date: options.summaryDate,
+    prompt: options.summaryPrompt,
+    force: options.summaryForce ?? false,
+    today: /* @__PURE__ */ new Date()
+  });
+  process.exit(exitCode);
+}
 if (options.mode === "watch") {
   clearScreen();
 }

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.8.5",
   "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");