zeitzeuge 0.3.0

package/dist/vitest/index.js

@@ -0,0 +1,1616 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/vitest/plugin.ts
+import { resolve as resolve3 } from "node:path";
+import { mkdirSync as mkdirSync2 } from "node:fs";
+
+// src/vitest/reporter.ts
+import { readdirSync, readFileSync, existsSync, rmSync, statSync } from "node:fs";
+import { join as join2, resolve as resolve2 } from "node:path";
+import chalk2 from "chalk";
+import ora2 from "ora";
+
+// src/vitest/profile-parser.ts
+var MAX_HOT_FUNCTIONS = 50;
+var MAX_CALL_TREES = 10;
+var CALL_TREE_PRUNE_THRESHOLD = 0.01;
+function parseCpuProfile(profile, profilePath) {
+  if (!profile.samples || profile.samples.length === 0) {
+    return emptySummary(profilePath);
+  }
+  const totalDurationUs = profile.endTime - profile.startTime;
+  const totalDurationMs = totalDurationUs / 1000;
+  const statsMap = buildNodeStats(profile);
+  computeSelfTime(profile, statsMap);
+  computeTotalTime(profile, statsMap);
+  const hotFunctions = extractHotFunctions(statsMap, totalDurationUs);
+  const expensiveCallTrees = extractCallTrees(profile, statsMap, totalDurationUs);
+  const { gcSamples, gcTimeUs, idleTimeUs } = computeSpecialCategories(profile, statsMap);
+  const scriptBreakdown = buildScriptBreakdown(statsMap, totalDurationUs);
+  return {
+    profilePath,
+    duration: round(totalDurationMs),
+    sampleCount: profile.samples.length,
+    hotFunctions,
+    expensiveCallTrees,
+    gcSamples,
+    gcPercentage: totalDurationUs > 0 ? round(gcTimeUs / totalDurationUs * 100) : 0,
+    idlePercentage: totalDurationUs > 0 ? round(idleTimeUs / totalDurationUs * 100) : 0,
+    scriptBreakdown
+  };
+}
+function buildNodeStats(profile) {
+  const statsMap = new Map;
+  for (const node of profile.nodes) {
+    statsMap.set(node.id, {
+      node,
+      selfTime: 0,
+      totalTime: 0,
+      parentIds: new Set
+    });
+  }
+  for (const node of profile.nodes) {
+    if (node.children) {
+      for (const childId of node.children) {
+        const childStats = statsMap.get(childId);
+        if (childStats) {
+          childStats.parentIds.add(node.id);
+        }
+      }
+    }
+  }
+  return statsMap;
+}
+function computeSelfTime(profile, statsMap) {
+  const { samples, timeDeltas } = profile;
+  for (let i = 0;i < samples.length; i++) {
+    const nodeId = samples[i];
+    const delta = timeDeltas[i] ?? 0;
+    const stats = statsMap.get(nodeId);
+    if (stats) {
+      stats.selfTime += Math.max(0, delta);
+    }
+  }
+}
+function computeTotalTime(profile, statsMap) {
+  const childCount = new Map;
+  const queue = [];
+  for (const node of profile.nodes) {
+    const numChildren = node.children?.length ?? 0;
+    childCount.set(node.id, numChildren);
+    if (numChildren === 0) {
+      queue.push(node.id);
+    }
+  }
+  while (queue.length > 0) {
+    const nodeId = queue.shift();
+    const stats = statsMap.get(nodeId);
+    if (!stats)
+      continue;
+    stats.totalTime = stats.selfTime;
+    const children = stats.node.children ?? [];
+    for (const childId of children) {
+      const childStats = statsMap.get(childId);
+      if (childStats) {
+        stats.totalTime += childStats.totalTime;
+      }
+    }
+    for (const parentId of stats.parentIds) {
+      const remaining = (childCount.get(parentId) ?? 1) - 1;
+      childCount.set(parentId, remaining);
+      if (remaining <= 0) {
+        queue.push(parentId);
+      }
+    }
+  }
+}
+function extractHotFunctions(statsMap, totalDurationUs) {
+  const results = [];
+  for (const stats of statsMap.values()) {
+    if (stats.selfTime <= 0)
+      continue;
+    const fn = stats.node.callFrame.functionName;
+    if (fn === "(root)" || fn === "(idle)" || fn === "(program)")
+      continue;
+    results.push({
+      functionName: stats.node.callFrame.functionName || "(anonymous)",
+      scriptUrl: stats.node.callFrame.url,
+      lineNumber: stats.node.callFrame.lineNumber,
+      columnNumber: stats.node.callFrame.columnNumber,
+      selfTime: round(stats.selfTime / 1000),
+      totalTime: round(stats.totalTime / 1000),
+      hitCount: stats.node.hitCount,
+      selfPercent: totalDurationUs > 0 ? round(stats.selfTime / totalDurationUs * 100) : 0
+    });
+  }
+  results.sort((a, b) => b.selfTime - a.selfTime);
+  return results.slice(0, MAX_HOT_FUNCTIONS);
+}
+function extractCallTrees(profile, statsMap, totalDurationUs) {
+  const rootIds = [];
+  for (const stats of statsMap.values()) {
+    if (stats.parentIds.size === 0) {
+      rootIds.push(stats.node.id);
+    }
+  }
+  const trees = [];
+  for (const rootId of rootIds) {
+    const tree = buildCallTreeNode(rootId, statsMap, totalDurationUs);
+    if (tree && tree.totalTime > 0) {
+      trees.push(tree);
+    }
+  }
+  trees.sort((a, b) => b.totalTime - a.totalTime);
+  return trees.slice(0, MAX_CALL_TREES);
+}
+function buildCallTreeNode(nodeId, statsMap, totalDurationUs) {
+  const stats = statsMap.get(nodeId);
+  if (!stats)
+    return null;
+  const totalPercent = totalDurationUs > 0 ? stats.totalTime / totalDurationUs : 0;
+  if (totalPercent < CALL_TREE_PRUNE_THRESHOLD)
+    return null;
+  const children = [];
+  for (const childId of stats.node.children ?? []) {
+    const childTree = buildCallTreeNode(childId, statsMap, totalDurationUs);
+    if (childTree) {
+      children.push(childTree);
+    }
+  }
+  children.sort((a, b) => b.totalTime - a.totalTime);
+  return {
+    functionName: stats.node.callFrame.functionName || "(anonymous)",
+    scriptUrl: stats.node.callFrame.url,
+    lineNumber: stats.node.callFrame.lineNumber,
+    totalTime: round(stats.totalTime / 1000),
+    totalPercent: round(totalPercent * 100),
+    children
+  };
+}
+function computeSpecialCategories(profile, statsMap) {
+  let gcSamples = 0;
+  let gcTimeUs = 0;
+  let idleTimeUs = 0;
+  for (const stats of statsMap.values()) {
+    const fn = stats.node.callFrame.functionName;
+    if (fn.includes("(garbage collector)") || fn === "(GC)") {
+      gcSamples += stats.node.hitCount;
+      gcTimeUs += stats.selfTime;
+    }
+    if (fn === "(idle)") {
+      idleTimeUs += stats.selfTime;
+    }
+  }
+  return { gcSamples, gcTimeUs, idleTimeUs };
+}
+function buildScriptBreakdown(statsMap, totalDurationUs) {
+  const scriptMap = new Map;
+  for (const stats of statsMap.values()) {
+    const url = stats.node.callFrame.url;
+    if (!url)
+      continue;
+    let entry = scriptMap.get(url);
+    if (!entry) {
+      entry = { selfTime: 0, functions: new Set };
+      scriptMap.set(url, entry);
+    }
+    entry.selfTime += stats.selfTime;
+    if (stats.selfTime > 0) {
+      entry.functions.add(`${stats.node.callFrame.functionName}:${stats.node.callFrame.lineNumber}`);
+    }
+  }
+  const results = [];
+  for (const [scriptUrl, data] of scriptMap) {
+    results.push({
+      scriptUrl,
+      selfTime: round(data.selfTime / 1000),
+      selfPercent: totalDurationUs > 0 ? round(data.selfTime / totalDurationUs * 100) : 0,
+      functionCount: data.functions.size
+    });
+  }
+  results.sort((a, b) => b.selfTime - a.selfTime);
+  return results;
+}
+function round(n) {
+  return Math.round(n * 100) / 100;
+}
+function emptySummary(profilePath) {
+  return {
+    profilePath,
+    duration: 0,
+    sampleCount: 0,
+    hotFunctions: [],
+    expensiveCallTrees: [],
+    gcSamples: 0,
+    gcPercentage: 0,
+    idlePercentage: 0,
+    scriptBreakdown: []
+  };
+}
+
+// src/vitest/heap-profile-parser.ts
+function parseHeapProfile(raw, profilePath) {
+  const nodeById = new Map;
+  const parentById = new Map;
+  const walk = (node, parent) => {
+    nodeById.set(node.id, node);
+    parentById.set(node.id, parent ? parent.id : null);
+    for (const child of node.children ?? [])
+      walk(child, node);
+  };
+  walk(raw.head, null);
+  const selfBytesByNode = new Map;
+  let totalAllocatedBytes = 0;
+  for (const s of raw.samples ?? []) {
+    const size = typeof s.size === "number" ? s.size : 0;
+    if (!Number.isFinite(size) || size <= 0)
+      continue;
+    totalAllocatedBytes += size;
+    selfBytesByNode.set(s.nodeId, (selfBytesByNode.get(s.nodeId) ?? 0) + size);
+  }
+  const hotspots = [];
+  const scriptMap = new Map;
+  for (const [nodeId, selfBytes] of selfBytesByNode.entries()) {
+    const node = nodeById.get(nodeId);
+    if (!node)
+      continue;
+    const cf = node.callFrame;
+    const scriptUrl = cf?.url ?? "";
+    const fnName = cf?.functionName ?? "(anonymous)";
+    hotspots.push({
+      functionName: fnName,
+      scriptUrl,
+      lineNumber: cf?.lineNumber ?? -1,
+      columnNumber: cf?.columnNumber ?? -1,
+      selfBytes,
+      selfPercent: 0
+    });
+    const key = scriptUrl || "(unknown)";
+    const entry = scriptMap.get(key) ?? { selfBytes: 0, functionIds: new Set };
+    entry.selfBytes += selfBytes;
+    entry.functionIds.add(nodeId);
+    scriptMap.set(key, entry);
+  }
+  hotspots.sort((a, b) => b.selfBytes - a.selfBytes);
+  const topAllocations = hotspots.slice(0, 50);
+  if (totalAllocatedBytes > 0) {
+    for (const h of topAllocations) {
+      h.selfPercent = round2(h.selfBytes / totalAllocatedBytes * 100);
+    }
+  }
+  const scriptBreakdown = Array.from(scriptMap.entries()).map(([scriptUrl, data]) => ({
+    scriptUrl,
+    selfBytes: data.selfBytes,
+    selfPercent: totalAllocatedBytes > 0 ? round2(data.selfBytes / totalAllocatedBytes * 100) : 0,
+    functionCount: data.functionIds.size
+  })).sort((a, b) => b.selfBytes - a.selfBytes);
+  return {
+    profilePath,
+    totalAllocatedBytes: Math.round(totalAllocatedBytes),
+    sampleCount: raw.samples?.length ?? 0,
+    topAllocations,
+    scriptBreakdown
+  };
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+
+// src/vitest/workspace.ts
+import { FilesystemBackend } from "deepagents";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+var SOURCE_INCLUSION_THRESHOLD = 1;
+var SLOW_TEST_THRESHOLD = 100;
+async function createVitestWorkspace(options) {
+  const { testTiming, profiles, heapProfiles, testSources, sourcePaths } = options;
+  const files = {};
+  const totalTests = testTiming.reduce((s, t) => s + t.testCount, 0);
+  const totalDuration = testTiming.reduce((s, t) => s + t.duration, 0);
+  const passCount = testTiming.reduce((s, t) => s + t.passCount, 0);
+  const failCount = testTiming.reduce((s, t) => s + t.failCount, 0);
+  const slowest = testTiming.length > 0 ? testTiming.reduce((a, b) => a.duration > b.duration ? a : b) : null;
+  const totalGcTime = profiles.reduce((s, p) => s + p.summary.duration * p.summary.gcPercentage / 100, 0);
+  const gcPercentage = totalDuration > 0 ? round3(totalGcTime / totalDuration * 100) : 0;
+  files["/summary.json"] = JSON.stringify({
+    totalTests,
+    totalDuration: round3(totalDuration),
+    passCount,
+    failCount,
+    profileCount: profiles.length,
+    slowestFile: slowest?.file ?? null,
+    slowestFileDuration: slowest ? round3(slowest.duration) : 0,
+    totalGcTime: round3(totalGcTime),
+    gcPercentage
+  }, null, 2);
+  files["/timing/overview.json"] = JSON.stringify(testTiming, null, 2);
+  const slowTests = [];
+  for (const fileTiming of testTiming) {
+    for (const test of fileTiming.tests) {
+      if (test.duration > SLOW_TEST_THRESHOLD) {
+        slowTests.push({
+          file: fileTiming.file,
+          name: test.name,
+          duration: test.duration
+        });
+      }
+    }
+  }
+  slowTests.sort((a, b) => b.duration - a.duration);
+  files["/timing/slow-tests.json"] = JSON.stringify(slowTests, null, 2);
+  files["/profiles/index.json"] = JSON.stringify(profiles.map((p) => ({
+    testFile: p.testFile,
+    profilePath: p.profilePath
+  })), null, 2);
+  for (const profile of profiles) {
+    const safeName = sanitizeFilename(profile.testFile);
+    files[`/profiles/${safeName}.json`] = JSON.stringify(profile.summary, null, 2);
+  }
+  if (heapProfiles && heapProfiles.length > 0) {
+    files["/heap-profiles/index.json"] = JSON.stringify(heapProfiles.map((p) => ({
+      testFile: p.testFile,
+      profilePath: p.profilePath
+    })), null, 2);
+    for (const hp of heapProfiles) {
+      const safeName = sanitizeFilename(hp.testFile);
+      files[`/heap-profiles/${safeName}.json`] = JSON.stringify(hp.summary, null, 2);
+    }
+  }
+  const mergedHotFunctions = mergeHotFunctions(profiles);
+  files["/hot-functions/global.json"] = JSON.stringify(mergedHotFunctions, null, 2);
+  const appHotFunctions = mergedHotFunctions.filter((fn) => fn.sourceCategory === "application");
+  files["/hot-functions/application.json"] = JSON.stringify(appHotFunctions, null, 2);
+  const depHotFunctions = mergedHotFunctions.filter((fn) => fn.sourceCategory === "dependency");
+  files["/hot-functions/dependencies.json"] = JSON.stringify(depHotFunctions, null, 2);
+  const appScripts = profiles.flatMap((p) => p.summary.scriptBreakdown.filter((s) => s.sourceCategory === "application"));
+  const appScriptMap = new Map;
+  for (const s of appScripts) {
+    const existing = appScriptMap.get(s.scriptUrl);
+    if (existing) {
+      existing.selfTime += s.selfTime;
+      existing.functionCount = Math.max(existing.functionCount, s.functionCount);
+    } else {
+      appScriptMap.set(s.scriptUrl, {
+        selfTime: s.selfTime,
+        functionCount: s.functionCount
+      });
+    }
+  }
+  const totalDurationMs = testTiming.reduce((s, t) => s + t.duration, 0);
+  const appScriptSummary = Array.from(appScriptMap.entries()).map(([scriptUrl, data]) => ({
+    scriptUrl,
+    selfTime: round3(data.selfTime),
+    selfPercent: totalDurationMs > 0 ? round3(data.selfTime / totalDurationMs * 100) : 0,
+    functionCount: data.functionCount
+  })).sort((a, b) => b.selfTime - a.selfTime);
+  files["/scripts/application.json"] = JSON.stringify(appScriptSummary, null, 2);
+  const depScripts = profiles.flatMap((p) => p.summary.scriptBreakdown.filter((s) => s.sourceCategory === "dependency"));
+  const depScriptMap = new Map;
+  for (const s of depScripts) {
+    const existing = depScriptMap.get(s.scriptUrl);
+    if (existing) {
+      existing.selfTime += s.selfTime;
+      existing.functionCount = Math.max(existing.functionCount, s.functionCount);
+    } else {
+      depScriptMap.set(s.scriptUrl, {
+        selfTime: s.selfTime,
+        functionCount: s.functionCount
+      });
+    }
+  }
+  const depScriptSummary = Array.from(depScriptMap.entries()).map(([scriptUrl, data]) => ({
+    scriptUrl,
+    selfTime: round3(data.selfTime),
+    selfPercent: totalDurationMs > 0 ? round3(data.selfTime / totalDurationMs * 100) : 0,
+    functionCount: data.functionCount
+  })).sort((a, b) => b.selfTime - a.selfTime);
+  files["/scripts/dependencies.json"] = JSON.stringify(depScriptSummary, null, 2);
+  for (const [filePath, source] of testSources) {
+    const filename = filePath.split("/").pop() ?? filePath;
+    files[`/tests/${filename}`] = source;
+  }
+  if (sourcePaths) {
+    const hotScriptUrls = new Set;
+    for (const profile of profiles) {
+      for (const fn of profile.summary.hotFunctions) {
+        if (!fn.scriptUrl)
+          continue;
+        const threshold = fn.sourceCategory === "application" ? 0.1 : SOURCE_INCLUSION_THRESHOLD;
+        if (fn.selfPercent >= threshold) {
+          hotScriptUrls.add(fn.scriptUrl);
+        }
+      }
+    }
+    for (const [scriptUrl, source] of sourcePaths) {
+      if (!hotScriptUrls.has(scriptUrl))
+        continue;
+      const filename = scriptUrl.split("/").pop() ?? scriptUrl;
+      files[`/src/${filename}`] = source;
+    }
+  }
+  const tempDir = mkdtempSync(join(tmpdir(), "zeitzeuge-vitest-workspace-"));
+  for (const [filePath, content] of Object.entries(files)) {
+    const relPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+    const fullPath = join(tempDir, relPath);
+    mkdirSync(join(fullPath, ".."), { recursive: true });
+    writeFileSync(fullPath, content, "utf-8");
+  }
+  const backend = new FilesystemBackend({
+    rootDir: tempDir,
+    virtualMode: true
+  });
+  const cleanup = () => {
+    try {
+      const { rmSync } = __require("node:fs");
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {}
+  };
+  return { backend, cleanup };
+}
+function mergeHotFunctions(profiles) {
+  const merged = new Map;
+  let totalDuration = 0;
+  for (const profile of profiles) {
+    totalDuration += profile.summary.duration;
+    for (const fn of profile.summary.hotFunctions) {
+      const key = `${fn.scriptUrl}:${fn.functionName}:${fn.lineNumber}`;
+      const existing = merged.get(key);
+      if (existing) {
+        existing.selfTime += fn.selfTime;
+        existing.totalTime += fn.totalTime;
+        existing.hitCount += fn.hitCount;
+      } else {
+        merged.set(key, { ...fn });
+      }
+    }
+  }
+  if (totalDuration > 0) {
+    for (const fn of merged.values()) {
+      fn.selfPercent = round3(fn.selfTime / totalDuration * 100);
+    }
+  }
+  const results = Array.from(merged.values());
+  results.sort((a, b) => b.selfTime - a.selfTime);
+  return results.slice(0, 50);
+}
+function sanitizeFilename(filePath) {
+  return filePath.replace(/[/\\]/g, "_").replace(/[^a-zA-Z0-9._-]/g, "_").replace(/^_+/, "");
+}
+function round3(n) {
+  return Math.round(n * 100) / 100;
+}
+
+// src/analysis/agent.ts
+import { createDeepAgent } from "deepagents";
+import { providerStrategy } from "langchain";
+
+// src/analysis/prompts.ts
+var SYSTEM_PROMPT = `You are an expert web performance engineer. You have access to a virtual filesystem workspace containing captured data from a real page load: heap snapshot, network trace, and Chrome runtime trace.
+
+## Workspace structure
+
+- /heap/summary.json — Parsed V8 heap snapshot: largest objects, type stats, constructor stats, detached DOM nodes, closure stats
+- /trace/summary.json — Page load metrics: timing, long tasks, render-blocking resources, resource breakdown
+- /trace/network-waterfall.json — Every network request with timing, size, priority, render-blocking status
+- /trace/asset-manifest.json — Index of all assets with paths to stored files
+- /trace/runtime/summary.json — Runtime trace overview: frame breakdown (scripting/layout/paint/GC), blocking function count, listener imbalances, GC stats
+- /trace/runtime/blocking-functions.json — Functions that blocked the main thread > 50ms, with script URL, line number, call stack, and duration
+- /trace/runtime/event-listeners.json — Event listener add/remove counts per event type, with source locations
+- /trace/runtime/frame-breakdown.json — Time spent in scripting vs layout vs paint vs GC
+- /trace/runtime/raw-events.json — Full Chrome trace events (large file — read to investigate specific function calls, layouts, GC, and event dispatches)
+- /scripts/*.js — Actual JavaScript source files captured during page load
+- /styles/*.css — Actual CSS source files
+- /html/document.html — The HTML document
+
+## Your workflow
+
+1. Read /heap/summary.json, /trace/summary.json, AND /trace/runtime/summary.json first for the big picture
+2. Identify the highest-impact issues from all datasets
+3. For each issue, dive into the relevant source files to understand the root cause
+4. Provide specific, code-level fixes
+
+## What to look for
+
+### Memory issues (from heap data)
+- Memory leaks: unbounded arrays, maps, caches that grow without bound
+- Detached DOM nodes: DOM elements removed from the document but still referenced
+- Large retained objects: single objects or trees retaining disproportionate memory
+- Closure leaks: closures capturing variables they no longer need
+
+### Page-load issues (from trace + source code)
+- Render-blocking scripts: <script> in <head> without async/defer — read the script to judge if it must be synchronous
+- Render-blocking CSS: large stylesheets blocking first paint
+- Long tasks (> 50ms): identify the function/module causing the block by reading the source
+- Large bundles: scripts > 100KB — search for unused imports or code that could be lazy-loaded
+- Sequential waterfalls: resources chained sequentially that could load in parallel
+
+### Runtime issues (from Chrome trace)
+- Frame-blocking functions: read /trace/runtime/blocking-functions.json first, then inspect the actual script source at the reported line number to understand what the function does and how to optimize it
+- Event listener leaks: check /trace/runtime/event-listeners.json for event types where addCount >> removeCount, then grep the scripts for those addEventListener calls
+- GC pressure: high GC pause counts or duration suggest excessive short-lived object creation — look for hot loops creating objects
+- Layout thrashing: forced synchronous layouts caused by reading layout properties (offsetHeight, getBoundingClientRect) after DOM writes
+
+## Output guidelines
+
+- Report 3–7 findings, ordered by impact (mix of memory, page-load, and runtime if all have issues)
+- Be specific — name actual files, functions, object constructors, and retention paths
+- Provide concrete code fixes, not generic advice
+- If heap, trace, and runtime all look healthy, say so — don't manufacture issues`;
+
+// src/vitest/prompts.ts
+var VITEST_SYSTEM_PROMPT = `You are an expert in JavaScript/TypeScript performance optimization.
+You have access to a workspace containing V8 CPU profiling data captured during
+a Vitest test run. The workspace may also include V8 heap profiling data
+captured via Node's \`--heap-prof\` (allocation sampling).
+
+The profiling data covers BOTH the test code AND the application code being tested.
+
+**Your primary goal is to analyze the PERFORMANCE OF THE APPLICATION CODE
+being tested** — the functions, modules, and algorithms that the developer
+wrote and is benchmarking or testing. Test infrastructure overhead (Vitest,
+tinybench, test setup) is secondary context.
+
+## Source categories
+
+Every hot function and script in the workspace has a \`sourceCategory\` field:
+
+- **application** — Code in the user's project (the code being tested).
+  This is your PRIMARY focus. Find bottlenecks, inefficiencies, and
+  optimization opportunities in these functions.
+- **dependency** — Third-party code in node_modules. Report when a dependency
+  is a significant bottleneck, since the developer may be able to choose
+  an alternative, configure it differently, or avoid calling it in hot paths.
+- **test** — Test files. Only mention if the test setup itself is creating
+  artificial overhead that masks application performance.
+- **framework** — Vitest/tinybench/V8 internals. Generally ignore unless
+  they dominate the profile in an unexpected way.
+
+## Workspace structure
+
+- /summary.json — Overall test run: total tests, duration, pass/fail, GC stats
+- /timing/overview.json — Per-file test durations and individual test times
+- /timing/slow-tests.json — Tests exceeding the slow threshold
+- /profiles/index.json — Manifest mapping test files to their CPU profiles
+- /profiles/<file>.json — CPU profile summary: hot functions (with sourceCategory),
+  call trees, GC samples, script breakdown (with sourceCategory)
+- /heap-profiles/index.json — (optional) Manifest mapping test files to heap profiles
+- /heap-profiles/<file>.json — (optional) Heap profile summary: allocation hotspots,
+  per-script allocated bytes (with sourceCategory)
+- /hot-functions/application.json — **START HERE**: Hot functions from application code only
+- /hot-functions/dependencies.json — Hot functions from third-party dependencies
+- /hot-functions/global.json — All hot functions across all categories
+- /scripts/application.json — Per-script time breakdown for application code
+- /scripts/dependencies.json — Per-script time breakdown for dependencies
+- /tests/*.ts — Test source files
+- /src/*.ts — Application and dependency source files referenced by hot functions
+
+## Your workflow
+
+1. Read /hot-functions/application.json FIRST — these are the application-level
+   bottlenecks the developer wants to optimize
+2. Read /scripts/application.json for the per-file view of application code time
+3. Read /hot-functions/dependencies.json for costly dependency calls
+4. If present, read /heap-profiles/index.json and /heap-profiles/<file>.json to identify
+   allocation hotspots (functions/scripts allocating lots of bytes)
+5. Read /summary.json and /timing/overview.json for the big picture
+6. Read CPU profiles in /profiles/ for detailed call trees of the slowest tests
+7. Read the actual source code in /src/ and /tests/ to understand root causes
+8. Provide specific, actionable fixes targeting the application code
+
+## What to look for
+
+### Application code bottlenecks (PRIMARY FOCUS)
+- Functions with high self time — where is the application spending CPU?
+- Expensive algorithms: O(n²) loops, unnecessary sorting, repeated work
+- String/JSON operations: excessive serialization, string concatenation in loops
+- Object allocation hotspots: functions creating many short-lived objects
+- Synchronous blocking: file I/O, crypto, or compression in hot paths
+- Redundant computation: values computed repeatedly that could be cached/memoized
+- Data structure choices: using arrays where Maps/Sets would be O(1)
+
+### Dependency-related bottlenecks
+- Dependencies consuming disproportionate CPU — suggest alternatives or configuration
+- Unnecessary calls to expensive dependency APIs in hot paths
+- Dependencies pulled in for simple operations that could be hand-written
+
+### GC pressure from application code
+- Application functions creating many temporary objects in tight loops
+- Large array/object allocations that could be pooled or reused
+- Closures capturing large scopes unnecessarily
+
+### Allocation hotspots (from heap profiles, if present)
+- Functions allocating a large share of total bytes (even if CPU isn't dominant)
+- Scripts/modules responsible for most allocation — suggest caching, reuse, pooling,
+  or avoiding intermediate arrays/objects
+- When allocation hotspots match CPU hotspots, prioritize fixes there first
+
+### Call chain analysis
+- Trace expensive call trees to find which APPLICATION function triggers them
+- Follow the call tree from application entry points down to the hot leaf functions
+- Identify which application-level design decisions lead to the bottleneck
+
+### Test infrastructure (SECONDARY — only if impactful)
+- Test setup creating artificial overhead that dwarfs application execution
+- Benchmarks measuring setup cost instead of application performance
+- Only mention if it prevents getting clean application performance data
+
+## Finding categories
+
+Each finding MUST use one of these exact category values:
+
+- **algorithm** — Inefficient algorithm: O(n²) loops, brute-force search, repeated work
+- **serialization** — Excessive JSON.stringify/parse, string concatenation, encoding
+- **allocation** — Excessive object/array creation causing GC pressure
+- **event-handling** — Listener leaks, unbounded event handler accumulation
+- **hot-function** — Generic CPU-hot function that doesn't fit a more specific category
+- **gc-pressure** — High garbage collection overhead
+- **listener-leak** — Event listeners not cleaned up properly
+- **unnecessary-computation** — Redundant work that could be cached or eliminated
+- **blocking-io** — Synchronous I/O or blocking operations in hot paths
+- **dependency-bottleneck** — Expensive dependency call the developer can optimize
+- **slow-test** — Test itself is slow due to setup or teardown
+- **expensive-setup** — Costly test setup (beforeAll/beforeEach)
+- **import-overhead** — Expensive module imports at test time
+- **other** — Doesn't fit any of the above
+
+Prefer more specific categories (algorithm, serialization, allocation, event-handling)
+over generic ones (hot-function, other) when the root cause is clear.
+
+## Output guidelines
+
+- Report 3–7 findings, ordered by impact ON THE APPLICATION CODE
+- Focus findings on functions the developer CAN change (application code first,
+  then dependency usage patterns, then test structure)
+- Be specific — name actual files, functions, line numbers from the source code
+- Provide concrete code-level fixes, not generic advice
+- When reporting a dependency bottleneck, explain what application code is
+  calling it and how the developer can reduce that cost
+- If the application code is already efficient, say so — don't force findings
+  about test infrastructure just to fill the report`;
+
+// src/schema.ts
+import { z } from "zod";
+var ALL_CATEGORIES = [
+  "memory-leak",
+  "large-retained-object",
+  "detached-dom",
+  "render-blocking",
+  "long-task",
+  "unused-code",
+  "waterfall-bottleneck",
+  "large-asset",
+  "frame-blocking-function",
+  "listener-leak",
+  "gc-pressure",
+  "slow-test",
+  "expensive-setup",
+  "hot-function",
+  "unnecessary-computation",
+  "import-overhead",
+  "dependency-bottleneck",
+  "algorithm",
+  "serialization",
+  "allocation",
+  "event-handling",
+  "blocking-io",
+  "other"
+];
+var FindingSchema = z.object({
+  severity: z.enum(["critical", "warning", "info"]),
+  title: z.string().describe("Short title for the finding"),
+  description: z.string().describe("Detailed explanation of the issue"),
+  category: z.string().describe(`Category of the performance issue. Use one of: ${ALL_CATEGORIES.join(", ")}`),
+  resourceUrl: z.string().optional().describe("URL of the resource involved"),
+  workspacePath: z.string().optional().describe("Path in the VFS workspace"),
+  impactMs: z.number().optional().describe("Impact on page load time in ms"),
+  retainedSize: z.number().optional().describe("Retained heap size in bytes"),
+  retainerPath: z.array(z.string()).optional().describe("Object retention path in the heap"),
+  suggestedFix: z.string().describe("Code snippet or guidance to fix the issue"),
+  testFile: z.string().optional().describe("Test file path (for test performance findings)"),
+  hotFunction: z.object({
+    name: z.string(),
+    scriptUrl: z.string(),
+    lineNumber: z.number(),
+    selfTime: z.number(),
+    selfPercent: z.number()
+  }).optional().describe("Hot function details (for hot-function findings)")
+});
+var FindingsSchema = z.object({
+  findings: z.array(FindingSchema)
+});
+
+// src/analysis/agent.ts
+async function analyze(model, backend) {
+  const agent = createDeepAgent({
+    model,
+    systemPrompt: SYSTEM_PROMPT,
+    backend,
+    responseFormat: providerStrategy(FindingsSchema)
+  });
+  const userMessage = [
+    "Analyze the frontend performance data in this workspace.",
+    "",
+    "The workspace contains heap snapshot data, page-load trace data, and Chrome runtime trace data.",
+    "",
+    "Start by reading /heap/summary.json, /trace/summary.json, and /trace/runtime/summary.json",
+    "to understand the overall picture. Then explore:",
+    "",
+    "- /trace/network-waterfall.json for request timing",
+    "- /trace/runtime/blocking-functions.json for function-level main thread blocking",
+    "- /trace/runtime/event-listeners.json for listener add/remove imbalances",
+    "- /trace/runtime/frame-breakdown.json for frame breakdown (scripting vs layout vs paint vs GC)",
+    "- /scripts/ for the actual JavaScript source code",
+    "- /styles/ for CSS source",
+    "- /html/document.html for the page markup",
+    "",
+    "Look for memory issues (from the heap data), page-load issues (from the network trace),",
+    "and runtime issues (from the Chrome trace — blocking functions, listener leaks, GC pressure).",
+    "When you find a problem, read the actual source file to provide a specific, code-level fix."
+  ].join(`
+`);
+  const result = await agent.invoke({
+    messages: [{ role: "user", content: userMessage }]
+  });
+  return result.structuredResponse.findings;
+}
+async function analyzeTestPerformance(model, backend) {
+  const agent = createDeepAgent({
+    model,
+    systemPrompt: VITEST_SYSTEM_PROMPT,
+    backend,
+    responseFormat: providerStrategy(FindingsSchema)
+  });
+  const userMessage = [
+    "Analyze the performance of the APPLICATION CODE being tested in this Vitest workspace.",
+    "",
+    "Follow this order:",
+    "1. Read /hot-functions/application.json — these are the hotspots IN the user's own code",
+    "2. Read /scripts/application.json — per-file CPU time for application source files",
+    "3. Read /hot-functions/dependencies.json — expensive dependency calls",
+    "4. If present, read /heap-profiles/index.json and /heap-profiles/<file>.json for allocation hotspots",
+    "5. Read /summary.json and /timing/overview.json for the big picture",
+    "6. Read CPU profiles in /profiles/ for detailed call trees",
+    "7. Read source files in /src/ and /tests/ to understand root causes and propose code-level fixes",
+    "",
+    "Focus findings on the APPLICATION code — what can the developer change in their own codebase",
+    "to improve performance? Dependency bottlenecks are worth reporting if the developer can",
+    "reduce how they call the dependency or choose an alternative."
+  ].join(`
+`);
+  const result = await agent.invoke({
+    messages: [{ role: "user", content: userMessage }]
+  });
+  return result.structuredResponse.findings;
+}
+
+// src/models/init.ts
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatAnthropic } from "@langchain/anthropic";
+function initModel() {
+  const modelOverride = process.env.ZEITZEUGE_MODEL;
+  const openaiKey = process.env.OPENAI_API_KEY;
+  const anthropicKey = process.env.ANTHROPIC_API_KEY;
+  if (openaiKey) {
+    return new ChatOpenAI({
+      model: modelOverride ?? "gpt-5.2",
+      apiKey: openaiKey
+    });
+  }
+  if (anthropicKey) {
+    return new ChatAnthropic({
+      model: modelOverride ?? "claude-opus-4-6",
+      apiKey: anthropicKey
+    });
+  }
+  throw new Error(`No API key found. Set OPENAI_API_KEY or ANTHROPIC_API_KEY in your environment.
+
+` + `  export OPENAI_API_KEY=sk-...
+` + `  # or
+` + `  export ANTHROPIC_API_KEY=sk-ant-...
+`);
+}
+
+// src/output/terminal.ts
+import chalk from "chalk";
+import ora from "ora";
+var SEVERITY_ICONS = {
+  critical: chalk.red("\uD83D\uDD34 CRITICAL"),
+  warning: chalk.yellow("\uD83D\uDFE1 WARNING"),
+  info: chalk.green("\uD83D\uDFE2 INFO")
+};
+var CATEGORY_LABELS = {
+  "memory-leak": "Memory Leak",
+  "large-retained-object": "Large Retained Object",
+  "detached-dom": "Detached DOM",
+  "render-blocking": "Render-Blocking",
+  "long-task": "Long Task",
+  "unused-code": "Unused Code",
+  "waterfall-bottleneck": "Waterfall Bottleneck",
+  "large-asset": "Large Asset",
+  "frame-blocking-function": "Frame-Blocking Function",
+  "listener-leak": "Listener Leak",
+  "gc-pressure": "GC Pressure",
+  "slow-test": "Slow Test",
+  "expensive-setup": "Expensive Setup",
+  "hot-function": "Hot Function",
+  "unnecessary-computation": "Unnecessary Computation",
+  "import-overhead": "Import Overhead",
+  "dependency-bottleneck": "Dependency Bottleneck",
+  algorithm: "Inefficient Algorithm",
+  serialization: "Serialization Overhead",
+  allocation: "Excessive Allocation",
+  "event-handling": "Event Handling",
+  "blocking-io": "Blocking I/O",
+  other: "Other"
+};
+function printHeader(url, version) {
+  const urlDisplay = url.length > 44 ? url.slice(0, 41) + "..." : url;
+  console.log(chalk.cyan(`
+┌${"─".repeat(57)}┐
+` + `│  zeitzeuge v${version.padEnd(44)}│
+` + `│  Analyzing: ${urlDisplay.padEnd(44)}│
+` + `└${"─".repeat(57)}┘
+`));
+}
+function createSpinner(text) {
+  return ora({ text, color: "cyan" }).start();
+}
+function printFindings(findings) {
+  console.log(chalk.dim(`
+` + "━".repeat(58) + `
+`));
+  if (findings.length === 0) {
+    console.log(chalk.green(`  ✔ No significant performance issues found. Page looks healthy!
+`));
+    console.log(chalk.dim("━".repeat(58)));
+    return;
+  }
+  for (const finding of findings) {
+    const icon = SEVERITY_ICONS[finding.severity];
+    const categoryLabel = CATEGORY_LABELS[finding.category] ?? finding.category;
+    console.log(`${icon} [${categoryLabel}]: ${chalk.bold(finding.title)}`);
+    if (finding.retainedSize != null) {
+      console.log(chalk.dim(`   Retained size: ${formatBytes(finding.retainedSize)}`));
+    }
+    if (finding.impactMs != null) {
+      console.log(chalk.dim(`   Impact: ${finding.impactMs.toFixed(0)}ms`));
+    }
+    if (finding.resourceUrl) {
+      console.log(chalk.dim(`   Resource: ${finding.resourceUrl}`));
+    }
+    if (finding.retainerPath && finding.retainerPath.length > 0) {
+      console.log(chalk.dim(`   Path: ${finding.retainerPath.join(" → ")}`));
+    }
+    if (finding.testFile) {
+      console.log(chalk.dim(`   Test file: ${finding.testFile}`));
+    }
+    if (finding.hotFunction) {
+      const hf = finding.hotFunction;
+      console.log(chalk.dim(`   Function: ${hf.name} at ${hf.scriptUrl}:${hf.lineNumber} (selfTime: ${hf.selfTime.toFixed(0)}ms, ${hf.selfPercent.toFixed(1)}%)`));
+    }
+    console.log(`
+   ${finding.description}
+`);
+    if (finding.suggestedFix) {
+      console.log(chalk.dim("   Suggested fix:"));
+      const lines = finding.suggestedFix.split(`
+`);
+      const boxWidth = Math.max(...lines.map((l) => l.length), 20) + 4;
+      console.log(chalk.dim(`   ┌${"─".repeat(boxWidth)}┐`));
+      for (const line of lines) {
+        console.log(chalk.dim("   │ ") + chalk.white(line.padEnd(boxWidth - 2)) + chalk.dim(" │"));
+      }
+      console.log(chalk.dim(`   └${"─".repeat(boxWidth)}┘`));
+    }
+    console.log();
+  }
+  console.log(chalk.dim("━".repeat(58)));
+  const counts = {
+    critical: findings.filter((f) => f.severity === "critical").length,
+    warning: findings.filter((f) => f.severity === "warning").length,
+    info: findings.filter((f) => f.severity === "info").length
+  };
+  console.log(`
+Summary: ${chalk.red(`${counts.critical} critical`)}, ` + `${chalk.yellow(`${counts.warning} warning`)}, ` + `${chalk.green(`${counts.info} info`)}
+`);
+}
+function printCaptureInfo(heapSummary, trace) {
+  console.log(chalk.dim(`Heap: ${formatBytes(heapSummary.metadata.totalSize)} | ` + `Nodes: ${heapSummary.metadata.nodeCount.toLocaleString()} | ` + `Requests: ${trace.networkRequests.length} | ` + `Long tasks: ${trace.metrics.longTasks.length}`));
+}
+function printError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(chalk.red(`
+✖ Error: ${message}
+`));
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/output/report.ts
+import { writeFileSync as writeFileSync2 } from "node:fs";
+var SEVERITY_EMOJI = {
+  critical: "\uD83D\uDD34",
+  warning: "\uD83D\uDFE1",
+  info: "ℹ️"
+};
+var CATEGORY_LABELS2 = {
+  "memory-leak": "Memory Leak",
+  "large-retained-object": "Large Retained Object",
+  "detached-dom": "Detached DOM",
+  "render-blocking": "Render-Blocking",
+  "long-task": "Long Task",
+  "unused-code": "Unused Code",
+  "waterfall-bottleneck": "Waterfall Bottleneck",
+  "large-asset": "Large Asset",
+  "frame-blocking-function": "Frame-Blocking Function",
+  "listener-leak": "Listener Leak",
+  "gc-pressure": "GC Pressure",
+  "slow-test": "Slow Test",
+  "expensive-setup": "Expensive Setup",
+  "hot-function": "Hot Function",
+  "unnecessary-computation": "Unnecessary Computation",
+  "import-overhead": "Import Overhead",
+  "dependency-bottleneck": "Dependency Bottleneck",
+  algorithm: "Inefficient Algorithm",
+  serialization: "Serialization Overhead",
+  allocation: "Excessive Allocation",
+  "event-handling": "Event Handling",
+  "blocking-io": "Blocking I/O",
+  other: "Other"
+};
+function writeReport(outputPath, options) {
+  const md = generateMarkdown(options);
+  writeFileSync2(outputPath, md, "utf-8");
+  return outputPath;
+}
+function generateMarkdown(options) {
+  const { url, version, findings, heapSummary, trace } = options;
+  const now = new Date;
+  const sections = [];
+  sections.push(`# Performance Report`);
+  sections.push("");
+  sections.push(`> **${url}** — analyzed ${now.toISOString().replace("T", " ").slice(0, 16)} UTC by zeitzeuge v${version}`);
+  sections.push("");
+  const totalTransfer = trace.networkRequests.reduce((s, r) => s + r.encodedSize, 0);
+  const loadSec = (trace.metrics.loadComplete / 1000).toFixed(1);
+  const fcpSec = (trace.metrics.firstContentfulPaint / 1000).toFixed(2);
+  const tbt = trace.metrics.totalBlockingTime.toFixed(0);
+  const heapSize = formatBytes(heapSummary.metadata.totalSize);
+  const reqCount = trace.networkRequests.length;
+  sections.push(`**Page load** ${loadSec}s · **FCP** ${fcpSec}s · **TBT** ${tbt}ms · ` + `**Heap** ${heapSize} · **${reqCount} requests** (${formatBytes(totalTransfer)} transferred)`);
+  sections.push("");
+  const counts = {
+    critical: findings.filter((f) => f.severity === "critical").length,
+    warning: findings.filter((f) => f.severity === "warning").length,
+    info: findings.filter((f) => f.severity === "info").length
+  };
+  if (findings.length === 0) {
+    sections.push(`## ✅ No issues found`);
+    sections.push("");
+    sections.push(`No significant performance problems were detected. ` + `The page loads in ${loadSec}s with ${tbt}ms of total blocking time — looking healthy.`);
+    sections.push("");
+  } else {
+    sections.push(`**${findings.length} issues found** — ` + `${counts.critical} critical, ${counts.warning} warning, ${counts.info} info`);
+    sections.push("");
+    for (let i = 0;i < findings.length; i++) {
+      const f = findings[i];
+      if (!f)
+        continue;
+      const emoji = SEVERITY_EMOJI[f.severity];
+      const categoryLabel = CATEGORY_LABELS2[f.category] ?? f.category;
+      sections.push(`---`);
+      sections.push("");
+      sections.push(`## ${emoji} ${f.title}`);
+      sections.push("");
+      const context = [`**${categoryLabel}**`];
+      if (f.impactMs != null)
+        context.push(`${f.impactMs.toFixed(0)}ms impact`);
+      if (f.retainedSize != null)
+        context.push(`${formatBytes(f.retainedSize)} retained`);
+      if (f.resourceUrl)
+        context.push(`\`${f.resourceUrl}\``);
+      sections.push(context.join(" · "));
+      sections.push("");
+      sections.push(f.description);
+      sections.push("");
+      if (f.suggestedFix) {
+        sections.push(`### How to fix`);
+        sections.push("");
+        const looksLikeCode = f.suggestedFix.includes("{") || f.suggestedFix.includes(";") || f.suggestedFix.includes("=>") || f.suggestedFix.includes("import ") || f.suggestedFix.includes("function ");
+        if (looksLikeCode) {
+          sections.push("```js");
+          sections.push(f.suggestedFix);
+          sections.push("```");
+        } else {
+          sections.push(f.suggestedFix);
+        }
+        sections.push("");
+      }
+      if (f.retainerPath && f.retainerPath.length > 0) {
+        sections.push(`*Retention path:* ${f.retainerPath.map((p) => `\`${p}\``).join(" → ")}`);
+        sections.push("");
+      }
+    }
+  }
+  sections.push(`---`);
+  sections.push("");
+  sections.push(`*Generated by zeitzeuge v${version}*`);
+  sections.push("");
+  return sections.join(`
+`);
+}
+function writeTestReport(outputPath, options) {
+  const md = generateTestMarkdown(options);
+  writeFileSync2(outputPath, md, "utf-8");
+  return outputPath;
+}
+function generateTestMarkdown(options) {
+  const { version, findings, testTiming, profiles } = options;
+  const now = new Date;
+  const sections = [];
+  sections.push(`# Vitest Performance Report`);
+  sections.push("");
+  sections.push(`> Analyzed ${now.toISOString().replace("T", " ").slice(0, 16)} UTC by zeitzeuge v${version}`);
+  sections.push("");
+  const totalTests = testTiming.reduce((s, t) => s + t.testCount, 0);
+  const totalFiles = testTiming.length;
+  const totalDuration = testTiming.reduce((s, t) => s + t.duration, 0);
+  const slowest = testTiming.length > 0 ? testTiming.reduce((a, b) => a.duration > b.duration ? a : b) : null;
+  const totalGcTime = profiles.reduce((s, p) => s + p.summary.duration * p.summary.gcPercentage / 100, 0);
+  const gcPercentage = totalDuration > 0 ? (totalGcTime / totalDuration * 100).toFixed(2) : "0";
+  sections.push(`**Test run** ${totalTests} tests across ${totalFiles} files · ` + `**Total duration** ${(totalDuration / 1000).toFixed(2)}s · ` + `**Slowest file** ${slowest ? `${slowest.file} (${(slowest.duration / 1000).toFixed(2)}s)` : "—"} · ` + `**GC overhead** ${gcPercentage}% (${totalGcTime.toFixed(0)}ms)`);
+  sections.push("");
+  const counts = {
+    critical: findings.filter((f) => f.severity === "critical").length,
+    warning: findings.filter((f) => f.severity === "warning").length,
+    info: findings.filter((f) => f.severity === "info").length
+  };
+  if (findings.length === 0) {
+    sections.push(`## ✅ No issues found`);
+    sections.push("");
+    sections.push(`No significant performance problems were detected. ` + `Tests complete in ${(totalDuration / 1000).toFixed(2)}s — looking healthy.`);
+    sections.push("");
+  } else {
+    sections.push(`**${findings.length} issues found** — ` + `${counts.critical} critical, ${counts.warning} warning, ${counts.info} info`);
+    sections.push("");
+    for (const f of findings) {
+      const emoji = SEVERITY_EMOJI[f.severity];
+      const categoryLabel = CATEGORY_LABELS2[f.category] ?? f.category;
+      sections.push(`---`);
+      sections.push("");
+      sections.push(`## ${emoji} ${f.title}`);
+      sections.push("");
+      const context = [`**${categoryLabel}**`];
+      if (f.impactMs != null)
+        context.push(`${f.impactMs.toFixed(0)}ms impact`);
+      if (f.testFile)
+        context.push(`\`${f.testFile}\``);
+      if (f.hotFunction) {
+        context.push(`\`${f.hotFunction.name}\` (${f.hotFunction.selfTime.toFixed(0)}ms, ${f.hotFunction.selfPercent.toFixed(1)}%)`);
+      }
+      if (f.resourceUrl)
+        context.push(`\`${f.resourceUrl}\``);
+      sections.push(context.join(" · "));
+      sections.push("");
+      sections.push(f.description);
+      sections.push("");
+      if (f.suggestedFix) {
+        sections.push(`### How to fix`);
+        sections.push("");
+        const looksLikeCode = f.suggestedFix.includes("{") || f.suggestedFix.includes(";") || f.suggestedFix.includes("=>") || f.suggestedFix.includes("import ") || f.suggestedFix.includes("function ");
+        if (looksLikeCode) {
+          sections.push("```ts");
+          sections.push(f.suggestedFix);
+          sections.push("```");
+        } else {
+          sections.push(f.suggestedFix);
+        }
+        sections.push("");
+      }
+    }
+  }
+  sections.push(`---`);
+  sections.push("");
+  sections.push(`*Generated by zeitzeuge v${version}*`);
+  sections.push("");
+  return sections.join(`
+`);
+}
+
+// src/vitest/classify.ts
+import { resolve, relative } from "node:path";
+var TEST_FILE_PATTERNS = [/\.test\./, /\.spec\./, /\.bench\./, /__tests__\//, /__mocks__\//];
+var FRAMEWORK_PATTERNS = [
+  /\/vitest\//,
+  /\/tinybench\//,
+  /\/vite\//,
+  /\/@vitest\//,
+  /node:internal\//,
+  /node:v8/,
+  /node:worker_threads/,
+  /\.XdZDrNZV\./,
+  /\.CJqBMi0u\./
+];
+function classifyScript(scriptUrl, projectRoot, testFiles) {
+  if (!scriptUrl)
+    return "unknown";
+  let filePath = scriptUrl;
+  if (filePath.startsWith("file://")) {
+    try {
+      filePath = new URL(filePath).pathname;
+    } catch {}
+  }
+  if (filePath.startsWith("node:") || filePath.startsWith("v8:")) {
+    return "framework";
+  }
+  for (const pattern of FRAMEWORK_PATTERNS) {
+    if (pattern.test(filePath)) {
+      return "framework";
+    }
+  }
+  if (filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\")) {
+    return "dependency";
+  }
+  if (testFiles) {
+    const resolved = resolve(filePath);
+    if (testFiles.has(resolved)) {
+      return "test";
+    }
+  }
+  for (const pattern of TEST_FILE_PATTERNS) {
+    if (pattern.test(filePath)) {
+      return "test";
+    }
+  }
+  const resolvedProject = resolve(projectRoot);
+  const resolvedFile = resolve(filePath);
+  const rel = relative(resolvedProject, resolvedFile);
+  if (!rel.startsWith("..") && !rel.startsWith("/")) {
+    return "application";
+  }
+  return "unknown";
+}
+// package.json
+var package_default = {
+  name: "zeitzeuge",
+  version: "0.3.0",
+  description: "A deepagent to witnessing slowdowns in your test runs.",
+  keywords: [
+    "analysis",
+    "deepagent",
+    "frontend",
+    "performance",
+    "zeitzeuge"
+  ],
+  homepage: "https://github.com/christian-bromann/zeitzeuge",
+  license: "MIT",
+  author: "Christian Bromann <christian@bromann.dev>",
+  repository: {
+    type: "git",
+    url: "https://github.com/christian-bromann/zeitzeuge.git"
+  },
+  bin: {
+    zeitzeuge: "./dist/cli.js"
+  },
+  files: [
+    "dist"
+  ],
+  type: "module",
+  module: "src/cli.ts",
+  types: "./dist/cli.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/cli.d.ts",
+      default: "./dist/cli.js"
+    },
+    "./vitest": {
+      types: "./dist/vitest/index.d.ts",
+      default: "./dist/vitest/index.js"
+    }
+  },
+  scripts: {
+    "build:js": "bun build src/cli.ts src/vitest/index.ts --outdir dist --target node --format esm --packages external",
+    "build:types": "bunx tsc -p tsconfig.build.json",
+    build: "bun run build:js && bun run build:types",
+    dev: "bun run src/cli.ts",
+    fmt: "oxfmt",
+    "fmt:check": "oxfmt --check",
+    lint: "bun ./node_modules/oxlint/dist/cli.js",
+    "lint:fix": "bun ./node_modules/oxlint/dist/cli.js --fix",
+    test: "bun test"
+  },
+  dependencies: {
+    "@langchain/anthropic": "^1.3.17",
+    "@langchain/core": "^1.1.24",
+    "@langchain/node-vfs": "^0.1",
+    "@langchain/openai": "^1.2.7",
+    chalk: "^5.6.2",
+    deepagents: "^1.7.6",
+    langchain: "^1.2.23",
+    ora: "^9.3.0",
+    "puppeteer-core": "^24.37.2",
+    webdriverio: "^9.24.0",
+    yargs: "^18.0.0",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    "@types/yargs": "^17",
+    oxfmt: "^0.32.0",
+    oxlint: "^1.47.0",
+    typescript: "^5"
+  },
+  peerDependencies: {
+    vitest: ">=3.1.0"
+  },
+  engines: {
+    node: ">=24"
+  },
+  packageManager: "pnpm@10.29.2+sha512.bef43fa759d91fd2da4b319a5a0d13ef7a45bb985a3d7342058470f9d2051a3ba8674e629672654686ef9443ad13a82da2beb9eeb3e0221c87b8154fff9d74b8"
+};
+
+// src/vitest/reporter.ts
+class ZeitZeugeReporter {
+  options;
+  executionOrder = [];
+  isCI = !!process.env.CI;
+  constructor(options) {
+    this.options = options;
+  }
+  onTestModuleStart(testModule) {
+    const filePath = testModule?.moduleId ?? testModule?.id ?? "";
+    if (filePath && !this.executionOrder.includes(filePath)) {
+      this.executionOrder.push(filePath);
+    }
+  }
+  async onTestRunEnd(testModules) {
+    try {
+      await this.runAnalysis(testModules);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(chalk2.red(`
+[zeitzeuge] Analysis failed: ${message}
+`));
+      if (this.options.verbose && err instanceof Error) {
+        console.error(err.stack);
+      }
+    } finally {
+      this.cleanupProfileDir();
+    }
+  }
+  async runAnalysis(testModules) {
+    const testTiming = this.collectTestTiming(testModules);
+    if (testTiming.length === 0) {
+      if (this.options.verbose) {
+        console.log("[zeitzeuge] No test modules found, skipping analysis.");
+      }
+      return;
+    }
+    const spinner = this.isCI ? null : ora2({ text: "zeitzeuge: Collecting CPU profiles...", color: "cyan" }).start();
+    const profiles = this.collectAndParseProfiles(testTiming);
+    const heapProfiles = this.collectAndParseHeapProfiles(testTiming);
+    if (profiles.length === 0) {
+      spinner?.warn("zeitzeuge: No .cpuprofile files found. " + "Try running with { verbose: true } for diagnostics.");
+      return;
+    }
+    spinner?.succeed(`zeitzeuge: ${profiles.length} CPU profile(s) collected`);
+    if (this.options.verbose && heapProfiles.length > 0) {
+      console.log(`[zeitzeuge] ${heapProfiles.length} heap profile(s) collected`);
+    }
+    const testSources = this.readTestSources(testTiming);
+    const sourcePaths = this.readHotFunctionSources(profiles);
+    const wsSpinner = this.isCI ? null : ora2({ text: "zeitzeuge: Building analysis workspace...", color: "cyan" }).start();
+    const workspace = await createVitestWorkspace({
+      testTiming,
+      profiles,
+      heapProfiles,
+      testSources,
+      sourcePaths,
+      projectRoot: this.options.projectRoot
+    });
+    wsSpinner?.succeed("zeitzeuge: Workspace ready");
+    if (this.options.analyzeOnFinish) {
+      const agentSpinner = this.isCI ? null : ora2({
+        text: "zeitzeuge: Deep Agent analyzing test performance...",
+        color: "cyan"
+      }).start();
+      try {
+        const model = initModel();
+        const findings = await analyzeTestPerformance(model, workspace.backend);
+        agentSpinner?.succeed(`zeitzeuge: Analysis complete — ${findings.length} finding(s)`);
+        console.log(chalk2.cyan(`
+${"─".repeat(3)} zeitzeuge Performance Analysis ${"─".repeat(3)}
+`));
+        printFindings(findings);
+        const version = this.getVersion();
+        const reportPath = writeTestReport(this.options.output, {
+          version,
+          findings,
+          testTiming,
+          profiles
+        });
+        console.log(`
+\uD83D\uDCC4 Report written to ${reportPath}
+`);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("API key") || message.includes("OPENAI_API_KEY") || message.includes("ANTHROPIC_API_KEY")) {
+          agentSpinner?.warn("zeitzeuge: No LLM API key found. Set OPENAI_API_KEY or ANTHROPIC_API_KEY for AI-powered analysis.");
+        } else {
+          agentSpinner?.fail(`zeitzeuge: Analysis failed — ${message}`);
+          throw err;
+        }
+      } finally {
+        workspace.cleanup();
+      }
+    } else {
+      workspace.cleanup();
+    }
+  }
+  collectTestTiming(testModules) {
+    const results = [];
+    for (const mod of testModules) {
+      const filePath = mod.moduleId ?? mod.id ?? "";
+      if (!filePath)
+        continue;
+      const tests = [];
+      let passCount = 0;
+      let failCount = 0;
+      if (mod.children) {
+        this.walkTestCases(mod.children, tests);
+      }
+      for (const t of tests) {
+        if (t.status === "pass")
+          passCount++;
+        else if (t.status === "fail")
+          failCount++;
+      }
+      const diagnostic = typeof mod.diagnostic === "function" ? mod.diagnostic() : mod.diagnostic;
+      const duration = diagnostic?.duration ?? tests.reduce((s, t) => s + t.duration, 0);
+      const setupTime = diagnostic?.setupDuration ?? 0;
+      results.push({
+        file: filePath,
+        duration,
+        testCount: tests.length,
+        passCount,
+        failCount,
+        setupTime,
+        tests
+      });
+    }
+    return results;
+  }
+  walkTestCases(children, results) {
+    for (const child of children) {
+      if (child.type === "test" || child.type === "case") {
+        const diagnostic = typeof child.diagnostic === "function" ? child.diagnostic() : child.diagnostic;
+        results.push({
+          name: child.fullName ?? child.name ?? "",
+          duration: diagnostic?.duration ?? 0,
+          status: child.result?.state === "passed" ? "pass" : child.result?.state === "failed" ? "fail" : "skip"
+        });
+      }
+      if (child.children) {
+        this.walkTestCases(child.children, results);
+      }
+    }
+  }
+  collectAndParseProfiles(testTiming) {
+    const { profileDir } = this.options;
+    if (!existsSync(profileDir)) {
+      if (this.options.verbose) {
+        console.log(`[zeitzeuge] Profile directory not found: ${profileDir}`);
+      }
+      return [];
+    }
+    const allFiles = readdirSync(profileDir);
+    if (this.options.verbose) {
+      console.log(`[zeitzeuge] Profile directory ${profileDir} contains ${allFiles.length} file(s): ${allFiles.join(", ") || "(empty)"}`);
+    }
+    const profileFiles = allFiles.filter((f) => f.endsWith(".cpuprofile")).map((f) => {
+      const fullPath = join2(profileDir, f);
+      try {
+        const stat = statSync(fullPath);
+        return { name: f, path: fullPath, lastModified: stat.mtimeMs };
+      } catch {
+        return { name: f, path: fullPath, lastModified: 0 };
+      }
+    }).sort((a, b) => a.lastModified - b.lastModified);
+    if (profileFiles.length === 0) {
+      if (this.options.verbose) {
+        console.log(`[zeitzeuge] No .cpuprofile files in ${profileDir}. ` + `This usually means --cpu-prof wasn't passed to the worker process. ` + `Check that pool is set to 'forks' and execArgv includes '--cpu-prof'.`);
+      }
+      return [];
+    }
+    const results = [];
+    const orderedTestFiles = this.executionOrder.length > 0 ? this.executionOrder : testTiming.map((t) => t.file);
+    for (let i = 0;i < profileFiles.length; i++) {
+      const pf = profileFiles[i];
+      const testFile = orderedTestFiles[i] ?? `unknown-${i}`;
+      try {
+        const content = readFileSync(pf.path, "utf-8");
+        const rawProfile = JSON.parse(content);
+        const summary = parseCpuProfile(rawProfile, pf.path);
+        const testFileSet = new Set(testTiming.map((t) => resolve2(t.file)));
+        for (const fn of summary.hotFunctions) {
+          fn.sourceCategory = classifyScript(fn.scriptUrl, this.options.projectRoot, testFileSet);
+        }
+        for (const script of summary.scriptBreakdown) {
+          script.sourceCategory = classifyScript(script.scriptUrl, this.options.projectRoot, testFileSet);
+        }
+        results.push({
+          testFile,
+          profilePath: pf.path,
+          summary
+        });
+      } catch (err) {
+        if (this.options.verbose) {
+          console.warn(`[zeitzeuge] Failed to parse profile ${pf.name}: ${err instanceof Error ? err.message : err}`);
+        }
+      }
+    }
+    results.sort((a, b) => b.summary.duration - a.summary.duration);
+    return results.slice(0, 10);
+  }
+  collectAndParseHeapProfiles(testTiming) {
+    const { profileDir } = this.options;
+    if (!existsSync(profileDir)) {
+      return [];
+    }
+    const allFiles = readdirSync(profileDir);
+    const heapFiles = allFiles.filter((f) => f.endsWith(".heapprofile")).map((f) => {
+      const fullPath = join2(profileDir, f);
+      try {
+        const stat = statSync(fullPath);
+        return { name: f, path: fullPath, lastModified: stat.mtimeMs };
+      } catch {
+        return { name: f, path: fullPath, lastModified: 0 };
+      }
+    }).sort((a, b) => a.lastModified - b.lastModified);
+    if (heapFiles.length === 0) {
+      return [];
+    }
+    const orderedTestFiles = this.executionOrder.length > 0 ? this.executionOrder : testTiming.map((t) => t.file);
+    const results = [];
+    const testFileSet = new Set(testTiming.map((t) => resolve2(t.file)));
+    for (let i = 0;i < heapFiles.length; i++) {
+      const hf = heapFiles[i];
+      const testFile = orderedTestFiles[i] ?? `unknown-${i}`;
+      try {
+        const content = readFileSync(hf.path, "utf-8");
+        const rawHeapProfile = JSON.parse(content);
+        const summary = parseHeapProfile(rawHeapProfile, hf.path);
+        for (const fn of summary.topAllocations) {
+          fn.sourceCategory = classifyScript(fn.scriptUrl, this.options.projectRoot, testFileSet);
+        }
+        for (const script of summary.scriptBreakdown) {
+          script.sourceCategory = classifyScript(script.scriptUrl, this.options.projectRoot, testFileSet);
+        }
+        results.push({
+          testFile,
+          profilePath: hf.path,
+          summary
+        });
+      } catch (err) {
+        if (this.options.verbose) {
+          console.warn(`[zeitzeuge] Failed to parse heap profile ${hf.name}: ${err instanceof Error ? err.message : err}`);
+        }
+      }
+    }
+    return results.slice(0, 10);
+  }
+  readTestSources(testTiming) {
+    const sources = new Map;
+    for (const timing of testTiming) {
+      try {
+        const resolvedPath = resolve2(timing.file);
+        if (existsSync(resolvedPath)) {
+          sources.set(timing.file, readFileSync(resolvedPath, "utf-8"));
+        }
+      } catch {}
+    }
+    return sources;
+  }
+  readHotFunctionSources(profiles) {
+    const sources = new Map;
+    const seen = new Set;
+    for (const profile of profiles) {
+      for (const fn of profile.summary.hotFunctions) {
+        if (!fn.scriptUrl || seen.has(fn.scriptUrl)) {
+          continue;
+        }
+        const threshold = fn.sourceCategory === "application" ? 0.1 : 1;
+        if (fn.selfPercent < threshold)
+          continue;
+        seen.add(fn.scriptUrl);
+        try {
+          let filePath = fn.scriptUrl;
+          if (filePath.startsWith("file://")) {
+            filePath = new URL(filePath).pathname;
+          }
+          if (existsSync(filePath)) {
+            sources.set(fn.scriptUrl, readFileSync(filePath, "utf-8"));
+          }
+        } catch {}
+      }
+    }
+    return sources;
+  }
+  cleanupProfileDir() {
+    try {
+      if (existsSync(this.options.profileDir)) {
+        rmSync(this.options.profileDir, { recursive: true, force: true });
+      }
+    } catch {}
+  }
+  getVersion() {
+    return package_default.version ?? "(unknown)";
+  }
+}
+
+// src/vitest/plugin.ts
+function zeitzeuge(options = {}) {
+  const {
+    enabled = true,
+    output = "zeitzeuge-report.md",
+    profileDir = ".zeitzeuge-profiles",
+    heapProf = false,
+    analyzeOnFinish = true,
+    verbose = false,
+    projectRoot = process.cwd()
+  } = options;
+  return {
+    name: "vitest:zeitzeuge",
+    configureVitest(context) {
+      if (!enabled)
+        return;
+      const { vitest } = context;
+      const resolvedProfileDir = resolve3(profileDir);
+      try {
+        mkdirSync2(resolvedProfileDir, { recursive: true });
+      } catch {}
+      const cpuProfArgs = ["--cpu-prof", `--cpu-prof-dir=${resolvedProfileDir}`];
+      const heapProfArgs = heapProf ? ["--heap-prof", `--heap-prof-dir=${resolvedProfileDir}`] : [];
+      const profilingArgs = [...cpuProfArgs, ...heapProfArgs];
+      const existingArgv = vitest.config.execArgv ?? [];
+      vitest.config.execArgv = [...existingArgv, ...profilingArgs];
+      vitest.config.pool = "forks";
+      if (!vitest.config.poolOptions) {
+        vitest.config.poolOptions = {};
+      }
+      if (!vitest.config.poolOptions.forks) {
+        vitest.config.poolOptions.forks = {};
+      }
+      const existingForksArgv = vitest.config.poolOptions.forks.execArgv ?? [];
+      vitest.config.poolOptions.forks.execArgv = [...existingForksArgv, ...profilingArgs];
+      vitest.config.fileParallelism = false;
+      const reporter = new ZeitZeugeReporter({
+        output: resolve3(output),
+        profileDir: resolvedProfileDir,
+        analyzeOnFinish,
+        verbose,
+        projectRoot: resolve3(projectRoot)
+      });
+      if (Array.isArray(vitest.config.reporters)) {
+        vitest.config.reporters.push(reporter);
+      } else {
+        vitest.config.reporters = [reporter];
+      }
+      if (verbose) {
+        console.log(`[zeitzeuge] Plugin enabled — CPU profiling to ${resolvedProfileDir}`);
+        console.log(`[zeitzeuge] execArgv: ${JSON.stringify(vitest.config.execArgv)}`);
+        console.log(`[zeitzeuge] pool: ${vitest.config.pool}`);
+      }
+    }
+  };
+}
+export {
+  zeitzeuge
+};