aihand 0.0.1 → 0.1.1

package/dist/chunk-KQOABC2O.cjs

@@ -0,0 +1,52 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/read/scan.ts
+var _fs = require('fs');
+var _glob = require('glob');
+var _ignore = require('ignore'); var _ignore2 = _interopRequireDefault(_ignore);
+function rootPriority(name) {
+  if (name === "package.json")
+    return 0;
+  if (name.endsWith(".html"))
+    return 1;
+  if (name.startsWith("tsconfig"))
+    return 2;
+  if (name.startsWith(".env"))
+    return 3;
+  return 4;
+}
+var hasGlob = (p) => p.includes("*") || p.includes("?") || p.includes("{") || p.includes("[");
+function filterAndSort(matched, gitignoreText, config, existingExplicit) {
+  const ig = _ignore2.default.call(void 0, );
+  if (gitignoreText)
+    ig.add(gitignoreText);
+  if (config.read.ignore.length)
+    ig.add(config.read.ignore);
+  const explicit = new Set(existingExplicit);
+  return matched.filter((f) => explicit.has(f) || !ig.ignores(f)).sort((a, b) => {
+    const aRoot = !a.includes("/");
+    const bRoot = !b.includes("/");
+    if (aRoot !== bRoot)
+      return aRoot ? -1 : 1;
+    if (aRoot) {
+      const pa = rootPriority(a);
+      const pb = rootPriority(b);
+      if (pa !== pb)
+        return pa - pb;
+    }
+    return a.localeCompare(b);
+  });
+}
+function scan(config) {
+  const matched = _glob.globSync.call(void 0, config.read.include, {
+    nodir: true,
+    dot: true,
+    ignore: ["**/node_modules/**"]
+  });
+  const gitignoreText = _fs.existsSync.call(void 0, ".gitignore") ? _fs.readFileSync.call(void 0, ".gitignore", "utf-8") : "";
+  const existingExplicit = config.read.include.filter((p) => !hasGlob(p) && _fs.existsSync.call(void 0, p));
+  return filterAndSort(matched, gitignoreText, config, existingExplicit);
+}
+
+
+
+
+exports.filterAndSort = filterAndSort; exports.scan = scan;

package/dist/chunk-OVMK33AC.cjs

