aihand 0.0.1 → 0.1.0

package/README.md

@@ -1,5 +1,139 @@
 # aihand
 
-**The hand of AI** — read code, drive the live UI, and refactor source from one CLI.
+**The hand of AI.** One CLI that lets an agent *read* your code, *refactor* it, and *drive your running app* — the three things a human does with their hands when working on software, given to the model directly.
 
-> **0.0.1 is a name placeholder.** The full tool ships shortly.
+Today an agent works half-blind: it reads files but can't see the running page, it edits text but can't safely move a symbol, it guesses at the UI instead of looking. `aihand` closes that loop. Add one Vite plugin and the agent gets a code map, AST-safe refactors, and a live probe into the browser — all over plain HTTP, all from one command.
+
+```
+aihand read     panel | source <file:line>      understand code (read-only)
+aihand refactor move-file | rename | move-symbol  change source (AST, writes disk)
+aihand runtime  screen | click | fill | wait …    inspect & drive the running app
+aihand probe    open <url> | screen | click …     drive ANY website (out-of-app, own chromium)
+```
+
+## Why
+
+The bottleneck in agentic coding isn't the model — it's the **round-trips**. Every time the agent has to guess, then check, then correct, that's a wasted turn. `aihand` is built to collapse those turns:
+
+- **See the app, don't guess it.** `runtime screen` returns a semantic, spatial sketch of the live UI — view, modals, focus, every clickable knob — so the agent reads the page directly instead of asking you to describe it.
+- **One round-trip per action.** Click-and-observe is fused: an action returns the *delta* it caused (and, for async flows, the trajectory until it settles), so the agent doesn't re-screen to find out what happened.
+- **Refactors that can't silently break.** `move-symbol` / `rename` go through ts-morph (never regex), rewrite every importer, and *refuse* unsafe edits with a clear reason instead of producing a broken tree.
+- **A control-panel view of the whole app.** `read panel` projects thousands of components down to the dozen knobs that actually drive state — the agent learns "what this app can do and which store each control writes" in one read.
+
+It's fully self-contained — a static code-analysis engine (tree-sitter) and a runtime browser probe + AST refactorer (ts-morph), both vendored in. No peer tools to install.
+
+## Install
+
+```sh
+npm i -D aihand
+```
+
+Add the plugin once to your `vite.config.ts`:
+
+```ts
+import { aihand } from 'aihand/vite'
+
+export default defineConfig({
+    plugins: [aihand()],
+})
+```
+
+One registration provides both the runtime UI probe (serving `/__aihand/*` endpoints in dev) and the watch-mode codemap injection into your AI context files.
+
+## Configuration
+
+First run detects existing AI context files (`CLAUDE.md`, `AGENTS.md`, etc.), adds injection markers, and writes `aihand.config.ts`.
+
+The config body is the three capability modules — that's the decision you actually make (which capabilities this repo wants). Tuning knobs live inside a module and have smart defaults.
+
+```ts
+// aihand.config.ts
+import { defineConfig } from 'aihand'
+
+export default defineConfig({
+    // Three capability modules. Each: true (on, defaults) · false (off) · { ...overrides }.
+    // Most repos only need the three switches below — tuning knobs have smart defaults.
+
+    // Codemap injection into CLAUDE.md / AGENTS.md
+    read: true,
+    // AST refactor commands (move-file / rename / move-symbol)
+    refactor: true,
+    // Inspect & drive the running app (runtime browser probe — needs the vite plugin);
+    // set false on repos without a dev server.
+    // Non-MobX store factory? runtime: { storeMarker: 'getState' } — the reactive
+    // fingerprint field on the store's return type (zustand 'getState', default '_loading').
+    runtime: true,
+
+    // Need to tune read? Open it up (all optional, shown with defaults):
+    // read: {
+    //   include: ['src/**'],           // what to scan (root config files always included)
+    //   ignore: [],                     // extra skips (.gitignore already applied)
+    //   maxTokens: 5_000,               // budget — auto-downgrades less important files
+    //   injectCodemap: true,            // false → Overview + a pointer to `aihand read --stdout`
+    // },
+})
+```
+
+### Smart allocation
+
+When `maxTokens` is set, `aihand` scores every file by **git recency** and **import centrality**, then auto-downgrades low-signal files (`compact` → `tree` → drop) to fit the budget. High-traffic, recently-changed files keep full signatures; the long tail collapses to names.
+
+## read — understand code
+
+- `aihand read panel` — the app's control-theoretic model: every knob (UI control + the store state it writes), one line each. `--live=<port>` joins it with the running app, marking which knobs are rendered right now (● live).
+- `aihand read source <file:line>` — reverse morphism: a runtime coordinate (or a `/dom` data-insp-path) → the static symbol covering it, plus its callers/callees.
+- `aihand read tree` — where files live and how the repo is laid out.
+- `aihand read --stdout` — the full code map on demand, instead of resident in your context.
+
+All support `--json` for structured output.
+
+## refactor — change source structure
+
+AST-driven via ts-morph (never regex). Rewrites every importer; verify with `tsc --noEmit` after.
+
+- `aihand refactor move-file <src> <dest> [--dry]` — move a file, rewrite all importers.
+- `aihand refactor rename <file> <oldName> <newName> [--dry]` — rename a top-level symbol across the project.
+- `aihand refactor move-symbol <fromFile> <name> <toFile> [--dry]` — move one symbol, carry its deps.
+
+Unsafe forms (default exports, alias-exported symbols, namespace-accessed symbols, barrel re-exports, existing destination) are rejected with a clear message — never a silent broken edit. Use `--dry` to preview.
+
+## runtime — inspect & drive the running app
+
+Reads and drives the live app over HTTP (needs the dev server running with `aihand()`). Start with `screen`.
+
+**Inspect:**
+
+- `aihand runtime screen` — state-machine view of the UI (start here); `ui` / `dom` for detail.
+- `aihand runtime check` — health check (exits non-zero on failure); `console` / `network` / `errors` for diagnostics.
+
+**Drive** — params are flags, forwarded as the query string the endpoint expects:
+
+- `aihand runtime click --text=New` — click by visible text (or `--sel=<css>` to target by selector).
+- `aihand runtime fill --sel=textarea --value=hello` — set an input/textarea value.
+- `aihand runtime wait --text=Done --timeout=8000` — poll until text/selector appears.
+- also `hover` / `press` / `scrollIntoView`.
+
+Flags use `--key=value` (not `--key value`); values may contain `=` and non-ASCII (CSS selectors, CJK text) and are URL-encoded for you. `--port=<port>` selects the dev server port (default 5173); `--full` requests untruncated output.
+
+These are a thin façade over the `/__aihand/*` HTTP endpoints the plugin serves — `curl` them directly for anything the CLI doesn't wrap (e.g. `POST /chain` for scripted interactions).
+
+## probe — drive ANY external website (out-of-app)
+
+The same probe, parachuted into a website you don't own. No vite plugin, no app cooperation: `aihand probe` launches its own chromium (playwright-core), injects the probe over CDP, and serves the same kernel from a resident server.
+
+- `aihand probe open <url>` — launch chromium, inject the probe, navigate; the reply *is* the page (semantic tree + addressable knobs + view/modal/focus), so `open → see` is one roundtrip. `--headed` pops a real window.
+- `aihand probe screen` / `click --text=…` (also `fill` / `press` / `hover` / `wait`) — same verbs as runtime, CDP transport.
+- `aihand probe eval --code=…` — run JS in the real page with auto-return; reads the exact text/numbers the spatial sketch clips (a stats table, a price), queries closures, installs listeners. The escape hatch when `screen` isn't enough.
+- `aihand probe screenshot` — save a PNG (pixels, not the sketch) and return its path; `--sel=…` shoots one element, `--fullPage=1` the whole scroll height. For visual verification a character sketch can't give (a chart, a captcha).
+
+The page handle lives in the resident server (`:5179`) — repeated commands hit the **same page**, so login / scroll / open menus persist across calls. Full-page navigations are back-filled in one roundtrip: a `click` that follows a link returns `navigated: from → to` plus the new page's full view, no extra round.
+
+For known multi-step sequences (login `fill→fill→click`, search `fill→press`), `POST /chain` with a JSON array of steps runs the whole interaction in **one roundtrip** — fail-fast, each step rendered with its delta, skipped steps announced:
+
+```sh
+curl -s :5179/chain -d '[{"type":"fill","sel":"input[type=search]","value":"hello"},{"type":"press","key":"Enter"}]'
+```
+
+## License
+
+MIT

