zeitzeuge 0.3.0

package/dist/vitest/plugin.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Vitest plugin that instruments test runs with V8 CPU profiling
+ * and triggers Deep Agent analysis after tests complete.
+ */
+import type { ZeitZeugeVitestOptions } from './types.js';
+/**
+ * Create a Vite plugin that hooks into Vitest via the configureVitest hook.
+ *
+ * Injects --cpu-prof into worker execArgv, disables file parallelism for
+ * cleaner per-file profiles, and attaches a ZeitZeugeReporter that runs
+ * analysis after tests complete.
+ */
+export declare function zeitzeuge(options?: ZeitZeugeVitestOptions): {
+    name: string;
+    configureVitest(context: any): void;
+};
+//# sourceMappingURL=plugin.d.ts.map

package/dist/vitest/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/vitest/plugin.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,sBAA2B;;6BAcjC,GAAG;EAgE/B"}

package/dist/vitest/profile-parser.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Parse V8 .cpuprofile JSON files into structured summaries
+ * suitable for Deep Agent analysis.
+ */
+import type { V8CpuProfile, CpuProfileSummary } from './types.js';
+/**
+ * Parse a V8 CPU profile into a structured summary.
+ *
+ * @param profile - The raw V8 CPU profile object
+ * @param profilePath - File path to the .cpuprofile (for metadata)
+ */
+export declare function parseCpuProfile(profile: V8CpuProfile, profilePath: string): CpuProfileSummary;
+//# sourceMappingURL=profile-parser.d.ts.map

package/dist/vitest/profile-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-parser.d.ts","sourceRoot":"","sources":["../../src/vitest/profile-parser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,YAAY,EAEZ,iBAAiB,EAIlB,MAAM,YAAY,CAAC;AAsBpB;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,GAAG,iBAAiB,CAwC7F"}