@@ -0,0 +1,104 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/read/seam.ts
+function fileOfInspPath(inspPath) {
+  const parts = inspPath.split(":");
+  return parts.length <= 3 ? parts[0] : parts.slice(0, parts.length - 3).join(":");
+}
+var key = (label, file) => `${label}\0${file}`;
+function joinPanel(staticKnobs, runtime) {
+  const liveSet = /* @__PURE__ */ new Set();
+  for (const r of runtime)
+    for (const f of r.files)
+      liveSet.add(key(r.label, f));
+  return staticKnobs.map((k) => ({
+    ...k,
+    live: k.label !== null && liveSet.has(key(k.label, k.filePath))
+  }));
+}
+var COLLECT_KNOBS_SCRIPT = `JSON.stringify(window.__aihandCollectKnobs ? window.__aihandCollectKnobs() : null)`;
+async function fetchRuntimeKnobs(port) {
+  const resp = await fetch(`http://localhost:${port}/__aihand/eval`, {
+    method: "POST",
+    body: COLLECT_KNOBS_SCRIPT
+  });
+  if (!resp.ok)
+    throw new Error(`runtime probe failed (${resp.status}) \u2014 is the dev server running with aihand() on :${port}?`);
+  const raw = JSON.parse(await resp.text());
+  if (!raw)
+    throw new Error("runtime knob collector missing (__aihandCollectKnobs) \u2014 the page is running an older aihand client; reload it");
+  return raw.map((r) => ({ label: r.label, files: r.files, tag: r.tag }));
+}
+
+// src/read/locate.ts
+function symbolAtLine(g, file, line) {
+  let best;
+  for (const s of Object.values(g.symbols)) {
+    if (s.filePath !== file || line < s.startLine || line > s.endLine)
+      continue;
+    if (!best || s.endLine - s.startLine < best.endLine - best.startLine)
+      best = s;
+  }
+  return best;
+}
+function parseInspPath(p) {
+  const parts = p.split(":");
+  const file = fileOfInspPath(p);
+  const lineStr = parts.length <= 3 ? parts[1] : parts[parts.length - 3];
+  return { file, line: Number(lineStr) };
+}
+function locate(g, file, line) {
+  const symbol = symbolAtLine(g, file, line);
+  if (!symbol)
+    return null;
+  const byUid = (uids) => (_nullishCoalesce(uids, () => ( []))).map((u) => g.symbols[u]).filter(Boolean);
+  return {
+    symbol,
+    callers: byUid(g.in[symbol.uid]),
+    callees: byUid(g.out[symbol.uid])
+  };
+}
+var at = (s) => `${s.filePath}:${s.startLine + 1}`;
+function renderLocate(r, json = false) {
+  if (json)
+    return JSON.stringify(r, null, 2);
+  const lines = [`${r.symbol.name}  ${r.symbol.kind}  ${at(r.symbol)}`];
+  if (r.callers.length) {
+    lines.push(`
+Callers (${r.callers.length}):`);
+    for (const c of r.callers)
+      lines.push(`  ${c.name}  ${at(c)}`);
+  }
+  if (r.callees.length) {
+    lines.push(`
+Callees (${r.callees.length}):`);
+    for (const c of r.callees)
+      lines.push(`  ${c.name}  ${at(c)}`);
+  }
+  if (!r.callers.length && !r.callees.length)
+    lines.push("  (no call edges found)");
+  return lines.join("\n");
+}
+function sourcePanelHtml(r, esc = escHtml) {
+  const row = (c) => `<div class="aihand-src-edge" data-src-path="${esc(at(c))}">${esc(c.name)} <span class="aihand-src-at">${esc(at(c))}</span></div>`;
+  const out = [`<div class="aihand-src-head">${esc(r.symbol.name)} <span class="aihand-src-kind">${esc(r.symbol.kind)}</span> <span class="aihand-src-at">${esc(at(r.symbol))}</span></div>`];
+  if (r.callers.length)
+    out.push(`<div class="aihand-src-sec">Callers (${r.callers.length})</div>`, ...r.callers.map(row));
+  if (r.callees.length)
+    out.push(`<div class="aihand-src-sec">Callees (${r.callees.length})</div>`, ...r.callees.map(row));
+  if (!r.callers.length && !r.callees.length)
+    out.push(`<div class="aihand-src-empty">(no call edges found)</div>`);
+  return out.join("");
+}
+function escHtml(s) {
+  return s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;").split('"').join("&quot;");
+}
+
+
+
+
+
+
+
+
+
+
+exports.fileOfInspPath = fileOfInspPath; exports.joinPanel = joinPanel; exports.fetchRuntimeKnobs = fetchRuntimeKnobs; exports.symbolAtLine = symbolAtLine; exports.parseInspPath = parseInspPath; exports.locate = locate; exports.renderLocate = renderLocate; exports.sourcePanelHtml = sourcePanelHtml;

package/dist/chunk-OWYK2IGV.js