package/dist/chunk-2NTK7H4W.js

@@ -0,0 +1,10 @@
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+export {
+  __dirname
+};

package/dist/chunk-3X4FTHLC.cjs

@@ -0,0 +1,369 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkDUUCVLC3cjs = require('./chunk-DUUCVLC3.cjs');
+
+// src/read/panel.ts
+var _fs = require('fs');
+var _webtreesitter = require('web-tree-sitter');
+var ATTR_QUERY = `
+(jsx_attribute
+  (property_identifier) @name
+  (jsx_expression) @val) @attr
+`;
+function collapseWs(s) {
+  const tokens = [];
+  let cur = "";
+  for (const ch of s) {
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      if (cur) {
+        tokens.push(cur);
+        cur = "";
+      }
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur) tokens.push(cur);
+  return tokens.join(" ");
+}
+function storeWritesIn(node) {
+  const out = [];
+  const walk = (n) => {
+    if (n.type === "assignment_expression") {
+      const left = n.childForFieldName("left");
+      const right = n.childForFieldName("right");
+      if (_optionalChain([left, 'optionalAccess', _ => _.type]) === "member_expression") {
+        const obj = left.childForFieldName("object");
+        const prop = left.childForFieldName("property");
+        if (_optionalChain([obj, 'optionalAccess', _2 => _2.type]) === "identifier" && obj.text.endsWith("Store") && prop)
+          out.push({ store: obj.text, field: prop.text, to: collapseWs(_nullishCoalesce(_optionalChain([right, 'optionalAccess', _3 => _3.text]), () => ( ""))) });
+      }
+    } else if (n.type === "call_expression") {
+      const fn = n.childForFieldName("function");
+      if (_optionalChain([fn, 'optionalAccess', _4 => _4.type]) === "member_expression") {
+        const obj = fn.childForFieldName("object");
+        const method = fn.childForFieldName("property");
+        if (_optionalChain([obj, 'optionalAccess', _5 => _5.type]) === "identifier" && obj.text.endsWith("Store") && method) {
+          const argsNode = n.childForFieldName("arguments");
+          const inner = argsNode ? collapseWs(argsNode.text).slice(1, -1).trim() : "";
+          out.push({ store: obj.text, field: `${method.text}()`, to: "", args: inner });
+        }
+      }
+    }
+    for (let i = 0; i < n.namedChildCount; i++) walk(n.namedChild(i));
+  };
+  walk(node);
+  return out;
+}
+function labelOf(opening) {
+  for (let i = 0; i < opening.namedChildCount; i++) {
+    const a = opening.namedChild(i);
+    if (a.type !== "jsx_attribute") continue;
+    if (_optionalChain([a, 'access', _6 => _6.namedChild, 'call', _7 => _7(0), 'optionalAccess', _8 => _8.text]) !== "label" && _optionalChain([a, 'access', _9 => _9.namedChild, 'call', _10 => _10(0), 'optionalAccess', _11 => _11.text]) !== "title") continue;
+    const val = a.namedChild(1);
+    if (!val) continue;
+    if (val.type === "string") return val.text.slice(1, -1);
+    let found = null;
+    const dig = (n) => {
+      if (found) return;
+      if (n.type === "string") {
+        found = n.text.slice(1, -1);
+        return;
+      }
+      for (let j = 0; j < n.namedChildCount; j++) dig(n.namedChild(j));
+    };
+    dig(val);
+    if (found) return found;
+  }
+  const element = opening.parent;
+  if (_optionalChain([element, 'optionalAccess', _12 => _12.type]) === "jsx_element") {
+    const parts = [];
+    for (let i = 0; i < element.namedChildCount; i++) {
+      const child = element.namedChild(i);
+      if (child.type === "jsx_text") {
+        const t = collapseWs(child.text).trim();
+        if (t) parts.push(t);
+      }
+    }
+    if (parts.length) return parts.join(" ");
+  }
+  return null;
+}
+function extractKnobs(filePath, code, lang) {
+  const parser = new (0, _webtreesitter.Parser)();
+  parser.setLanguage(lang);
+  const tree = parser.parse(code);
+  if (!tree) return [];
+  const knobs = [];
+  for (const c of new (0, _webtreesitter.Query)(lang, ATTR_QUERY).captures(tree.rootNode)) {
+    if (c.name !== "attr") continue;
+    const event = _optionalChain([c, 'access', _13 => _13.node, 'access', _14 => _14.namedChild, 'call', _15 => _15(0), 'optionalAccess', _16 => _16.text]);
+    if (!event || !event.startsWith("on")) continue;
+    const writes = storeWritesIn(c.node);
+    if (!writes.length) continue;
+    const opening = c.node.parent;
+    const byField = /* @__PURE__ */ new Map();
+    for (const w of writes) byField.set(w.field, { to: w.to, args: w.args });
+    const transitions = [...byField].map(([field, v]) => v.args !== void 0 ? { field, to: v.to, args: v.args } : { field, to: v.to });
+    knobs.push({
+      label: labelOf(opening),
+      tag: _nullishCoalesce(_optionalChain([opening, 'access', _17 => _17.childForFieldName, 'call', _18 => _18("name"), 'optionalAccess', _19 => _19.text]), () => ( "?")),
+      event,
+      transitions,
+      store: writes[0].store,
+      filePath,
+      line: c.node.startPosition.row + 1
+    });
+  }
+  return knobs;
+}
+function fmtTransitions(ts) {
+  return ts.map((t) => t.to ? `${t.field}=${t.to}` : t.field).join(", ");
+}
+function formatPanel(knobs) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const k of knobs) {
+    const arr = _nullishCoalesce(byFile.get(k.filePath), () => ( []));
+    arr.push(k);
+    byFile.set(k.filePath, arr);
+  }
+  const lines = [];
+  for (const [file, ks] of byFile) {
+    lines.push(file);
+    for (const k of ks) {
+      const name = k.label ? `\u300C${k.label}\u300D` : `<${k.tag}>`;
+      lines.push(`  ${name} ${k.event} \u2192 ${k.store}.{ ${fmtTransitions(k.transitions)} }  :${k.line}`);
+    }
+  }
+  return lines.join("\n");
+}
+function isIdentChar(ch) {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_" || ch === "$";
+}
+function isLiteral(to) {
+  if (to === "true" || to === "false" || to === "null") return true;
+  if (to.length >= 2) {
+    const q = to[0];
+    if ((q === "'" || q === '"' || q === "`") && to[to.length - 1] === q) {
+      for (let i = 1; i < to.length - 1; i++) {
+        if (to[i] === q && to[i - 1] !== "\\") return false;
+      }
+      return true;
+    }
+  }
+  let dot = 0;
+  for (let i = 0; i < to.length; i++) {
+    const ch = to[i];
+    if (ch === "-" && i === 0) continue;
+    if (ch === ".") {
+      dot++;
+      if (dot > 1) return false;
+      continue;
+    }
+    if (ch < "0" || ch > "9") return false;
+  }
+  return to.length > 0 && to !== "-" && to !== ".";
+}
+function isMemberPath(s) {
+  if (!s || s[0] === "." || s[s.length - 1] === ".") return false;
+  let prevDot = false;
+  for (const ch of s) {
+    if (ch === ".") {
+      if (prevDot) return false;
+      prevDot = true;
+      continue;
+    }
+    if (!isIdentChar(ch)) return false;
+    prevDot = false;
+  }
+  return true;
+}
+function isPlaceholder(to) {
+  if (!isMemberPath(to)) return false;
+  const segs = to.split(".");
+  if (segs.length > 2) return false;
+  if (segs[0].endsWith("Store")) return false;
+  return true;
+}
+function lastSeg(path) {
+  const i = path.lastIndexOf(".");
+  return i < 0 ? path : path.slice(i + 1);
+}
+function classifyTransition(t) {
+  const field = t.field;
+  const to = t.to;
+  if (field.endsWith("()")) {
+    if (t.args && t.args.length > 0)
+      return { field, kind: "context", arity: "nullary", reason: `\u65B9\u6CD5\u5E26\u53C2 ${field.slice(0, -2)}(${t.args})\uFF0C\u5B9E\u53C2\u4F9D\u8D56\u8FD0\u884C\u65F6\u4E0A\u4E0B\u6587` };
+    return { field, kind: "call", arity: "nullary" };
+  }
+  if (isLiteral(to)) return { field, kind: "assign", arity: "nullary", to };
+  if (to.startsWith("!")) {
+    const inner = to.slice(1);
+    if (isMemberPath(inner)) return { field: lastSeg(inner), kind: "toggle", arity: "nullary" };
+  }
+  if (isPlaceholder(to)) return { field, kind: "assign", arity: "param" };
+  let reason = "\u4F9D\u8D56\u8FD0\u884C\u65F6\u4E0A\u4E0B\u6587";
+  if (to.includes("e.target") || to.includes(".target.")) reason = "\u4F9D\u8D56\u4E8B\u4EF6\u5BF9\u8C61 e.target";
+  else if (to.includes(".filter(") || to.includes(".map(") || to.includes(".find(")) reason = "\u6570\u7EC4\u8FD0\u7B97,\u4F9D\u8D56\u5F53\u524D\u96C6\u5408";
+  else if (to.includes("...")) reason = "\u5C55\u5F00\u8FD0\u7B97\u7B26,\u4F9D\u8D56\u5F53\u524D\u5FEB\u7167";
+  else if (to.includes("=>")) reason = "\u503C\u662F\u7BAD\u5934\u51FD\u6570/\u95ED\u5305";
+  else if (to.includes("?") && to.includes(":")) reason = "\u4E09\u5143\u8868\u8FBE\u5F0F,\u4F9D\u8D56\u8FD0\u884C\u65F6\u5206\u652F";
+  else if (to.includes(".message") || to.includes(".id") || to.includes(".name")) reason = "\u8BFB\u8FD0\u884C\u65F6\u5BF9\u8C61\u5C5E\u6027";
+  return { field, kind: "context", arity: "nullary", reason };
+}
+function classifyKnob(transitions) {
+  const ops = transitions.map(classifyTransition);
+  const executable = ops.length > 0 && ops.every((o) => o.kind !== "context");
+  const arity = ops.some((o) => o.arity === "param") ? "param" : "nullary";
+  return { ops, arity, executable };
+}
+async function buildPanel(filePaths, contents) {
+  await _webtreesitter.Parser.init();
+  const tsx = await _chunkDUUCVLC3cjs.getLang.call(void 0, ".tsx");
+  if (!tsx) return [];
+  const panel = [];
+  for (const fp of filePaths) {
+    if (!fp.endsWith(".tsx") && !fp.endsWith(".jsx")) continue;
+    let code;
+    if (_optionalChain([contents, 'optionalAccess', _20 => _20.has, 'call', _21 => _21(fp)])) code = contents.get(fp);
+    else {
+      try {
+        code = _fs.readFileSync.call(void 0, fp, "utf-8");
+      } catch (e) {
+        continue;
+      }
+    }
+    panel.push(...extractKnobs(fp, code, tsx));
+  }
+  return panel;
+}
+
+// src/read/stategraph.ts
+
+var _path = require('path');
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+var _tsmorph = require('ts-morph');
+async function openProject(cwd = _process2.default.cwd()) {
+  const { Project } = await Promise.resolve().then(() => _interopRequireWildcard(require("ts-morph")));
+  const tsConfigFilePath = ["tsconfig.app.json", "tsconfig.json"].map((f) => _path.resolve.call(void 0, cwd, f)).find(_fs.existsSync);
+  if (!tsConfigFilePath)
+    throw new Error(`stategraph: no tsconfig.json (or tsconfig.app.json) found under ${cwd}`);
+  return new Project({ tsConfigFilePath });
+}
+function isModuleLevel(v) {
+  const stmt = v.getVariableStatement();
+  return !!stmt && _optionalChain([stmt, 'access', _22 => _22.getParent, 'call', _23 => _23(), 'optionalAccess', _24 => _24.getKind, 'call', _25 => _25()]) === _tsmorph.SyntaxKind.SourceFile;
+}
+var DEFAULT_STORE_MARKER = "_loading";
+function isStateFactory(v, marker) {
+  const init = v.getInitializer();
+  if (!init || !_tsmorph.Node.isCallExpression(init))
+    return false;
+  return !!v.getType().getProperty(marker);
+}
+function classify(v, marker = DEFAULT_STORE_MARKER) {
+  const init = v.getInitializer();
+  if (!init)
+    return null;
+  const k = init.getKind();
+  if (k === _tsmorph.SyntaxKind.ArrowFunction || k === _tsmorph.SyntaxKind.FunctionExpression || k === _tsmorph.SyntaxKind.ClassExpression)
+    return "view";
+  if (isStateFactory(v, marker))
+    return "state";
+  return null;
+}
+function fieldOf(pa) {
+  if (!_tsmorph.Node.isPropertyAssignment(pa))
+    return null;
+  const valueInit = pa.getInitializer();
+  if (!valueInit)
+    return null;
+  const init = _tsmorph.Node.isAsExpression(valueInit) ? valueInit.getExpression().getText() : valueInit.getText();
+  const t = valueInit.getType();
+  const domain = t.isUnion() ? t.getUnionTypes().filter((u) => u.isStringLiteral()).map((u) => u.getLiteralValue()) : [];
+  return { name: pa.getName(), init, type: t.getText(valueInit), domain, line: pa.getStartLineNumber() };
+}
+function resolveStateObject(arg) {
+  if (_tsmorph.Node.isObjectLiteralExpression(arg))
+    return arg;
+  if (_tsmorph.Node.isIdentifier(arg)) {
+    const decl = _optionalChain([arg, 'access', _26 => _26.getSymbol, 'call', _27 => _27(), 'optionalAccess', _28 => _28.getDeclarations, 'call', _29 => _29(), 'optionalAccess', _30 => _30[0]]);
+    if (decl && _tsmorph.Node.isVariableDeclaration(decl)) {
+      const di = decl.getInitializer();
+      if (di && _tsmorph.Node.isObjectLiteralExpression(di))
+        return di;
+    }
+  }
+  return null;
+}
+function extractStoreFields(v, marker = DEFAULT_STORE_MARKER) {
+  if (!isStateFactory(v, marker))
+    return [];
+  const init = v.getInitializer();
+  if (!_tsmorph.Node.isCallExpression(init))
+    return [];
+  const arg = init.getArguments()[0];
+  const stateObj = arg && resolveStateObject(arg);
+  if (!stateObj || !_tsmorph.Node.isObjectLiteralExpression(stateObj))
+    return [];
+  const out = [];
+  for (const pa of stateObj.getProperties()) {
+    const f = fieldOf(pa);
+    if (f)
+      out.push(f);
+  }
+  return out;
+}
+function growFromDecl(v, file, marker = DEFAULT_STORE_MARKER) {
+  const fields = extractStoreFields(v, marker).map((f) => ({
+    name: f.name,
+    type: f.type,
+    domain: f.domain,
+    line: f.line
+  }));
+  return {
+    store: v.getName(),
+    anchor: `${file}:${v.getStartLineNumber()}`,
+    fields
+  };
+}
+function buildStateGraph(project, fileFor = (p) => p.split("/").slice(-2).join("/"), marker = DEFAULT_STORE_MARKER) {
+  const nodes = [];
+  for (const sf of project.getSourceFiles()) {
+    const fp = sf.getFilePath();
+    if (fp.endsWith(".d.ts") || fp.includes("/node_modules/"))
+      continue;
+    const file = fileFor(fp);
+    for (const v of sf.getVariableDeclarations()) {
+      if (!isModuleLevel(v) || classify(v, marker) !== "state")
+        continue;
+      const grown = growFromDecl(v, file, marker);
+      const seen = /* @__PURE__ */ new Set();
+      let refs = 0;
+      try {
+        for (const ref of v.findReferencesAsNodes()) {
+          refs++;
+          seen.add(ref.getSourceFile().getFilePath());
+        }
+      } catch (e2) {
+      }
+      nodes.push({ ...grown, refs, files: seen.size, rank: refs + seen.size * 3 });
+    }
+  }
+  nodes.sort((a, b) => b.rank - a.rank);
+  return { nodes };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+exports.extractKnobs = extractKnobs; exports.fmtTransitions = fmtTransitions; exports.formatPanel = formatPanel; exports.classifyKnob = classifyKnob; exports.buildPanel = buildPanel; exports.openProject = openProject; exports.classify = classify; exports.extractStoreFields = extractStoreFields; exports.growFromDecl = growFromDecl; exports.buildStateGraph = buildStateGraph;