jinzd-ai-cli 0.4.75 → 0.4.77

package/dist/chunk-NHNWUBXB.js

@@ -0,0 +1,431 @@
+#!/usr/bin/env node
+import {
+  detectLanguage,
+  emptyIndex,
+  loadIndex,
+  removeFile,
+  saveIndex,
+  upsertFileSymbols
+} from "./chunk-6VRJGH25.js";
+
+// src/symbols/indexer.ts
+import fs2 from "fs";
+import path3 from "path";
+
+// src/symbols/parser.ts
+import path2 from "path";
+
+// src/symbols/loader.ts
+import { Parser, Language } from "web-tree-sitter";
+import { createRequire } from "module";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+var _metaUrl = import.meta?.url;
+var _cjsFilename = globalThis.__filename;
+var __filename_ = _metaUrl ? fileURLToPath(_metaUrl) : _cjsFilename ?? process.execPath;
+var __dirname_ = path.dirname(__filename_);
+var require_ = _metaUrl ? createRequire(_metaUrl) : createRequire(__filename_);
+var GRAMMAR_FILE = {
+  typescript: "tree-sitter-typescript.wasm",
+  tsx: "tree-sitter-tsx.wasm",
+  javascript: "tree-sitter-javascript.wasm",
+  python: "tree-sitter-python.wasm"
+};
+var RUNTIME_WASM = "web-tree-sitter.wasm";
+var parserInitPromise = null;
+var languageCache = /* @__PURE__ */ new Map();
+var parserCache = /* @__PURE__ */ new Map();
+function resolveWasmPath(filename) {
+  const candidates = [];
+  candidates.push(path.join(__dirname_, "wasm", filename));
+  candidates.push(path.join(__dirname_, "..", "wasm", filename));
+  candidates.push(path.join(__dirname_, "..", "dist", "wasm", filename));
+  if (process.pkg) {
+    candidates.push(path.join(path.dirname(process.execPath), "dist", "wasm", filename));
+    candidates.push(path.join("/snapshot", "ai-cli", "dist", "wasm", filename));
+    candidates.push(path.join("/snapshot", "jinzd-ai-cli", "dist", "wasm", filename));
+  }
+  const resourcesPath = process.resourcesPath;
+  if (resourcesPath) {
+    candidates.push(path.join(resourcesPath, "app.asar.unpacked", "dist", "wasm", filename));
+    candidates.push(path.join(resourcesPath, "app", "dist", "wasm", filename));
+  }
+  try {
+    if (filename === RUNTIME_WASM) {
+      const pkgPath = require_.resolve("web-tree-sitter/package.json");
+      candidates.push(path.join(path.dirname(pkgPath), filename));
+    } else {
+      const grammarPkg = filename.replace(/\.wasm$/, "").replace(/^tree-sitter-tsx$/, "tree-sitter-typescript");
+      const pkgPath = require_.resolve(`${grammarPkg}/package.json`);
+      candidates.push(path.join(path.dirname(pkgPath), filename));
+    }
+  } catch {
+  }
+  candidates.push(path.join(process.cwd(), "dist", "wasm", filename));
+  candidates.push(path.join(process.cwd(), "node_modules", "web-tree-sitter", filename));
+  for (const p of candidates) {
+    try {
+      if (fs.existsSync(p)) return p;
+    } catch {
+    }
+  }
+  throw new Error(
+    `[symbols/loader] Cannot locate ${filename}. Searched:
+  ${candidates.join("\n  ")}`
+  );
+}
+async function initRuntime() {
+  if (parserInitPromise) return parserInitPromise;
+  parserInitPromise = Parser.init({
+    locateFile: (name) => resolveWasmPath(name)
+  });
+  return parserInitPromise;
+}
+async function loadParser(language) {
+  const cached = parserCache.get(language);
+  if (cached) return cached;
+  await initRuntime();
+  let lang = languageCache.get(language);
+  if (!lang) {
+    const wasmPath = resolveWasmPath(GRAMMAR_FILE[language]);
+    lang = await Language.load(wasmPath);
+    languageCache.set(language, lang);
+  }
+  const parser = new Parser();
+  parser.setLanguage(lang);
+  parserCache.set(language, parser);
+  return parser;
+}
+
+// src/symbols/parser.ts
+function locationOf(file, node) {
+  return {
+    file: path2.resolve(file),
+    line: node.startPosition.row + 1,
+    column: node.startPosition.column,
+    endLine: node.endPosition.row + 1,
+    endColumn: node.endPosition.column
+  };
+}
+function firstLine(text, max = 200) {
+  const line = text.split(/\r?\n/)[0] ?? "";
+  return line.length > max ? line.slice(0, max) + "\u2026" : line;
+}
+function childByFieldName(node, field) {
+  return node.childForFieldName(field) ?? null;
+}
+function nameOf(node) {
+  const n = childByFieldName(node, "name") ?? node.children.find((c) => c?.type === "identifier" || c?.type === "property_identifier" || c?.type === "type_identifier");
+  return n?.text ?? null;
+}
+function extractTsJs(root, file, language) {
+  const out = [];
+  const visit = (node, container, exported) => {
+    let childrenContainer = container;
+    const kindMap = {
+      function_declaration: "function",
+      generator_function_declaration: "function",
+      class_declaration: "class",
+      abstract_class_declaration: "class",
+      interface_declaration: "interface",
+      type_alias_declaration: "type",
+      enum_declaration: "enum",
+      method_definition: "method",
+      method_signature: "method",
+      public_field_definition: "property"
+    };
+    const kind = kindMap[node.type];
+    if (kind) {
+      const name = nameOf(node);
+      if (name) {
+        out.push({
+          name,
+          kind,
+          language,
+          location: locationOf(file, node),
+          signature: firstLine(node.text),
+          container,
+          exported
+        });
+        if (kind === "class" || kind === "interface" || kind === "enum") {
+          childrenContainer = name;
+        }
+      }
+    } else if (node.type === "lexical_declaration" || node.type === "variable_declaration") {
+      for (const decl of node.children) {
+        if (decl?.type !== "variable_declarator") continue;
+        const nameNode = childByFieldName(decl, "name");
+        if (!nameNode || nameNode.type !== "identifier") continue;
+        out.push({
+          name: nameNode.text,
+          kind: "variable",
+          language,
+          location: locationOf(file, decl),
+          signature: firstLine(decl.text),
+          container,
+          exported
+        });
+      }
+    } else if (node.type === "export_statement") {
+      for (const c of node.children) {
+        if (c) visit(c, container, true);
+      }
+      return;
+    }
+    const descendInto = /* @__PURE__ */ new Set([
+      "program",
+      "module",
+      "class_body",
+      "class_declaration",
+      "abstract_class_declaration",
+      "interface_body",
+      "interface_declaration",
+      "enum_body",
+      "enum_declaration",
+      "export_statement",
+      "statement_block",
+      // for nested class_declaration inside namespace etc.
+      "internal_module",
+      "namespace_declaration"
+    ]);
+    if (node === root || descendInto.has(node.type)) {
+      for (const c of node.children) {
+        if (c) visit(c, childrenContainer, exported);
+      }
+    }
+  };
+  visit(root, void 0, false);
+  return out;
+}
+function extractPython(root, file) {
+  const out = [];
+  const visit = (node, container, isModuleLevel) => {
+    if (node.type === "decorated_definition") {
+      const def = node.children.find(
+        (c) => c?.type === "class_definition" || c?.type === "function_definition"
+      );
+      if (def) visit(def, container, isModuleLevel);
+      return;
+    }
+    if (node.type === "class_definition") {
+      const name = nameOf(node);
+      if (name) {
+        out.push({
+          name,
+          kind: "class",
+          language: "python",
+          location: locationOf(file, node),
+          signature: firstLine(node.text),
+          container,
+          exported: isModuleLevel
+        });
+        const body = childByFieldName(node, "body");
+        if (body) {
+          for (const c of body.children) {
+            if (c) visit(c, name, false);
+          }
+        }
+      }
+      return;
+    }
+    if (node.type === "function_definition") {
+      const name = nameOf(node);
+      if (name) {
+        out.push({
+          name,
+          kind: container ? "method" : "function",
+          language: "python",
+          location: locationOf(file, node),
+          signature: firstLine(node.text),
+          container,
+          exported: isModuleLevel && !name.startsWith("_")
+        });
+      }
+      return;
+    }
+    if (isModuleLevel && node.type === "expression_statement") {
+      const assign = node.children.find((c) => c?.type === "assignment");
+      if (assign) {
+        const left = childByFieldName(assign, "left");
+        if (left && left.type === "identifier") {
+          out.push({
+            name: left.text,
+            kind: "variable",
+            language: "python",
+            location: locationOf(file, assign),
+            signature: firstLine(assign.text),
+            container,
+            exported: !left.text.startsWith("_")
+          });
+        }
+      }
+      return;
+    }
+    if (node === root || node.type === "module") {
+      for (const c of node.children) {
+        if (c) visit(c, container, true);
+      }
+    }
+  };
+  visit(root, void 0, true);
+  return out;
+}
+async function parseSource(file, source, language) {
+  const lang = language ?? detectLanguage(path2.extname(file).slice(1));
+  if (!lang) return [];
+  try {
+    const parser = await loadParser(lang);
+    const tree = parser.parse(source);
+    if (!tree) return [];
+    const root = tree.rootNode;
+    if (lang === "python") return extractPython(root, file);
+    return extractTsJs(root, file, lang);
+  } catch (err) {
+    return [];
+  }
+}
+
+// src/symbols/indexer.ts
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "dist-cjs",
+  "build",
+  "out",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".cache",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".idea",
+  ".vscode",
+  "release"
+]);
+var MAX_FILE_BYTES = 2 * 1024 * 1024;
+function collectFiles(root, maxFiles) {
+  const out = [];
+  const stack = [root];
+  while (stack.length > 0 && out.length < maxFiles) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const full = path3.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        if (e.name.startsWith(".") && e.name !== ".") {
+          continue;
+        }
+        stack.push(full);
+      } else if (e.isFile()) {
+        const ext = path3.extname(e.name).slice(1);
+        if (detectLanguage(ext)) {
+          out.push(full);
+          if (out.length >= maxFiles) break;
+        }
+      }
+    }
+  }
+  return out;
+}
+async function indexProject(root, opts = {}) {
+  const start = Date.now();
+  const maxFiles = opts.maxFiles ?? 5e3;
+  const force = opts.force === true;
+  const absRoot = path3.resolve(root);
+  let index = force ? emptyIndex(absRoot) : loadIndex(absRoot) ?? emptyIndex(absRoot);
+  const files = collectFiles(absRoot, maxFiles);
+  const liveSet = new Set(files.map((f) => path3.resolve(f)));
+  for (const known of Object.keys(index.files)) {
+    if (!liveSet.has(known)) {
+      index = removeFile(index, known);
+    }
+  }
+  let parsed = 0;
+  let skipped = 0;
+  for (let i = 0; i < files.length; i++) {
+    const file = path3.resolve(files[i]);
+    let stat;
+    try {
+      stat = fs2.statSync(file);
+    } catch {
+      skipped++;
+      continue;
+    }
+    if (stat.size > MAX_FILE_BYTES) {
+      skipped++;
+      continue;
+    }
+    const prevMtime = index.files[file];
+    if (!force && prevMtime !== void 0 && prevMtime === stat.mtimeMs) {
+      continue;
+    }
+    let src;
+    try {
+      src = fs2.readFileSync(file, "utf-8");
+    } catch {
+      skipped++;
+      continue;
+    }
+    const symbols = await parseSource(file, src);
+    index = upsertFileSymbols(index, file, stat.mtimeMs, symbols);
+    parsed++;
+    if (opts.onProgress && parsed % 50 === 0) {
+      opts.onProgress(i + 1, files.length);
+    }
+  }
+  saveIndex(index);
+  return {
+    index,
+    stats: {
+      filesScanned: files.length,
+      filesParsed: parsed,
+      filesSkipped: skipped,
+      symbols: index.symbolCount,
+      durationMs: Date.now() - start
+    }
+  };
+}
+async function updateFile(root, file) {
+  const absRoot = path3.resolve(root);
+  const absFile = path3.resolve(file);
+  let index = loadIndex(absRoot);
+  if (!index) return;
+  if (!fs2.existsSync(absFile)) {
+    index = removeFile(index, absFile);
+    saveIndex(index);
+    return;
+  }
+  const ext = path3.extname(absFile).slice(1);
+  if (!detectLanguage(ext)) return;
+  let stat;
+  try {
+    stat = fs2.statSync(absFile);
+  } catch {
+    return;
+  }
+  if (stat.size > MAX_FILE_BYTES) return;
+  let src;
+  try {
+    src = fs2.readFileSync(absFile, "utf-8");
+  } catch {
+    return;
+  }
+  const symbols = await parseSource(absFile, src);
+  index = upsertFileSymbols(index, absFile, stat.mtimeMs, symbols);
+  saveIndex(index);
+}
+
+export {
+  indexProject,
+  updateFile
+};

