aihand 0.0.1 → 0.1.1

package/dist/chunk-DUUCVLC3.cjs

@@ -0,0 +1,254 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkZ2Y65YOYcjs = require('./chunk-Z2Y65YOY.cjs');
+
+// src/read/compact.ts
+var _fs = require('fs');
+var _module = require('module');
+var _path = require('path');
+var _webtreesitter = require('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 (0, _webtreesitter.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 _fs.existsSync.call(void 0, wasmDir) ? wasmDir : null;
+  for (const probe of WASM_PROBE_PATHS) {
+    const full = _path.resolve.call(void 0, "node_modules", probe);
+    if (_fs.existsSync.call(void 0, full))
+      return full;
+  }
+  try {
+    const req = _module.createRequire.call(void 0, _chunkZ2Y65YOYcjs.importMetaUrl);
+    return _path.dirname.call(void 0, req.resolve("@repomix/tree-sitter-wasms/out/tree-sitter-tsx.wasm"));
+  } catch (e) {
+  }
+  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 = _path.join.call(void 0, dir, wasm);
+  if (!_fs.existsSync.call(void 0, wasmPath))
+    return null;
+  const cached = langCache.get(wasmPath);
+  if (cached)
+    return cached;
+  const lang = await _webtreesitter.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 = _nullishCoalesce(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 = _nullishCoalesce(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;
+}
+
+
+
+
+
+
+
+
+
+exports.SEPARATOR = SEPARATOR; exports.IMPORT_QUERY = IMPORT_QUERY; exports.TS_QUERY = TS_QUERY; exports.getLang = getLang; exports.cleanFnSignature = cleanFnSignature; exports.compact = compact; exports.extractImports = extractImports;

package/dist/chunk-FAHI53KO.cjs

@@ -0,0 +1,125 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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/graph.ts
+var _fs = require('fs');
+var _webtreesitter = require('web-tree-sitter');
+var DEFS_QUERY = `
+(function_declaration name: (identifier) @name) @def
+(generator_function_declaration name: (identifier) @name) @def
+(class_declaration name: (type_identifier) @name) @def
+(method_definition name: (property_identifier) @name) @def
+(variable_declarator name: (identifier) @name value: (arrow_function)) @def
+`;
+var CALLS_QUERY = `
+(call_expression function: (identifier) @callee)
+(call_expression function: (member_expression property: (property_identifier) @callee))
+(new_expression constructor: (identifier) @callee)
+`;
+function extractFileGraph(code, parser, defsQuery, callsQuery) {
+  const tree = parser.parse(code);
+  if (!tree)
+    return { defs: [], attributed: [] };
+  const defs = [];
+  for (const match of defsQuery.matches(tree.rootNode)) {
+    const defCapture = match.captures.find((c) => c.name === "def");
+    const nameCapture = match.captures.find((c) => c.name === "name");
+    if (!defCapture || !nameCapture)
+      continue;
+    const KIND_MAP = {
+      class_declaration: "class",
+      method_definition: "method"
+    };
+    const kind = _nullishCoalesce(KIND_MAP[defCapture.node.type], () => ( "function"));
+    defs.push({
+      name: nameCapture.node.text,
+      kind,
+      startLine: defCapture.node.startPosition.row,
+      endLine: defCapture.node.endPosition.row
+    });
+  }
+  const rawCalls = [];
+  for (const { node } of callsQuery.captures(tree.rootNode))
+    rawCalls.push({ callee: node.text, row: node.startPosition.row });
+  const attributed = [];
+  for (const call of rawCalls) {
+    let best = null;
+    let bestSize = Infinity;
+    for (const def of defs) {
+      if (call.row >= def.startLine && call.row <= def.endLine) {
+        const size = def.endLine - def.startLine;
+        if (size < bestSize) {
+          best = def;
+          bestSize = size;
+        }
+      }
+    }
+    if (best)
+      attributed.push({ callerDef: best, callee: call.callee });
+  }
+  tree.delete();
+  return { defs, attributed };
+}
+async function buildCallGraph(filePaths, contents) {
+  await _webtreesitter.Parser.init();
+  const parser = new (0, _webtreesitter.Parser)();
+  let lang = null;
+  for (const fp of filePaths) {
+    const ext = fp.slice(fp.lastIndexOf("."));
+    lang = await _chunkDUUCVLC3cjs.getLang.call(void 0, ext);
+    if (lang)
+      break;
+  }
+  if (!lang)
+    return { symbols: {}, out: {}, in: {} };
+  parser.setLanguage(lang);
+  const defsQuery = new (0, _webtreesitter.Query)(lang, DEFS_QUERY);
+  const callsQuery = new (0, _webtreesitter.Query)(lang, CALLS_QUERY);
+  const symbols = {};
+  const nameToUids = /* @__PURE__ */ new Map();
+  const fileGraphs = [];
+  for (const filePath of filePaths) {
+    let code;
+    if (_optionalChain([contents, 'optionalAccess', _ => _.has, 'call', _2 => _2(filePath)])) {
+      code = contents.get(filePath);
+    } else {
+      try {
+        code = _fs.readFileSync.call(void 0, filePath, "utf-8");
+      } catch (e) {
+        continue;
+      }
+    }
+    const { defs, attributed } = extractFileGraph(code, parser, defsQuery, callsQuery);
+    for (const def of defs) {
+      const uid = `${filePath}::${def.name}:${def.startLine}`;
+      symbols[uid] = { uid, name: def.name, kind: def.kind, filePath, startLine: def.startLine, endLine: def.endLine };
+      if (!nameToUids.has(def.name))
+        nameToUids.set(def.name, []);
+      nameToUids.get(def.name).push(uid);
+    }
+    fileGraphs.push({ filePath, attributed });
+  }
+  const outSets = {};
+  const inSets = {};
+  for (const { filePath, attributed } of fileGraphs) {
+    for (const { callerDef, callee } of attributed) {
+      const callerUid = `${filePath}::${callerDef.name}:${callerDef.startLine}`;
+      for (const calleeUid of _nullishCoalesce(nameToUids.get(callee), () => ( []))) {
+        ;
+        (outSets[callerUid] ??= /* @__PURE__ */ new Set()).add(calleeUid);
+        (inSets[calleeUid] ??= /* @__PURE__ */ new Set()).add(callerUid);
+      }
+    }
+  }
+  const out = Object.fromEntries(Object.entries(outSets).map(([k, v]) => [k, [...v]]));
+  const inEdges = Object.fromEntries(Object.entries(inSets).map(([k, v]) => [k, [...v]]));
+  defsQuery.delete();
+  callsQuery.delete();
+  parser.delete();
+  return { symbols, out, in: inEdges };
+}
+
+
+
+exports.buildCallGraph = buildCallGraph;