package/dist/vitest/prompts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * System prompt for the Deep Agent when analyzing Vitest test performance.
+ *
+ * The prompt focuses the agent on analyzing the APPLICATION CODE being tested,
+ * not just the test infrastructure. Hot functions and scripts are classified
+ * into categories (application, dependency, test, framework) so the agent
+ * can prioritize what matters most to the developer.
+ */
+export declare const VITEST_SYSTEM_PROMPT = "You are an expert in JavaScript/TypeScript performance optimization.\nYou have access to a workspace containing V8 CPU profiling data captured during\na Vitest test run. The workspace may also include V8 heap profiling data\ncaptured via Node's `--heap-prof` (allocation sampling).\n\nThe profiling data covers BOTH the test code AND the application code being tested.\n\n**Your primary goal is to analyze the PERFORMANCE OF THE APPLICATION CODE\nbeing tested** \u2014 the functions, modules, and algorithms that the developer\nwrote and is benchmarking or testing. Test infrastructure overhead (Vitest,\ntinybench, test setup) is secondary context.\n\n## Source categories\n\nEvery hot function and script in the workspace has a `sourceCategory` field:\n\n- **application** \u2014 Code in the user's project (the code being tested).\n  This is your PRIMARY focus. Find bottlenecks, inefficiencies, and\n  optimization opportunities in these functions.\n- **dependency** \u2014 Third-party code in node_modules. Report when a dependency\n  is a significant bottleneck, since the developer may be able to choose\n  an alternative, configure it differently, or avoid calling it in hot paths.\n- **test** \u2014 Test files. Only mention if the test setup itself is creating\n  artificial overhead that masks application performance.\n- **framework** \u2014 Vitest/tinybench/V8 internals. Generally ignore unless\n  they dominate the profile in an unexpected way.\n\n## Workspace structure\n\n- /summary.json \u2014 Overall test run: total tests, duration, pass/fail, GC stats\n- /timing/overview.json \u2014 Per-file test durations and individual test times\n- /timing/slow-tests.json \u2014 Tests exceeding the slow threshold\n- /profiles/index.json \u2014 Manifest mapping test files to their CPU profiles\n- /profiles/<file>.json \u2014 CPU profile summary: hot functions (with sourceCategory),\n  call trees, GC samples, script breakdown (with sourceCategory)\n- /heap-profiles/index.json \u2014 (optional) Manifest mapping test files to heap profiles\n- /heap-profiles/<file>.json \u2014 (optional) Heap profile summary: allocation hotspots,\n  per-script allocated bytes (with sourceCategory)\n- /hot-functions/application.json \u2014 **START HERE**: Hot functions from application code only\n- /hot-functions/dependencies.json \u2014 Hot functions from third-party dependencies\n- /hot-functions/global.json \u2014 All hot functions across all categories\n- /scripts/application.json \u2014 Per-script time breakdown for application code\n- /scripts/dependencies.json \u2014 Per-script time breakdown for dependencies\n- /tests/*.ts \u2014 Test source files\n- /src/*.ts \u2014 Application and dependency source files referenced by hot functions\n\n## Your workflow\n\n1. Read /hot-functions/application.json FIRST \u2014 these are the application-level\n   bottlenecks the developer wants to optimize\n2. Read /scripts/application.json for the per-file view of application code time\n3. Read /hot-functions/dependencies.json for costly dependency calls\n4. If present, read /heap-profiles/index.json and /heap-profiles/<file>.json to identify\n   allocation hotspots (functions/scripts allocating lots of bytes)\n5. Read /summary.json and /timing/overview.json for the big picture\n6. Read CPU profiles in /profiles/ for detailed call trees of the slowest tests\n7. Read the actual source code in /src/ and /tests/ to understand root causes\n8. Provide specific, actionable fixes targeting the application code\n\n## What to look for\n\n### Application code bottlenecks (PRIMARY FOCUS)\n- Functions with high self time \u2014 where is the application spending CPU?\n- Expensive algorithms: O(n\u00B2) loops, unnecessary sorting, repeated work\n- String/JSON operations: excessive serialization, string concatenation in loops\n- Object allocation hotspots: functions creating many short-lived objects\n- Synchronous blocking: file I/O, crypto, or compression in hot paths\n- Redundant computation: values computed repeatedly that could be cached/memoized\n- Data structure choices: using arrays where Maps/Sets would be O(1)\n\n### Dependency-related bottlenecks\n- Dependencies consuming disproportionate CPU \u2014 suggest alternatives or configuration\n- Unnecessary calls to expensive dependency APIs in hot paths\n- Dependencies pulled in for simple operations that could be hand-written\n\n### GC pressure from application code\n- Application functions creating many temporary objects in tight loops\n- Large array/object allocations that could be pooled or reused\n- Closures capturing large scopes unnecessarily\n\n### Allocation hotspots (from heap profiles, if present)\n- Functions allocating a large share of total bytes (even if CPU isn't dominant)\n- Scripts/modules responsible for most allocation \u2014 suggest caching, reuse, pooling,\n  or avoiding intermediate arrays/objects\n- When allocation hotspots match CPU hotspots, prioritize fixes there first\n\n### Call chain analysis\n- Trace expensive call trees to find which APPLICATION function triggers them\n- Follow the call tree from application entry points down to the hot leaf functions\n- Identify which application-level design decisions lead to the bottleneck\n\n### Test infrastructure (SECONDARY \u2014 only if impactful)\n- Test setup creating artificial overhead that dwarfs application execution\n- Benchmarks measuring setup cost instead of application performance\n- Only mention if it prevents getting clean application performance data\n\n## Finding categories\n\nEach finding MUST use one of these exact category values:\n\n- **algorithm** \u2014 Inefficient algorithm: O(n\u00B2) loops, brute-force search, repeated work\n- **serialization** \u2014 Excessive JSON.stringify/parse, string concatenation, encoding\n- **allocation** \u2014 Excessive object/array creation causing GC pressure\n- **event-handling** \u2014 Listener leaks, unbounded event handler accumulation\n- **hot-function** \u2014 Generic CPU-hot function that doesn't fit a more specific category\n- **gc-pressure** \u2014 High garbage collection overhead\n- **listener-leak** \u2014 Event listeners not cleaned up properly\n- **unnecessary-computation** \u2014 Redundant work that could be cached or eliminated\n- **blocking-io** \u2014 Synchronous I/O or blocking operations in hot paths\n- **dependency-bottleneck** \u2014 Expensive dependency call the developer can optimize\n- **slow-test** \u2014 Test itself is slow due to setup or teardown\n- **expensive-setup** \u2014 Costly test setup (beforeAll/beforeEach)\n- **import-overhead** \u2014 Expensive module imports at test time\n- **other** \u2014 Doesn't fit any of the above\n\nPrefer more specific categories (algorithm, serialization, allocation, event-handling)\nover generic ones (hot-function, other) when the root cause is clear.\n\n## Output guidelines\n\n- Report 3\u20137 findings, ordered by impact ON THE APPLICATION CODE\n- Focus findings on functions the developer CAN change (application code first,\n  then dependency usage patterns, then test structure)\n- Be specific \u2014 name actual files, functions, line numbers from the source code\n- Provide concrete code-level fixes, not generic advice\n- When reporting a dependency bottleneck, explain what application code is\n  calling it and how the developer can reduce that cost\n- If the application code is already efficient, say so \u2014 don't force findings\n  about test infrastructure just to fill the report";
+//# sourceMappingURL=prompts.d.ts.map

