aipeek 0.2.6 → 0.2.8

package/dist/index.cjs

@@ -5,7 +5,7 @@
 
 
 
-var _chunk5ZZYOETFcjs = require('./chunk-5ZZYOETF.cjs');
+var _chunkSDUTK75Ycjs = require('./chunk-SDUTK75Y.cjs');
 require('./chunk-Z2Y65YOY.cjs');
 
 
@@ -14,4 +14,4 @@ require('./chunk-Z2Y65YOY.cjs');
 
 
 
-exports.aipeekPlugin = _chunk5ZZYOETFcjs.aipeekPlugin; exports.check = _chunk5ZZYOETFcjs.check; exports.diffState = _chunk5ZZYOETFcjs.diffState; exports.emitCheck = _chunk5ZZYOETFcjs.emitCheck; exports.emitDiff = _chunk5ZZYOETFcjs.emitDiff; exports.emitSummary = _chunk5ZZYOETFcjs.emitSummary;
+exports.aipeekPlugin = _chunkSDUTK75Ycjs.aipeekPlugin; exports.check = _chunkSDUTK75Ycjs.check; exports.diffState = _chunkSDUTK75Ycjs.diffState; exports.emitCheck = _chunkSDUTK75Ycjs.emitCheck; exports.emitDiff = _chunkSDUTK75Ycjs.emitDiff; exports.emitSummary = _chunkSDUTK75Ycjs.emitSummary;

package/dist/index.d.cts

@@ -28,15 +28,58 @@ interface ErrorEntry {
     line?: number;
     column?: number;
 }
+interface ActionEntry {
+    type: string;
+    target: string;
+    value?: string;
+    trusted: boolean;
+    view?: string;
+    modal?: string;
+    focus?: string;
+    ts: number;
+    tab?: string;
+}
 interface RawState {
+    tab?: string;
     url: string;
+    title?: string;
+    visible?: boolean;
     ui: string;
     console: LogEntry[];
     network: NetworkRequest[];
     errors: ErrorEntry[];
+    actions?: ActionEntry[];
     state: Record<string, unknown>;
+    performance?: PerformanceData;
     timestamp: number;
 }
