jinzd-ai-cli 0.4.75 → 0.4.77

package/dist/chunk-RFQVUMDB.js

@@ -0,0 +1,430 @@
+import {
+  detectLanguage,
+  emptyIndex,
+  loadIndex,
+  removeFile,
+  saveIndex,
+  upsertFileSymbols
+} from "./chunk-BJAT4GNC.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-5P4QTZBI.js → chunk-S4WDPHKS.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/core/constants.ts
-var VERSION = "0.4.75";
+var VERSION = "0.4.77";
 var APP_NAME = "ai-cli";
 var CONFIG_DIR_NAME = ".aicli";
 var CONFIG_FILE_NAME = "config.json";
@@ -30,8 +30,16 @@ var PLAN_MODE_READONLY_TOOLS = /* @__PURE__ */ new Set([
   "google_search",
   "ask_user",
   // 允许：可向用户澄清需求
-  "write_todos"
+  "write_todos",
   // 允许：可输出任务列表作为实施计划
+  "find_symbol",
+  // C1 symbol index (read-only)
+  "get_outline",
+  // C1 symbol index (read-only)
+  "find_references",
+  // C1 symbol index (read-only)
+  "search_code"
+  // C2 semantic search (read-only)
 ]);
 var PLAN_MODE_SYSTEM_ADDON = `# \u{1F50D} Plan Mode \u2014 Read-Only Planning Mode
 
@@ -71,7 +79,11 @@ var SUBAGENT_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
   "web_fetch",
   "google_search",
   "write_todos",
-  "run_tests"
+  "run_tests",
+  "find_symbol",
+  "get_outline",
+  "find_references",
+  "search_code"
 ]);
 var CONTEXT_PRESSURE_THRESHOLD = 0.8;
 var TEST_TIMEOUT = 3e5;

package/dist/chunk-UTCC3UMT.js

@@ -0,0 +1,83 @@
+import {
+  loadIndex
+} from "./chunk-BJAT4GNC.js";
+import {
+  EMBEDDING_DIM,
+  embed,
+  embedOne,
+  loadVectorStore,
+  saveVectorStore,
+  searchVectorStore
+} from "./chunk-XMA222FQ.js";
+
+// src/symbols/semantic.ts
+function buildEmbeddingText(s) {
+  const parts = [s.kind, s.name];
+  if (s.container) parts.push(`in ${s.container}`);
+  if (s.signature) parts.push(s.signature);
+  if (s.doc) parts.push(s.doc);
+  return parts.join(" ").slice(0, 512);
+}
+async function rebuildSemanticIndex(root, opts = {}) {
+  const start = Date.now();
+  const index = loadIndex(root);
+  if (!index) {
+    throw new Error(
+      `No symbol index for ${root}. Run /index rebuild first so find_symbol has data to embed.`
+    );
+  }
+  const maxSymbols = opts.maxSymbols ?? 2e4;
+  const batchSize = opts.batchSize ?? 32;
+  const total = Math.min(index.symbols.length, maxSymbols);
+  if (total === 0) {
+    saveVectorStore(root, new Uint32Array(0), new Float32Array(0));
+    return { symbolsEmbedded: 0, durationMs: Date.now() - start };
+  }
+  const symbolIdx = new Uint32Array(total);
+  const vectors = new Float32Array(total * EMBEDDING_DIM);
+  let modelFirstLoadMs;
+  for (let i = 0; i < total; i += batchSize) {
+    const end = Math.min(i + batchSize, total);
+    const batch = [];
+    for (let j = i; j < end; j++) {
+      symbolIdx[j] = j;
+      batch.push(buildEmbeddingText(index.symbols[j]));
+    }
+    const batchStart = Date.now();
+    const rows = await embed(batch);
+    if (i === 0) modelFirstLoadMs = Date.now() - batchStart;
+    for (let r = 0; r < rows.length; r++) {
+      vectors.set(rows[r], (i + r) * EMBEDDING_DIM);
+    }
+    if (opts.onProgress) opts.onProgress(end, total);
+  }
+  saveVectorStore(root, symbolIdx, vectors);
+  return {
+    symbolsEmbedded: total,
+    durationMs: Date.now() - start,
+    modelFirstLoadMs
+  };
+}
+async function semanticSearch(root, query, k = 10) {
+  const index = loadIndex(root);
+  if (!index) return [];
+  const store = loadVectorStore(root);
+  if (!store || store.count === 0) return [];
+  const queryVec = await embedOne(query);
+  const hits = searchVectorStore(store, queryVec, k);
+  return hits.map((h) => ({
+    ...h,
+    symbol: index.symbols[h.symbolIdx]
+  })).filter((h) => h.symbol !== void 0);
+}
+function hasSemanticIndex(root) {
+  const s = loadVectorStore(root);
+  return s !== null && s.count > 0;
+}
+
+export {
+  buildEmbeddingText,
+  rebuildSemanticIndex,
+  semanticSearch,
+  hasSemanticIndex
+};