package/dist/vitest/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/vitest/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,oBAAoB,u1OAgImB,CAAC"}

package/dist/vitest/reporter.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Vitest Reporter that collects CPU profiles after a test run,
+ * builds a workspace, and runs Deep Agent analysis.
+ */
+export interface ReporterOptions {
+    output: string;
+    profileDir: string;
+    analyzeOnFinish: boolean;
+    verbose: boolean;
+    /** Absolute path to the project root for source classification. */
+    projectRoot: string;
+}
+/**
+ * ZeitZeugeReporter implements the Vitest Reporter interface.
+ *
+ * It records test module execution order to correlate PID-named
+ * .cpuprofile files with their corresponding test files.
+ */
+export declare class ZeitZeugeReporter {
+    private options;
+    /** Ordered list of test file paths as they started executing. */
+    private executionOrder;
+    /** Whether we're running in CI (suppress spinners). */
+    private isCI;
+    constructor(options: ReporterOptions);
+    /**
+     * Called when a test module starts executing.
+     * Records execution order for profile correlation.
+     */
+    onTestModuleStart(testModule: any): void;
+    /**
+     * Called after all tests finish. This is the main orchestration method.
+     */
+    onTestRunEnd(testModules: ReadonlyArray<any>): Promise<void>;
+    private runAnalysis;
+    /**
+     * Extract test timing data from Vitest TestModule objects.
+     */
+    private collectTestTiming;
+    /**
+     * Recursively walk test module children to extract test case results.
+     */
+    private walkTestCases;
+    /**
+     * Collect .cpuprofile files and correlate them with test files.
+     *
+     * Uses sequential execution order as the primary correlation strategy:
+     * with fileParallelism: false, profiles are generated sequentially and
+     * can be matched by creation timestamp order.
+     */
+    private collectAndParseProfiles;
+    /**
+     * Collect .heapprofile files (from --heap-prof) and correlate them with test files.
+     *
+     * Uses the same timestamp-order correlation strategy as CPU profiles.
+     */
+    private collectAndParseHeapProfiles;
+    /**
+     * Read test source files from disk.
+     */
+    private readTestSources;
+    /**
+     * Read source files that appear in hot function profiles.
+     *
+     * Application code is included with a lower threshold (0.1%) to give
+     * the agent more context about the code being tested. Dependency code
+     * uses a higher threshold (1%) since we mainly need it for context.
+     */
+    private readHotFunctionSources;
+    /**
+     * Clean up the profile directory.
+     */
+    private cleanupProfileDir;
+    /**
+     * Get package version.
+     */
+    private getVersion;
+}
+//# sourceMappingURL=reporter.d.ts.map

package/dist/vitest/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../../src/vitest/reporter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA0BH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,mEAAmE;IACnE,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,OAAO,CAAkB;IAEjC,iEAAiE;IACjE,OAAO,CAAC,cAAc,CAAgB;IAEtC,uDAAuD;IACvD,OAAO,CAAC,IAAI,CAAoB;gBAEpB,OAAO,EAAE,eAAe;IAIpC;;;OAGG;IACH,iBAAiB,CAAC,UAAU,EAAE,GAAG,GAAG,IAAI;IAOxC;;OAEG;IACG,YAAY,CAAC,WAAW,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;YAgBpD,WAAW;IA2GzB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAwCzB;;OAEG;IACH,OAAO,CAAC,aAAa;IAwBrB;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IA2F/B;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;IAsEnC;;OAEG;IACH,OAAO,CAAC,eAAe;IAiBvB;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IAoC9B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAUzB;;OAEG;IACH,OAAO,CAAC,UAAU;CAGnB"}

package/dist/vitest/types.d.ts