package/dist/chunk-PFYAAX2S.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+// src/symbols/vector-store.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+import crypto from "crypto";
+
+// src/symbols/embedder.ts
+import path from "path";
+import os from "os";
+import fs from "fs";
+var EMBEDDING_MODEL_ID = "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
+var EMBEDDING_DIM = 384;
+var pipelinePromise = null;
+function cacheDir() {
+  return path.join(os.homedir(), ".aicli", "models");
+}
+async function getEmbedder() {
+  if (pipelinePromise) return pipelinePromise;
+  pipelinePromise = (async () => {
+    const mod = await import("@huggingface/transformers");
+    const dir = cacheDir();
+    fs.mkdirSync(dir, { recursive: true });
+    mod.env.cacheDir = dir;
+    mod.env.allowRemoteModels = true;
+    mod.env.allowLocalModels = true;
+    const pipe = await mod.pipeline("feature-extraction", EMBEDDING_MODEL_ID, {
+      // Keep the ONNX session in float32; int8 quantization exists but the
+      // quality drop on short code identifiers is noticeable.
+      dtype: "fp32"
+    });
+    return pipe;
+  })();
+  return pipelinePromise;
+}
+async function embed(texts) {
+  if (texts.length === 0) return [];
+  const pipe = await getEmbedder();
+  const out = await pipe(texts, { pooling: "mean", normalize: true });
+  const batch = texts.length;
+  const dim = EMBEDDING_DIM;
+  const rows = new Array(batch);
+  for (let i = 0; i < batch; i++) {
+    rows[i] = new Float32Array(out.data.buffer, out.data.byteOffset + i * dim * 4, dim).slice();
+  }
+  return rows;
+}
+async function embedOne(text) {
+  const [vec] = await embed([text]);
+  return vec;
+}
+
+// src/symbols/vector-store.ts
+var MAGIC = 1094927190;
+var VERSION = 1;
+var HEADER_BYTES = 16;
+function indexDir() {
+  return path2.join(os2.homedir(), ".aicli", "index");
+}
+function projectHash(root) {
+  return crypto.createHash("sha1").update(path2.resolve(root).toLowerCase()).digest("hex").slice(0, 16);
+}
+function vecPath(root) {
+  return path2.join(indexDir(), `${projectHash(root)}.vec`);
+}
+function emptyVectorStore(root) {
+  return {
+    root: path2.resolve(root),
+    count: 0,
+    dim: EMBEDDING_DIM,
+    vectors: new Float32Array(0),
+    symbolIdx: new Uint32Array(0)
+  };
+}
+function saveVectorStore(root, indices, vectors) {
+  if (indices.length * EMBEDDING_DIM !== vectors.length) {
+    throw new Error(
+      `saveVectorStore: length mismatch \u2014 ${indices.length} indices vs ${vectors.length / EMBEDDING_DIM} vectors`
+    );
+  }
+  const count = indices.length;
+  const dir = indexDir();
+  fs2.mkdirSync(dir, { recursive: true });
+  const totalBytes = HEADER_BYTES + count * 4 + count * EMBEDDING_DIM * 4;
+  const buf = Buffer.alloc(totalBytes);
+  buf.writeUInt32LE(MAGIC, 0);
+  buf.writeUInt32LE(VERSION, 4);
+  buf.writeUInt32LE(count, 8);
+  buf.writeUInt32LE(EMBEDDING_DIM, 12);
+  Buffer.from(indices.buffer, indices.byteOffset, indices.byteLength).copy(buf, HEADER_BYTES);
+  Buffer.from(vectors.buffer, vectors.byteOffset, vectors.byteLength).copy(buf, HEADER_BYTES + count * 4);
+  const target = vecPath(root);
+  const tmp = `${target}.tmp`;
+  fs2.writeFileSync(tmp, buf);
+  fs2.renameSync(tmp, target);
+}
+function loadVectorStore(root) {
+  const p = vecPath(root);
+  if (!fs2.existsSync(p)) return null;
+  let buf;
+  try {
+    buf = fs2.readFileSync(p);
+  } catch {
+    return null;
+  }
+  if (buf.length < HEADER_BYTES) return null;
+  const magic = buf.readUInt32LE(0);
+  const version = buf.readUInt32LE(4);
+  const count = buf.readUInt32LE(8);
+  const dim = buf.readUInt32LE(12);
+  if (magic !== MAGIC || version !== VERSION || dim !== EMBEDDING_DIM) return null;
+  const expected = HEADER_BYTES + count * 4 + count * dim * 4;
+  if (buf.length !== expected) return null;
+  const symbolIdx = new Uint32Array(
+    buf.buffer.slice(buf.byteOffset + HEADER_BYTES, buf.byteOffset + HEADER_BYTES + count * 4)
+  );
+  const vectors = new Float32Array(
+    buf.buffer.slice(
+      buf.byteOffset + HEADER_BYTES + count * 4,
+      buf.byteOffset + HEADER_BYTES + count * 4 + count * dim * 4
+    )
+  );
+  return { root: path2.resolve(root), count, dim, vectors, symbolIdx };
+}
+function clearVectorStore(root) {
+  const p = vecPath(root);
+  try {
+    if (fs2.existsSync(p)) fs2.unlinkSync(p);
+  } catch {
+  }
+}
+function searchVectorStore(store, queryVec, k) {
+  if (store.count === 0) return [];
+  if (queryVec.length !== store.dim) {
+    throw new Error(`searchVectorStore: dim mismatch (query=${queryVec.length}, store=${store.dim})`);
+  }
+  const { count, dim, vectors, symbolIdx } = store;
+  const heap = [];
+  const push = (hit) => {
+    if (heap.length < k) {
+      heap.push(hit);
+      heap.sort((a, b) => a.score - b.score);
+    } else if (hit.score > heap[0].score) {
+      heap[0] = hit;
+      heap.sort((a, b) => a.score - b.score);
+    }
+  };
+  for (let row = 0; row < count; row++) {
+    const base = row * dim;
+    let score = 0;
+    for (let d = 0; d < dim; d++) {
+      score += vectors[base + d] * queryVec[d];
+    }
+    push({ row, symbolIdx: symbolIdx[row], score });
+  }
+  return heap.sort((a, b) => b.score - a.score);
+}
+
+export {
+  EMBEDDING_DIM,
+  embed,
+  embedOne,
+  emptyVectorStore,
+  saveVectorStore,
+  loadVectorStore,
+  clearVectorStore,
+  searchVectorStore
+};

package/dist/{chunk-3BHGEPIT.js → chunk-QATT4NCL.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   TEST_TIMEOUT
-} from "./chunk-5P4QTZBI.js";
+} from "./chunk-S4WDPHKS.js";
 
 // src/tools/builtin/run-tests.ts
 import { execSync } from "child_process";