aihand 0.0.1 → 0.1.0

package/dist/index.js

@@ -0,0 +1,479 @@
+import {
+  moveFile,
+  moveSymbol,
+  renameSymbol
+} from "./chunk-BXVNR4E2.js";
+import {
+  allocate,
+  buildBlocks,
+  buildClassifier,
+  buildImportGraph,
+  buildState,
+  computeCentrality,
+  computeRecency,
+  ensureMarkers,
+  expandByBudget,
+  formatState,
+  formatTree,
+  formatXml,
+  injectAll,
+  injectFile,
+  scanSecrets
+} from "./chunk-QSAMLXML.js";
+import {
+  aihand,
+  check,
+  diffState,
+  discover,
+  emitCheck,
+  emitDiff,
+  emitSummary,
+  storeSchema
+} from "./chunk-JLYC76XL.js";
+import {
+  buildPanel,
+  buildStateGraph,
+  classify,
+  extractKnobs,
+  extractStoreFields,
+  fmtTransitions,
+  growFromDecl,
+  openProject
+} from "./chunk-G7KVJ7NF.js";
+import "./chunk-YKSYW77R.js";
+import {
+  DEFAULT_CONFIG,
+  configTemplate,
+  defineConfig
+} from "./chunk-PQSQN4CN.js";
+import {
+  scan
+} from "./chunk-GNEUSRGP.js";
+import {
+  buildCallGraph
+} from "./chunk-IS5XFUDB.js";
+import {
+  IMPORT_QUERY,
+  SEPARATOR,
+  TS_QUERY,
+  cleanFnSignature,
+  compact,
+  extractImports,
+  getLang
+} from "./chunk-OWYK2IGV.js";
+import {
+  fetchRuntimeKnobs,
+  fileOfInspPath,
+  joinPanel,
+  locate,
+  parseInspPath,
+  renderLocate,
+  sourcePanelHtml,
+  symbolAtLine
+} from "./chunk-ZJQRNIK7.js";
+import "./chunk-2NTK7H4W.js";
+
+// src/ui/babel/line-profiler.ts
+import { types as t } from "@babel/core";
+import path from "path";
+function lineProfilerPlugin() {
+  return {
+    name: "aihand-line-profiler",
+    visitor: {
+      VariableDeclaration(nodePath, state) {
+        if (shouldSkip(nodePath, state)) return;
+        const decl = nodePath.node.declarations[0];
+        if (!decl?.init) return;
+        if (hasAwaitOrYield(decl.init)) return;
+        const label = makeLabel(nodePath, state, decl.id.type === "Identifier" ? decl.id.name : void 0);
+        const wrapped = wrapExpr(decl.init, label);
+        decl.init = wrapped;
+      },
+      ExpressionStatement(nodePath, 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, state) {
+        if (shouldSkip(nodePath, state)) return;
+        if (!nodePath.node.argument) 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, state) {
+  const filename = state.file?.opts?.filename ?? "";
+  if (filename.includes("node_modules")) return true;
+  if (filename.includes("packages/aidev/")) return true;
+  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;
+  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, state, varName) {
+  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}`;
+}
+function resolveLine(nodePath) {
+  if (nodePath.node.loc) return nodePath.node.loc.start.line;
+  const descend = firstLocLine(nodePath.node);
+  if (descend != null) return descend;
+  let p = nodePath.parentPath;
+  while (p) {
+    if (p.node.loc) return p.node.loc.start.line;
+    p = p.parentPath;
+  }
+  return 0;
+}
+function firstLocLine(node) {
+  for (const key of t.VISITOR_KEYS[node.type] ?? []) {
+    const child = node[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;
+}
+function wrapExpr(expr, label) {
+  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)
+    ]
+  );
+}
+function hasAwaitOrYield(node) {
+  if (!node || typeof node !== "object") return false;
+  if (t.isAwaitExpression(node) || t.isYieldExpression(node)) return true;
+  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[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;
+}
+
+// src/ui/self/act.ts
+function stringifyDomain(v) {
+  if (v === null || v === void 0)
+    return String(v);
+  if (typeof v === "object")
+    return JSON.stringify(v).slice(0, 80);
+  return String(v).slice(0, 80);
+}
+function act(before, after) {
+  const lines = [];
+  if (after.view !== before.view)
+    lines.push(`view: ${before.view} \u2192 ${after.view}`);
+  if (after.modal !== before.modal) {
+    if (after.modal === null)
+      lines.push(`modal: closed (${before.modal})`);
+    else if (before.modal === null)
+      lines.push(`modal: opened ${after.modal}`);
+    else
+      lines.push(`modal: ${before.modal} \u2192 ${after.modal}`);
+  }
+  if (after.focus !== before.focus)
+    lines.push(`focus: ${after.focus}`);
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(before.state), ...Object.keys(after.state)])) {
+    const b = stringifyDomain(before.state[key]);
+    const a = stringifyDomain(after.state[key]);
+    if (b !== a)
+      lines.push(`${key}: ${b} \u2192 ${a}`);
+  }
+  return lines;
+}
+
+// src/ui/self/grow.ts
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { Language, Parser } from "web-tree-sitter";
+var langPromise = null;
+function loadLang() {
+  if (!langPromise) {
+    langPromise = (async () => {
+      const req = createRequire(import.meta.url);
+      const wasmDir = dirname(req.resolve("@repomix/tree-sitter-wasms/out/tree-sitter-tsx.wasm"));
+      await Parser.init();
+      return Language.load(join(wasmDir, "tree-sitter-tsx.wasm"));
+    })();
+  }
+  return langPromise;
+}
+function typeOf(value) {
+  if (value.type === "as_expression") {
+    const typeNode = value.namedChild(value.namedChildCount - 1);
+    if (!typeNode)
+      return { type: "unknown", domain: [] };
+    const literals = typeNode.descendantsOfType("literal_type");
+    const domain = literals.map((l) => l.descendantsOfType("string_fragment")[0]?.text).filter((s) => !!s);
+    return { type: typeNode.text, domain };
+  }
+  if (value.type === "true" || value.type === "false")
+    return { type: "boolean", domain: [] };
+  if (value.type === "number")
+    return { type: "number", domain: [] };
+  if (value.type === "string")
+    return { type: "string", domain: [] };
+  if (value.type === "array")
+    return { type: "array", domain: [] };
+  if (value.type === "null")
+    return { type: "null", domain: [] };
+  return { type: value.type, domain: [] };
+}
+async function grow(code, file) {
+  const lang = await loadLang();
+  const parser = new Parser();
+  parser.setLanguage(lang);
+  const tree = parser.parse(code);
+  const root = tree?.rootNode;
+  if (!root)
+    return [];
+  const out = [];
+  for (const decl of root.descendantsOfType("variable_declarator")) {
+    const nameNode = decl.namedChild(0);
+    const valueNode = decl.childForFieldName("value");
+    if (!nameNode || nameNode.type !== "identifier" || valueNode?.type !== "call_expression")
+      continue;
+    const callee = valueNode.namedChild(0);
+    if (callee?.type !== "identifier" || callee.text !== "create")
+      continue;
+    const args = valueNode.childForFieldName("arguments");
+    const stateObj = args?.namedChildren.find((c) => c?.type === "object");
+    if (!stateObj)
+      continue;
+    const fields = [];
+    for (const pair of stateObj.namedChildren) {
+      if (pair?.type !== "pair")
+        continue;
+      const key = pair.childForFieldName("key");
+      const value = pair.childForFieldName("value");
+      if (!key || !value)
+        continue;
+      const { type, domain } = typeOf(value);
+      fields.push({ name: key.text, type, domain, line: key.startPosition.row + 1 });
+    }
+    out.push({
+      store: nameNode.text,
+      anchor: `${file}:${decl.startPosition.row + 1}`,
+      fields
+    });
+  }
+  return out;
+}
+
+// src/ui/self/self.ts
+function screen(self) {
+  return self;
+}
+function log(seq, entry) {
+  return [...seq, entry];
+}
+
+// src/ui/self/install.ts
+function emit(sink, channel, detail) {
+  sink.seq = log(sink.seq, { channel, detail, ts: sink.now() });
+}
+function installSelfLog(win, sink) {
+  const restores = [];
+  const levels = ["log", "info", "warn", "error", "debug"];
+  for (const level of levels) {
+    const orig = win.console[level];
+    win.console[level] = (...args) => {
+      emit(sink, "console", `[${level}] ${args.map(String).join(" ")}`);
+      orig.apply(win.console, args);
+    };
+    restores.push(() => {
+      win.console[level] = orig;
+    });
+  }
+  const origFetch = win.fetch;
+  win.fetch = async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = init?.method || "GET";
+    try {
+      const res = await origFetch(input, init);
+      emit(sink, "fetch", `${method} ${url} ${res.status}`);
+      return res;
+    } catch (e) {
+      emit(sink, "fetch", `${method} ${url} failed: ${e instanceof Error ? e.message : String(e)}`);
+      throw e;
+    }
+  };
+  restores.push(() => {
+    win.fetch = origFetch;
+  });
+  const XHRProto = win.XMLHttpRequest.prototype;
+  const origOpen = XHRProto.open;
+  const origSend = XHRProto.send;
+  XHRProto.open = function(method, url, ...rest) {
+    this.__m = method;
+    this.__u = typeof url === "string" ? url : url.toString();
+    return origOpen.call(this, method, url, ...rest);
+  };
+  XHRProto.send = function(...args) {
+    this.addEventListener("loadend", () => {
+      emit(sink, "xhr", `${this.__m ?? "GET"} ${this.__u ?? ""} ${this.status}`);
+    });
+    return origSend.apply(this, args);
+  };
+  restores.push(() => {
+    XHRProto.open = origOpen;
+    XHRProto.send = origSend;
+  });
+  const onError = (e) => emit(sink, "error", e.message || String(e.error));
+  const onRejection = (e) => emit(sink, "error", `unhandled rejection: ${String(e.reason)}`);
+  win.addEventListener("error", onError);
+  win.addEventListener("unhandledrejection", onRejection);
+  restores.push(() => {
+    win.removeEventListener("error", onError);
+    win.removeEventListener("unhandledrejection", onRejection);
+  });
+  const OrigES = win.EventSource;
+  if (OrigES) {
+    win.EventSource = new Proxy(OrigES, {
+      construct(Target, cArgs) {
+        const es = new Target(...cArgs);
+        const url = String(cArgs[0]);
+        es.addEventListener("error", () => emit(sink, "sse", `${url} error (readyState ${es.readyState})`));
+        return es;
+      }
+    });
+    restores.push(() => {
+      win.EventSource = OrigES;
+    });
+  }
+  return () => {
+    for (const r of restores) r();
+  };
+}
+
+// src/ui/self/screen-hook.ts
+function screenHook(stores) {
+  const domain = {};
+  let view = "";
+  for (const { schema, snapshot } of stores) {
+    for (const f of schema.fields) {
+      domain[`${schema.store}.${f.name}`] = snapshot[f.name];
+      if (!view && f.domain.length > 0)
+        view = String(snapshot[f.name] ?? "");
+    }
+  }
+  return { view, domain };
+}
+
+// src/ui/self/synth.ts
+function synth(schema, snapshot) {
+  const viewField = schema.fields.find((f) => f.domain.length > 0);
+  const state = {};
+  for (const f of schema.fields)
+    state[f.name] = snapshot[f.name];
+  return {
+    view: viewField ? String(snapshot[viewField.name] ?? "") : "",
+    modal: null,
+    focus: null,
+    state,
+    anchor: schema.anchor
+  };
+}
+export {
+  DEFAULT_CONFIG,
+  IMPORT_QUERY,
+  SEPARATOR,
+  TS_QUERY,
+  act,
+  aihand,
+  allocate,
+  buildBlocks,
+  buildCallGraph,
+  buildClassifier,
+  buildImportGraph,
+  buildPanel,
+  buildState,
+  buildStateGraph,
+  check,
+  classify,
+  cleanFnSignature,
+  compact,
+  computeCentrality,
+  computeRecency,
+  configTemplate,
+  defineConfig,
+  diffState,
+  discover,
+  emitCheck,
+  emitDiff,
+  emitSummary,
+  ensureMarkers,
+  expandByBudget,
+  extractImports,
+  extractKnobs,
+  extractStoreFields,
+  fetchRuntimeKnobs,
+  fileOfInspPath,
+  fmtTransitions,
+  formatState,
+  formatTree,
+  formatXml,
+  getLang,
+  grow,
+  growFromDecl,
+  injectAll,
+  injectFile,
+  installSelfLog,
+  joinPanel,
+  lineProfilerPlugin,
+  locate,
+  log,
+  moveFile,
+  moveSymbol,
+  openProject,
+  parseInspPath,
+  renameSymbol,
+  renderLocate,
+  scan,
+  scanSecrets,
+  screen,
+  screenHook,
+  sourcePanelHtml,
+  storeSchema,
+  symbolAtLine,
+  synth
+};

package/dist/locate-5XFSXJ5J.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkOVMK33ACcjs = require('./chunk-OVMK33AC.cjs');
+require('./chunk-Z2Y65YOY.cjs');
+
+
+
+
+
+
+exports.locate = _chunkOVMK33ACcjs.locate; exports.parseInspPath = _chunkOVMK33ACcjs.parseInspPath; exports.renderLocate = _chunkOVMK33ACcjs.renderLocate; exports.sourcePanelHtml = _chunkOVMK33ACcjs.sourcePanelHtml; exports.symbolAtLine = _chunkOVMK33ACcjs.symbolAtLine;

package/dist/locate-NKSUGL3A.js

@@ -0,0 +1,15 @@
+import {
+  locate,
+  parseInspPath,
+  renderLocate,
+  sourcePanelHtml,
+  symbolAtLine
+} from "./chunk-ZJQRNIK7.js";
+import "./chunk-2NTK7H4W.js";
+export {
+  locate,
+  parseInspPath,
+  renderLocate,
+  sourcePanelHtml,
+  symbolAtLine
+};

package/dist/refactor-5FWSZIBN.cjs

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+var _chunkVEKYRKPFcjs = require('./chunk-VEKYRKPF.cjs');
+require('./chunk-Z2Y65YOY.cjs');
+
+
+
+
+
+
+
+
+exports.moveFile = _chunkVEKYRKPFcjs.moveFile; exports.moveInProject = _chunkVEKYRKPFcjs.moveInProject; exports.moveSymbol = _chunkVEKYRKPFcjs.moveSymbol; exports.moveSymbolInProject = _chunkVEKYRKPFcjs.moveSymbolInProject; exports.renameInProject = _chunkVEKYRKPFcjs.renameInProject; exports.renameSymbol = _chunkVEKYRKPFcjs.renameSymbol; exports.toAlias = _chunkVEKYRKPFcjs.toAlias;

package/dist/refactor-BOB3SZSA.js

@@ -0,0 +1,19 @@
+import {
+  moveFile,
+  moveInProject,
+  moveSymbol,
+  moveSymbolInProject,
+  renameInProject,
+  renameSymbol,
+  toAlias
+} from "./chunk-BXVNR4E2.js";
+import "./chunk-2NTK7H4W.js";
+export {
+  moveFile,
+  moveInProject,
+  moveSymbol,
+  moveSymbolInProject,
+  renameInProject,
+  renameSymbol,
+  toAlias
+};

package/dist/scan-4R7GQG2W.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkKQOABC2Ocjs = require('./chunk-KQOABC2O.cjs');
+require('./chunk-Z2Y65YOY.cjs');
+
+
+
+exports.filterAndSort = _chunkKQOABC2Ocjs.filterAndSort; exports.scan = _chunkKQOABC2Ocjs.scan;

package/dist/scan-VF54GAAX.js

@@ -0,0 +1,9 @@
+import {
+  filterAndSort,
+  scan
+} from "./chunk-GNEUSRGP.js";
+import "./chunk-2NTK7H4W.js";
+export {
+  filterAndSort,
+  scan
+};