@@ -0,0 +1,250 @@
+// src/read/compact.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join, resolve } from "path";
+import { Language, Query } from "web-tree-sitter";
+var queryCache = /* @__PURE__ */ new Map();
+function cachedQuery(lang, source) {
+  let byLang = queryCache.get(lang);
+  if (!byLang) {
+    byLang = /* @__PURE__ */ new Map();
+    queryCache.set(lang, byLang);
+  }
+  let q = byLang.get(source);
+  if (!q) {
+    q = new Query(lang, source);
+    byLang.set(source, q);
+  }
+  return q;
+}
+var SEPARATOR = "\u22EE----";
+function isNoParamFn(trimmed) {
+  if (!trimmed.endsWith(")"))
+    return false;
+  let i = trimmed.length - 2;
+  while (i >= 0 && (trimmed[i] === " " || trimmed[i] === "	")) i--;
+  return i >= 0 && trimmed[i] === "(";
+}
+function isSectionComment(text) {
+  if (!text.startsWith("//"))
+    return false;
+  let i = 2;
+  while (i < text.length && (text[i] === " " || text[i] === "	")) i++;
+  return text.startsWith("\u2500\u2500", i);
+}
+var IMPORT_QUERY = `
+(import_statement
+  source: (string (string_fragment) @source))
+`;
+var TS_QUERY = `
+(export_statement (function_declaration)) @fn
+(export_statement (lexical_declaration (variable_declarator value: (arrow_function)))) @fn
+(export_statement (generator_function_declaration)) @fn
+(type_alias_declaration) @internal_type
+(export_statement (type_alias_declaration)) @type
+(interface_declaration) @internal_type
+(export_statement (interface_declaration)) @type
+(enum_declaration) @internal_type
+(export_statement (enum_declaration)) @type
+(class_declaration) @class
+(export_statement (class_declaration)) @class
+(export_statement value: (assignment_expression)) @export_val
+(export_statement (lexical_declaration)) @export_val
+(export_statement source: (string)) @reexport
+(comment) @comment
+`;
+var WASM_MAP = {
+  ".ts": "tree-sitter-tsx.wasm",
+  ".tsx": "tree-sitter-tsx.wasm",
+  ".mts": "tree-sitter-tsx.wasm",
+  ".js": "tree-sitter-tsx.wasm",
+  ".jsx": "tree-sitter-tsx.wasm",
+  ".mjs": "tree-sitter-tsx.wasm"
+};
+var WASM_PROBE_PATHS = [
+  "@repomix/tree-sitter-wasms/out",
+  "@anthropic-ai/tree-sitter-wasms/out",
+  "@anthropic-ai/codemap-tree-sitter-wasms/out"
+];
+var langCache = /* @__PURE__ */ new Map();
+var wasmWarnedOnce = false;
+function findWasmDir(wasmDir) {
+  if (wasmDir)
+    return existsSync(wasmDir) ? wasmDir : null;
+  for (const probe of WASM_PROBE_PATHS) {
+    const full = resolve("node_modules", probe);
+    if (existsSync(full))
+      return full;
+  }
+  try {
+    const req = createRequire(import.meta.url);
+    return dirname(req.resolve("@repomix/tree-sitter-wasms/out/tree-sitter-tsx.wasm"));
+  } catch {
+  }
+  return null;
+}
+async function getLang(ext, wasmDir) {
+  const wasm = WASM_MAP[ext];
+  if (!wasm)
+    return null;
+  const dir = findWasmDir(wasmDir);
+  if (!dir) {
+    if (!wasmWarnedOnce) {
+      wasmWarnedOnce = true;
+      const pkgs = WASM_PROBE_PATHS.map((p) => p.split("/")[0]).join(", ");
+      console.warn(`[repodex] \u26A0 tree-sitter wasm not found. Install one of: ${pkgs}`);
+    }
+    return null;
+  }
+  const wasmPath = join(dir, wasm);
+  if (!existsSync(wasmPath))
+    return null;
+  const cached = langCache.get(wasmPath);
+  if (cached)
+    return cached;
+  const lang = await Language.load(wasmPath);
+  langCache.set(wasmPath, lang);
+  return lang;
+}
+function cleanFnSignature(text) {
+  const lines = text.split("\n");
+  let braceDepth = 0;
+  let parenDepth = 0;
+  let angleDepth = 0;
+  let afterArrow = false;
+  let arrowI = 0;
+  let arrowJ = 0;
+  let prevTopChar = "";
+  for (let i = 0; i < lines.length; i++) {
+    for (let j = 0; j < lines[i].length; j++) {
+      const ch = lines[i][j];
+      if (ch === " " || ch === "	")
+        continue;
+      if (ch === "(") {
+        parenDepth++;
+        afterArrow = false;
+      } else if (ch === ")") {
+        parenDepth--;
+        afterArrow = false;
+      } else if (ch === "<") {
+        angleDepth++;
+        afterArrow = false;
+      } else if (ch === ">") {
+        if (angleDepth > 0)
+          angleDepth--;
+        afterArrow = false;
+      } else if (ch === "{") {
+        if (afterArrow) {
+          lines[arrowI] = lines[arrowI].slice(0, arrowJ).trimEnd();
+          return lines.slice(0, arrowI + 1).join("\n");
+        }
+        if (parenDepth <= 0 && braceDepth <= 0 && angleDepth <= 0 && prevTopChar !== ":") {
+          lines[i] = lines[i].slice(0, j).trimEnd();
+          return lines.slice(0, i + 1).join("\n");
+        }
+        braceDepth++;
+        afterArrow = false;
+      } else if (ch === "}") {
+        if (braceDepth > 0)
+          braceDepth--;
+        afterArrow = false;
+      } else if (ch === "=" && lines[i][j + 1] === ">") {
+        if (parenDepth <= 0 && braceDepth <= 0 && angleDepth <= 0) {
+          lines[i] = lines[i].slice(0, j).trimEnd();
+          return lines.slice(0, i + 1).join("\n");
+        }
+        afterArrow = true;
+        arrowI = i;
+        arrowJ = j;
+        j++;
+      } else {
+        afterArrow = false;
+      }
+      if (parenDepth <= 0 && braceDepth <= 0 && angleDepth <= 0)
+        prevTopChar = ch;
+    }
+  }
+  return text.split("\n")[0];
+}
+function compact(code, parser, lang, flags = {}, existingTree) {
+  const { skipNoParamFn = true } = flags;
+  const tree = existingTree ?? parser.parse(code);
+  if (!tree)
+    return "";
+  const query = cachedQuery(lang, TS_QUERY);
+  const captures = query.captures(tree.rootNode);
+  const ownTree = !existingTree;
+  captures.sort((a, b) => a.node.startPosition.row - b.node.startPosition.row);
+  const chunks = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { name, node } of captures) {
+    const startRow = node.startPosition.row;
+    if (seen.has(startRow))
+      continue;
+    seen.add(startRow);
+    let content;
+    if (name === "fn" || name === "class") {
+      content = cleanFnSignature(node.text);
+    } else if (name === "comment") {
+      if (isSectionComment(node.text))
+        content = node.text;
+      else continue;
+    } else if (name === "reexport") {
+      content = node.text;
+    } else if (name === "export_val") {
+      if (node.descendantsOfType("arrow_function").length > 0) {
+        content = cleanFnSignature(node.text);
+      } else if (node.text.includes("\n")) {
+        content = node.text.split("\n")[0];
+      } else {
+        content = node.text;
+      }
+    } else if (name === "internal_type" || name === "type") {
+      content = node.text;
+    } else {
+      content = node.text;
+    }
+    const trimmed = content.trim();
+    if (skipNoParamFn && (name === "fn" || name === "export_val") && isNoParamFn(trimmed))
+      continue;
+    chunks.push({ content: trimmed, startRow, endRow: node.endPosition.row });
+  }
+  const GAP = 2;
+  const merged = [];
+  for (const chunk of chunks) {
+    const last = merged[merged.length - 1];
+    if (last && last.endRow + GAP >= chunk.startRow) {
+      last.content += `
+${chunk.content}`;
+      last.endRow = chunk.endRow;
+    } else {
+      merged.push({ ...chunk });
+    }
+  }
+  const result = merged.map((c) => c.content).join(`
+${SEPARATOR}
+`);
+  if (ownTree)
+    tree.delete();
+  return result;
+}
+function extractImports(code, parser, lang, existingTree) {
+  const tree = existingTree ?? parser.parse(code);
+  if (!tree)
+    return [];
+  const query = cachedQuery(lang, IMPORT_QUERY);
+  const result = query.captures(tree.rootNode).map((c) => c.node.text);
+  if (!existingTree)
+    tree.delete();
+  return result;
+}
+
+export {
+  SEPARATOR,
+  IMPORT_QUERY,
+  TS_QUERY,
+  getLang,
+  cleanFnSignature,
+  compact,
+  extractImports
+};