+interface PerfStat {
+    total: number;
+    n: number;
+    max: number;
+    samples: number[];
+}
+interface PerfBucketData {
+    name: string;
+    components: Record<string, PerfStat>;
+    frames: {
+        total: number;
+        long: number;
+        max: number;
+        samples: number[];
+    };
+    lines: Record<string, PerfStat>;
+}
+interface PerformanceData {
+    windowMs: number;
+    hiddenFrames: number;
+    mobxPatched: boolean;
+    buckets: PerfBucketData[];
+    longtasks: {
+        count: number;
+        max: number;
+    };
+}
 interface CompactState {
     url: string;
     ui: string;
@@ -44,6 +87,7 @@ interface CompactState {
     network: string;
     errors: string;
     state: string;
+    performance?: string;
     timestamp: number;
     counts: {
         console: number;

package/dist/index.d.ts

@@ -28,15 +28,58 @@ interface ErrorEntry {
     line?: number;
     column?: number;
 }
+interface ActionEntry {
+    type: string;
+    target: string;
+    value?: string;
+    trusted: boolean;
+    view?: string;
+    modal?: string;
+    focus?: string;
+    ts: number;
+    tab?: string;
+}
 interface RawState {
+    tab?: string;
     url: string;
+    title?: string;
+    visible?: boolean;
     ui: string;
     console: LogEntry[];
     network: NetworkRequest[];
     errors: ErrorEntry[];
+    actions?: ActionEntry[];
     state: Record<string, unknown>;
+    performance?: PerformanceData;
     timestamp: number;
 }
+interface PerfStat {
+    total: number;
+    n: number;
+    max: number;
+    samples: number[];
+}
+interface PerfBucketData {
+    name: string;
+    components: Record<string, PerfStat>;
+    frames: {
+        total: number;
+        long: number;
+        max: number;
+        samples: number[];
+    };
+    lines: Record<string, PerfStat>;
+}
+interface PerformanceData {
+    windowMs: number;
+    hiddenFrames: number;
+    mobxPatched: boolean;
+    buckets: PerfBucketData[];
+    longtasks: {
+        count: number;
+        max: number;
+    };
+}
 interface CompactState {
     url: string;
     ui: string;
@@ -44,6 +87,7 @@ interface CompactState {
     network: string;
     errors: string;
     state: string;
+    performance?: string;
     timestamp: number;
     counts: {
         console: number;

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   emitCheck,
   emitDiff,
   emitSummary
-} from "./chunk-XA2LT6I4.js";
+} from "./chunk-4BPXH2SW.js";
 export {
   aipeekPlugin,
   check,

package/dist/plugin.cjs

@@ -3,11 +3,13 @@
 
 
 
-var _chunk5ZZYOETFcjs = require('./chunk-5ZZYOETF.cjs');
+
+var _chunkSDUTK75Ycjs = require('./chunk-SDUTK75Y.cjs');
 require('./chunk-Z2Y65YOY.cjs');
 
 
 
 
 
-exports.END_TAG = _chunk5ZZYOETFcjs.END_TAG; exports.START_TAG = _chunk5ZZYOETFcjs.START_TAG; exports.aipeekPlugin = _chunk5ZZYOETFcjs.aipeekPlugin; exports.injectClaudeMd = _chunk5ZZYOETFcjs.injectClaudeMd;
+
+exports.END_TAG = _chunkSDUTK75Ycjs.END_TAG; exports.START_TAG = _chunkSDUTK75Ycjs.START_TAG; exports.aipeekPlugin = _chunkSDUTK75Ycjs.aipeekPlugin; exports.injectClaudeMd = _chunkSDUTK75Ycjs.injectClaudeMd; exports.renderClaudeMd = _chunkSDUTK75Ycjs.renderClaudeMd;

package/dist/plugin.js

@@ -2,11 +2,13 @@ import {
   END_TAG,
   START_TAG,
   aipeekPlugin,
-  injectClaudeMd
-} from "./chunk-XA2LT6I4.js";
+  injectClaudeMd,
+  renderClaudeMd
+} from "./chunk-4BPXH2SW.js";
 export {
   END_TAG,
   START_TAG,
   aipeekPlugin,
-  injectClaudeMd
+  injectClaudeMd,
+  renderClaudeMd
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "aipeek",
-    "version": "0.2.6",
+    "version": "0.2.8",
     "description": "Gives AI a peek into your running browser app — UI tree, console, network, errors, state",
     "license": "MIT",
     "repository": {
@@ -22,6 +22,7 @@
         "src"
     ],
     "scripts": {
+        "prebuild": "node --import ../../node_modules/tsx/dist/loader.mjs ../../packages/repodex/src/cli.ts",
         "build": "tsup",
         "test": "vitest run",
         "test:watch": "vitest",
@@ -42,6 +43,7 @@
     },
     "devDependencies": {
         "jsdom": "^29.1.1",
+        "repodex": "^0.3.7",
         "teact": "file:../teact",
         "tsup": "^8.4.0",
         "typescript": "~5.7.2",

package/src/babel/line-profiler.ts

@@ -0,0 +1,190 @@
+import type { PluginObj, NodePath } from '@babel/core'
+import type { Statement, VariableDeclaration, ReturnStatement, ExpressionStatement } from '@babel/types'
+import * as t from '@babel/types'
+import path from 'path'
+
+/**
+ * Babel plugin: wrap statements with __line(label, () => ...) for line-level profiling.
+ *
+ * Only wraps statements that have measurable cost:
+ * - VariableDeclaration with initializer
+ * - ExpressionStatement (function calls, assignments)
+ * - ReturnStatement with argument
+ *
+ * Skips:
+ * - import/export (module syntax)
+ * - control flow (if/for/while/switch) — their bodies get wrapped, not the structure
+ * - empty statements, type declarations
+ */
+export function lineProfilerPlugin(): PluginObj {
+    return {
+        name: 'aipeek-line-profiler',
+        visitor: {
+            VariableDeclaration(nodePath: NodePath<VariableDeclaration>, state) {
+                if (shouldSkip(nodePath, state)) return
+                const decl = nodePath.node.declarations[0]
+                if (!decl?.init) return // skip `let x;`
+                if (hasAwaitOrYield(decl.init)) return // wrapping in arrow fn breaks async semantics
+
+                const label = makeLabel(nodePath, state, decl.id.type === 'Identifier' ? decl.id.name : undefined)
+                const wrapped = wrapExpr(decl.init, label)
+                decl.init = wrapped
+            },
+
+            ExpressionStatement(nodePath: NodePath<ExpressionStatement>, state) {
+                if (shouldSkip(nodePath, state)) return
+                if (hasAwaitOrYield(nodePath.node.expression)) return
+
+                const label = makeLabel(nodePath, state)
+                const wrapped = wrapExpr(nodePath.node.expression, label)
+                nodePath.node.expression = wrapped
+            },
+
+            ReturnStatement(nodePath: NodePath<ReturnStatement>, state) {
+                if (shouldSkip(nodePath, state)) return
+                if (!nodePath.node.argument) return // skip `return;`
+                if (hasAwaitOrYield(nodePath.node.argument)) return
+
+                const label = makeLabel(nodePath, state)
+                const wrapped = wrapExpr(nodePath.node.argument, label)
+                nodePath.node.argument = wrapped
+            },
+        },
+    }
+}
+
+function shouldSkip(nodePath: NodePath<Statement>, state: any): boolean {
+    const filename: string = state.file?.opts?.filename ?? ''
+    // Skip node_modules — third-party cost isn't the app's to fix.
+    if (filename.includes('node_modules')) return true
+    // Skip aipeek's own source: the profiler reads state by walking the React fiber tree
+    // (client.ts walkFiber/walkChildren) on every /ui|/dom|/screen. That's MEASUREMENT cost,
+    // not the app's — instrumenting it lets the observer dominate its own report (290ms self-top).
+    if (filename.includes('packages/aipeek/')) return true
+
+    // Skip module syntax — import/export carry no runtime cost to measure
+    const node = nodePath.node
+    if (t.isImportDeclaration(node)) return true
+    if (t.isExportNamedDeclaration(node)) return true
+    if (t.isExportDefaultDeclaration(node)) return true
+    if (t.isExportAllDeclaration(node)) return true
+
+    // Skip if already wrapped
+    if (t.isExpressionStatement(node) && t.isCallExpression(node.expression)) {
+        const callee = node.expression.callee
+        if (t.isIdentifier(callee) && callee.name === '__line') return true
+    }
+
+    return false
+}
+
+function makeLabel(nodePath: NodePath<Statement>, state: any, varName?: string): string {
+    const filename = state.file.opts.filename ?? 'unknown'
+    const basename = path.basename(filename)
+    const line = resolveLine(nodePath)
+
+    if (varName) {
+        return `${basename}:${line}:${varName}`
+    }
+    return `${basename}:${line}`
+}
+
+// Resolve the source line a wrapped statement should point to.
+//
+// A node synthesized by an upstream transform (e.g. mobx-react-observer rewriting
+// `function Root(){…}` → `const Root = observer(function Root(){…})`) carries NO loc on the
+// outer declaration. Two recovery moves, in priority order:
+//
+//   1. descend — the synthesized wrapper still contains the user's ORIGINAL node
+//      (`function Root()` keeps its loc 59). The nearest loc-bearing descendant is the most
+//      specific real source location, so prefer it.
+//   2. climb — only if the whole subtree is synthetic (no loc anywhere inside) do we fall back
+//      to the nearest ancestor's loc.
+//
+// Without this, observer-wrapped components — the ones most worth profiling — collapse onto
+// `<file>:1` (climbing all the way to Program) or `<file>:0` (no loc at all).
+function resolveLine(nodePath: NodePath<Statement>): number {
+    if (nodePath.node.loc) return nodePath.node.loc.start.line
+
+    const descend = firstLocLine(nodePath.node)
+    if (descend != null) return descend
+
+    let p: NodePath | null = nodePath.parentPath
+    while (p) {
+        if (p.node.loc) return p.node.loc.start.line
+        p = p.parentPath
+    }
+    return 0
+}
+
+// Pre-order DFS for the first node carrying a loc. Skips the root itself (caller already
+// checked it). Source-order traversal so the earliest real line wins.
+function firstLocLine(node: t.Node): number | null {
+    for (const key of t.VISITOR_KEYS[node.type] ?? []) {
+        const child = (node as any)[key]
+        const children = Array.isArray(child) ? child : [child]
+        for (const c of children) {
+            if (!c || typeof c.type !== 'string') continue
+            if (c.loc) return c.loc.start.line
+            const deeper = firstLocLine(c)
+            if (deeper != null) return deeper
+        }
+    }
+    return null
+}
+
+// Emit: (globalThis.__line || ((_l, f) => f()))(label, () => expr)
+// NOT a bare `__line(...)`: instrumented modules eval their top-level statements at IMPORT time,
+// before client-patch installs window.__line — a bare identifier then throws ReferenceError and
+// kills the app. globalThis.__line is a member access (→ undefined, not a throw); the || fallback
+// just runs the original expr, so the instrumentation is inert until the runtime is present.
+function wrapExpr(expr: t.Expression, label: string): t.CallExpression {
+    const runtime = t.logicalExpression(
+        '||',
+        t.memberExpression(t.identifier('globalThis'), t.identifier('__line')),
+        t.arrowFunctionExpression(
+            [t.identifier('_l'), t.identifier('f')],
+            t.callExpression(t.identifier('f'), []),
+        ),
+    )
+    return t.callExpression(
+        runtime,
+        [
+            t.stringLiteral(label),
+            t.arrowFunctionExpression([], expr),
+        ]
+    )
+}
+
+// True if expr contains an await/yield at THIS function level (not inside a nested function).
+// Wrapping such an expr in `() => expr` would either be a syntax error (await in non-async
+// arrow) or silently change semantics (the arrow returns a Promise instead of awaiting).
+// Nested functions are their own scope, so we stop recursing at function boundaries.
+function hasAwaitOrYield(node: t.Node | null | undefined): boolean {
+    if (!node || typeof node !== 'object') return false
+    if (t.isAwaitExpression(node) || t.isYieldExpression(node)) return true
+    // Don't descend into nested functions — their await/yield belongs to their own scope.
+    if (
+        t.isFunctionExpression(node)
+        || t.isArrowFunctionExpression(node)
+        || t.isFunctionDeclaration(node)
+        || t.isObjectMethod(node)
+        || t.isClassMethod(node)
+    ) return false
+
+    for (const key of Object.keys(node)) {
+        if (key === 'loc' || key === 'start' || key === 'end' || key === 'leadingComments' || key === 'trailingComments') continue
+        const child = (node as any)[key]
+        if (Array.isArray(child)) {
+            for (const c of child) {
+                if (c && typeof c.type === 'string' && hasAwaitOrYield(c)) return true
+            }
+        }
+        else if (child && typeof child.type === 'string') {
+            if (hasAwaitOrYield(child)) return true
+        }
+    }
+    return false
+}
+
+export default lineProfilerPlugin