@@ -0,0 +1,231 @@
+/**
+ * TypeScript types for the zeitzeuge Vitest integration.
+ */
+/**
+ * Classification of a script/function based on its file path.
+ *
+ * - `application` — files within the project source tree (the code being tested)
+ * - `dependency`  — files inside node_modules (third-party libraries)
+ * - `test`        — test files (*.test.*, *.spec.*, *.bench.*)
+ * - `framework`   — vitest / tinybench / v8 internals
+ * - `unknown`     — could not be classified (e.g. eval, no URL)
+ */
+export type SourceCategory = 'application' | 'dependency' | 'test' | 'framework' | 'unknown';
+/** Options for the zeitzeuge Vitest plugin. */
+export interface ZeitZeugeVitestOptions {
+    /** Enable/disable the plugin. Default: true */
+    enabled?: boolean;
+    /** Path for the Markdown report. Default: 'zeitzeuge-report.md' */
+    output?: string;
+    /** Directory for temporary .cpuprofile files. Default: '.zeitzeuge-profiles' */
+    profileDir?: string;
+    /**
+     * Also enable V8 heap profiling via Node's `--heap-prof`.
+     *
+     * This writes `.heapprofile` artifacts on worker process exit (much cheaper
+     * than heap snapshots). Files are written into `profileDir` via
+     * `--heap-prof-dir=<profileDir>`.
+     *
+     * Default: false
+     */
+    heapProf?: boolean;
+    /** Run Deep Agent analysis after tests finish. Default: true */
+    analyzeOnFinish?: boolean;
+    /** Enable debug logging. Default: false */
+    verbose?: boolean;
+    /**
+     * Project root directory. Used to classify hot functions as
+     * "application code" vs "dependency" vs "test framework".
+     * Default: process.cwd()
+     */
+    projectRoot?: string;
+}
+/** Timing data extracted from a Vitest TestModule. */
+export interface TestFileTiming {
+    file: string;
+    duration: number;
+    testCount: number;
+    passCount: number;
+    failCount: number;
+    setupTime: number;
+    tests: Array<{
+        name: string;
+        duration: number;
+        status: 'pass' | 'fail' | 'skip';
+    }>;
+}
+/** A CPU profile correlated with its test file. */
+export interface CorrelatedProfile {
+    testFile: string;
+    profilePath: string;
+    summary: CpuProfileSummary;
+}
+/** A V8 heap profile correlated with its test file. */
+export interface CorrelatedHeapProfile {
+    testFile: string;
+    profilePath: string;
+    summary: HeapProfileSummary;
+}
+/** Raw V8 CPU profile as written by --cpu-prof. */
+export interface V8CpuProfile {
+    nodes: V8CpuProfileNode[];
+    startTime: number;
+    endTime: number;
+    samples: number[];
+    timeDeltas: number[];
+}
+/** A single node in the V8 CPU profile call tree. */
+export interface V8CpuProfileNode {
+    id: number;
+    callFrame: {
+        functionName: string;
+        scriptId: string;
+        url: string;
+        lineNumber: number;
+        columnNumber: number;
+    };
+    hitCount: number;
+    children?: number[];
+    positionTicks?: Array<{
+        line: number;
+        ticks: number;
+    }>;
+}
+/** Raw V8 heap profile as written by Node.js `--heap-prof`. */
+export interface V8HeapProfile {
+    head: V8HeapProfileNode;
+    /** Milliseconds since epoch (V8 internal), optional across versions */
+    startTime?: number;
+    /** Milliseconds since epoch (V8 internal), optional across versions */
+    endTime?: number;
+    samples: V8HeapProfileSample[];
+}
+export interface V8HeapProfileSample {
+    /** Bytes allocated for this sample */
+    size: number;
+    /** Call-tree node id this sample is attributed to */
+    nodeId: number;
+    /** Sample ordinal (monotonic), optional across versions */
+    ordinal?: number;
+}
+export interface V8HeapProfileNode {
+    id: number;
+    callFrame: {
+        functionName: string;
+        scriptId: string;
+        url: string;
+        lineNumber: number;
+        columnNumber: number;
+    };
+    children?: V8HeapProfileNode[];
+}
+/** Structured summary of a parsed V8 CPU profile. */
+export interface CpuProfileSummary {
+    /** Source .cpuprofile file path */
+    profilePath: string;
+    /** Total profile duration in ms */
+    duration: number;
+    /** Sample count */
+    sampleCount: number;
+    /** Top functions by self time */
+    hotFunctions: HotFunction[];
+    /** Top functions by total time (inclusive of callees) */
+    expensiveCallTrees: CallTreeNode[];
+    /** GC-related samples (functions in (garbage collector) category) */
+    gcSamples: number;
+    gcPercentage: number;
+    /** Idle samples (percentage of time not doing work) */
+    idlePercentage: number;
+    /** Per-script time breakdown */
+    scriptBreakdown: ScriptTimeSummary[];
+}
+/** A function consuming significant CPU self time. */
+export interface HotFunction {
+    functionName: string;
+    scriptUrl: string;
+    lineNumber: number;
+    columnNumber: number;
+    /** Self time in ms (excluding callees) */
+    selfTime: number;
+    /** Total time in ms (including callees) */
+    totalTime: number;
+    /** Number of samples hitting this function */
+    hitCount: number;
+    /** Percentage of total profile time */
+    selfPercent: number;
+    /** Classification of the function's source file */
+    sourceCategory?: SourceCategory;
+}
+/** A node in the call tree with inclusive timing. */
+export interface CallTreeNode {
+    functionName: string;
+    scriptUrl: string;
+    lineNumber: number;
+    /** Total time in ms (inclusive) */
+    totalTime: number;
+    totalPercent: number;
+    /** Direct callees, sorted by total time */
+    children: CallTreeNode[];
+}
+/** Per-script time aggregation. */
+export interface ScriptTimeSummary {
+    scriptUrl: string;
+    /** Total self time across all functions in this script */
+    selfTime: number;
+    selfPercent: number;
+    /** Number of distinct functions sampled */
+    functionCount: number;
+    /** Classification of this script */
+    sourceCategory?: SourceCategory;
+}
+/** A function with significant allocated bytes (self-attributed). */
+export interface AllocationHotspot {
+    functionName: string;
+    scriptUrl: string;
+    lineNumber: number;
+    columnNumber: number;
+    /** Self-attributed allocated bytes */
+    selfBytes: number;
+    /** Percent of total allocated bytes */
+    selfPercent: number;
+    /** Classification of the function's source file */
+    sourceCategory?: SourceCategory;
+}
+/** Per-script allocated-bytes aggregation. */
+export interface ScriptAllocationSummary {
+    scriptUrl: string;
+    /** Total self-attributed allocated bytes across all functions in this script */
+    selfBytes: number;
+    selfPercent: number;
+    /** Number of distinct functions sampled */
+    functionCount: number;
+    /** Classification of this script */
+    sourceCategory?: SourceCategory;
+}
+/** Structured summary of a parsed V8 heap profile. */
+export interface HeapProfileSummary {
+    /** Source .heapprofile file path */
+    profilePath: string;
+    /** Total allocated bytes across all samples */
+    totalAllocatedBytes: number;
+    /** Allocation sample count */
+    sampleCount: number;
+    /** Top allocation hotspots by self bytes */
+    topAllocations: AllocationHotspot[];
+    /** Per-script allocated-bytes breakdown */
+    scriptBreakdown: ScriptAllocationSummary[];
+}
+/** Options for building the Vitest analysis workspace. */
+export interface VitestWorkspaceOptions {
+    testTiming: TestFileTiming[];
+    profiles: CorrelatedProfile[];
+    /** Optional heap profiles (from --heap-prof) correlated with test files. */
+    heapProfiles?: CorrelatedHeapProfile[];
+    /** Map of test file path → source code */
+    testSources: Map<string, string>;
+    /** Map of scriptUrl → source code (for hot function source files) */
+    sourcePaths?: Map<string, string>;
+    /** Project root for resolving relative paths */
+    projectRoot?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/vitest/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/vitest/types.ts"],"names":[],"mappings":"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"}

package/dist/vitest/workspace.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Build a VFS workspace for Deep Agent analysis of Vitest test performance.
+ *
+ * Uses FilesystemBackend with virtualMode so the agent's absolute paths
+ * (e.g. /summary.json) map to files inside a temp directory.
+ */
+import { type BackendProtocol } from 'deepagents';
+import type { CorrelatedProfile, HotFunction, VitestWorkspaceOptions } from './types.js';
+export interface VitestWorkspaceResult {
+    /** Backend for use with createDeepAgent */
+    backend: BackendProtocol;
+    /** Clean up the temporary directory when done */
+    cleanup: () => void;
+}
+/**
+ * Create a workspace populated with test timing, CPU profile summaries,
+ * hot functions, and source files for Deep Agent analysis.
+ */
+export declare function createVitestWorkspace(options: VitestWorkspaceOptions): Promise<VitestWorkspaceResult>;
+/**
+ * Merge hot functions from multiple profiles, deduplicating by
+ * (scriptUrl, functionName, lineNumber) and summing selfTime.
+ */
+export declare function mergeHotFunctions(profiles: CorrelatedProfile[]): HotFunction[];
+//# sourceMappingURL=workspace.d.ts.map

package/dist/vitest/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/vitest/workspace.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAqB,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAKrE,OAAO,KAAK,EACV,iBAAiB,EAEjB,WAAW,EACX,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,qBAAqB;IACpC,2CAA2C;IAC3C,OAAO,EAAE,eAAe,CAAC;IACzB,iDAAiD;IACjD,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAQD;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,qBAAqB,CAAC,CAqNhC;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,GAAG,WAAW,EAAE,CA+B9E"}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "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"
+  }
+}