package/dist/chunk-PQSQN4CN.js

@@ -0,0 +1,126 @@
+// src/read/config.ts
+import { existsSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { createJiti } from "jiti";
+
+// src/read/types.ts
+var READ_DEFAULTS = {
+  include: [
+    "package.json",
+    "index.html",
+    "tsconfig.json",
+    "tsconfig.*.json",
+    "*.config.{js,ts,mjs,cjs}"
+  ],
+  ignore: [],
+  fileDetailLevel: {
+    "package-lock.json": "tree",
+    "pnpm-lock.yaml": "tree",
+    "yarn.lock": "tree",
+    "bun.lock": "tree",
+    "**/*.test.ts": "tree",
+    "**/*.test.tsx": "tree",
+    "**/*.spec.ts": "tree",
+    "**/*.spec.tsx": "tree"
+  },
+  injectDetailLevel: "tree",
+  injectTargetFiles: ["CLAUDE.md", "AGENTS.md"],
+  showNoParamFn: false,
+  treeFoldThreshold: 8,
+  injectDevToolInstructions: true,
+  injectCodemap: true,
+  maxTokens: 5e3
+};
+var DEFAULT_CONFIG = {
+  read: { enabled: true, ...READ_DEFAULTS },
+  refactor: { enabled: true },
+  runtime: { enabled: true, storeMarker: "_loading" }
+};
+function resolveModule(sw, defaults) {
+  if (sw === false)
+    return { enabled: false, ...defaults };
+  if (sw === void 0 || sw === true)
+    return { enabled: true, ...defaults };
+  return { enabled: true, ...defaults, ...sw };
+}
+function defineConfig(config) {
+  return config;
+}
+function configTemplate() {
+  return `    // aihand = three capability modules. Each: true (on, defaults) \xB7 false (off) \xB7 { ...overrides }.
+    // Most repos only need the three switches below \u2014 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 \u2014 needs the vite plugin);
+    // set false on repos without a dev server.
+    // Non-MobX store factory? runtime: { storeMarker: 'getState' } \u2014 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 \u2014 auto-downgrades less important files
+    //   injectCodemap: true,           // false \u2192 Overview + a pointer to \`aihand read --stdout\`
+    // },`;
+}
+
+// src/read/config.ts
+var CONFIG_PATH = "aihand.config.ts";
+var SELF_PATH = fileURLToPath(import.meta.url);
+var TS_EXTS = [".ts", ".tsx", ".js", ".jsx"];
+var isTsFile = (p) => TS_EXTS.some((ext) => p.endsWith(ext));
+async function loadConfig(root = resolve(".")) {
+  const configFile = join(root, CONFIG_PATH);
+  if (!existsSync(configFile))
+    return DEFAULT_CONFIG;
+  const selfDir = dirname(SELF_PATH);
+  const aihandIndex = [join(selfDir, "index.js"), resolve(selfDir, "../index.ts")].find(existsSync) ?? join(selfDir, "index.js");
+  const jiti = createJiti(root, {
+    alias: { aihand: aihandIndex },
+    moduleCache: false,
+    fsCache: false
+  });
+  const mod = await jiti.import(configFile);
+  const raw = mod.default ?? mod;
+  return normalizeConfig(raw);
+}
+function normalizeConfig(raw) {
+  const read = resolveModule(raw.read, {});
+  const d = DEFAULT_CONFIG.read;
+  return {
+    read: {
+      enabled: read.enabled,
+      include: [...d.include, ...read.include ?? ["src/**"]],
+      ignore: read.ignore ?? d.ignore,
+      fileDetailLevel: { ...d.fileDetailLevel, ...read.fileDetailLevel },
+      injectDetailLevel: read.injectDetailLevel ?? d.injectDetailLevel,
+      injectTargetFiles: read.injectTargetFiles ?? d.injectTargetFiles,
+      injectDevToolInstructions: read.injectDevToolInstructions ?? d.injectDevToolInstructions,
+      injectCodemap: read.injectCodemap ?? d.injectCodemap,
+      showNoParamFn: read.showNoParamFn ?? d.showNoParamFn,
+      treeFoldThreshold: read.treeFoldThreshold ?? d.treeFoldThreshold,
+      maxTokens: typeof read.maxTokens === "number" ? read.maxTokens : d.maxTokens
+    },
+    refactor: { enabled: raw.refactor !== false },
+    runtime: (() => {
+      const r = resolveModule(raw.runtime, {});
+      return { enabled: r.enabled, storeMarker: r.storeMarker ?? "_loading" };
+    })()
+  };
+}
+
+export {
+  DEFAULT_CONFIG,
+  defineConfig,
+  configTemplate,
+  CONFIG_PATH,
+  isTsFile,
+  loadConfig,
+  normalizeConfig
+};