jinzd-ai-cli 0.4.75 → 0.4.77

package/dist/{chunk-MPIUYP6Q.js → chunk-LKDX2GOW.js}

@@ -1,15 +1,25 @@
 #!/usr/bin/env node
-import {
-  fileCheckpoints
-} from "./chunk-4BKXL7SM.js";
-import {
-  runTestsTool
-} from "./chunk-3BHGEPIT.js";
 import {
   EnvLoader,
   NetworkError,
   ToolError
 } from "./chunk-2ZD3YTVM.js";
+import {
+  fileCheckpoints
+} from "./chunk-4BKXL7SM.js";
+import {
+  indexProject
+} from "./chunk-NHNWUBXB.js";
+import {
+  hasSemanticIndex,
+  semanticSearch
+} from "./chunk-HPDDAXFY.js";
+import {
+  loadIndex
+} from "./chunk-6VRJGH25.js";
+import {
+  runTestsTool
+} from "./chunk-QATT4NCL.js";
 import {
   CONFIG_DIR_NAME,
   DEFAULT_MAX_TOOL_OUTPUT_CHARS_CAP,
@@ -17,7 +27,7 @@ import {
   SUBAGENT_ALLOWED_TOOLS,
   SUBAGENT_DEFAULT_MAX_ROUNDS,
   SUBAGENT_MAX_ROUNDS_LIMIT
-} from "./chunk-5P4QTZBI.js";
+} from "./chunk-S4WDPHKS.js";
 
 // src/tools/builtin/bash.ts
 import { execSync } from "child_process";
@@ -1028,8 +1038,8 @@ function checkPermission(toolName, args, dangerLevel, rules, defaultAction = "co
     if (rule.when) {
       if (rule.when.dangerLevel && rule.when.dangerLevel !== dangerLevel) continue;
       if (rule.when.pathPattern) {
-        const path = String(args["path"] ?? args["command"] ?? "");
-        if (!path.includes(rule.when.pathPattern)) continue;
+        const path3 = String(args["path"] ?? args["command"] ?? "");
+        if (!path3.includes(rule.when.pathPattern)) continue;
       }
     }
     return rule.action;
@@ -1729,6 +1739,13 @@ Important: For long content (over 500 lines or 3000 chars), you MUST split into
     }
     const lines = content.split("\n").length;
     const mode = appendMode ? "appended" : "written";
+    void (async () => {
+      try {
+        const { updateFile } = await import("./indexer-C7QYYHSZ.js");
+        await updateFile(process.cwd(), filePath);
+      } catch {
+      }
+    })();
     return `File ${mode}: ${filePath} (${lines} lines, ${content.length} bytes)`;
   }
 };
@@ -4286,6 +4303,281 @@ var notebookEditTool = {
   }
 };
 
+// src/tools/builtin/symbol-tools.ts
+import path2 from "path";
+
+// src/symbols/queries.ts
+import path from "path";
+import fs from "fs";
+function findSymbol(index, opts) {
+  const name = opts.name.toLowerCase();
+  const exact = opts.exact !== false;
+  const kinds = opts.kind ? new Set(Array.isArray(opts.kind) ? opts.kind : [opts.kind]) : null;
+  const limit = opts.limit ?? 50;
+  const out = [];
+  for (const s of index.symbols) {
+    if (kinds && !kinds.has(s.kind)) continue;
+    const lower = s.name.toLowerCase();
+    if (exact ? lower === name : lower.includes(name)) {
+      out.push(s);
+      if (out.length >= limit) break;
+    }
+  }
+  return out;
+}
+function getOutline(index, file) {
+  const abs = path.resolve(file);
+  return index.symbols.filter((s) => s.location.file === abs).sort((a, b) => a.location.line - b.location.line).map((s) => ({
+    name: s.name,
+    kind: s.kind,
+    line: s.location.line,
+    signature: s.signature,
+    container: s.container,
+    exported: s.exported
+  }));
+}
+function findReferences(index, name, opts = {}) {
+  const maxFiles = opts.maxFiles ?? 2e3;
+  const maxHits = opts.maxHits ?? 500;
+  const re = new RegExp(`\\b${name.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}\\b`);
+  const hits = [];
+  const files = Object.keys(index.files).slice(0, maxFiles);
+  for (const file of files) {
+    let content;
+    try {
+      content = fs.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    if (!re.test(content)) continue;
+    const lines = content.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+      const m = re.exec(lines[i]);
+      if (m) {
+        hits.push({
+          file,
+          line: i + 1,
+          column: m.index,
+          text: lines[i].trim().slice(0, 200)
+        });
+        if (hits.length >= maxHits) return hits;
+      }
+    }
+  }
+  return hits;
+}
+
+// src/tools/builtin/symbol-tools.ts
+var NO_INDEX_HINT = "No symbol index exists for this project yet. Ask the user to run `/index rebuild`, or call indexProject() first. Alternatively, use grep_files for a slower fallback.";
+async function ensureIndex(root, autoBuild) {
+  let index = loadIndex(root);
+  if (!index && autoBuild) {
+    const result = await indexProject(root);
+    index = result.index;
+  }
+  return index;
+}
+var findSymbolTool = {
+  definition: {
+    name: "find_symbol",
+    description: "Locate symbol definitions (functions, classes, methods, interfaces, types, variables) across the project using the pre-built symbol index. Orders of magnitude faster than grep_files for definition lookups. Returns file:line locations plus a one-line signature.",
+    parameters: {
+      name: {
+        type: "string",
+        description: 'Symbol name to find (e.g. "handleChat", "ProviderRegistry")',
+        required: true
+      },
+      exact: {
+        type: "boolean",
+        description: "Exact match (default true). When false, substring match (case-insensitive).",
+        required: false
+      },
+      kind: {
+        type: "string",
+        description: "Restrict to one kind: function, method, class, interface, type, enum, variable, property. Omit to search all.",
+        required: false
+      },
+      path: {
+        type: "string",
+        description: "Project root (defaults to current working directory).",
+        required: false
+      },
+      limit: {
+        type: "number",
+        description: "Max results (default 50).",
+        required: false
+      }
+    }
+  },
+  async execute(args) {
+    const name = String(args.name ?? "").trim();
+    if (!name) return "Error: `name` is required.";
+    const root = path2.resolve(String(args.path ?? process.cwd()));
+    const index = await ensureIndex(root, true);
+    if (!index) return NO_INDEX_HINT;
+    const kindArg = args.kind ? String(args.kind) : void 0;
+    const hits = findSymbol(index, {
+      name,
+      exact: args.exact !== false,
+      kind: kindArg,
+      limit: typeof args.limit === "number" ? args.limit : 50
+    });
+    if (hits.length === 0) {
+      return `No symbol matching "${name}" found (index has ${index.symbolCount} symbols across ${index.fileCount} files).`;
+    }
+    const lines = hits.map((s) => {
+      const rel = path2.relative(index.root, s.location.file) || s.location.file;
+      const container = s.container ? ` (in ${s.container})` : "";
+      const exp = s.exported ? " [exported]" : "";
+      const sig = s.signature ? `
+    ${s.signature}` : "";
+      return `${s.kind} ${s.name}${container}${exp} \u2014 ${rel}:${s.location.line}${sig}`;
+    });
+    return `Found ${hits.length} symbol(s):
+${lines.join("\n")}`;
+  }
+};
+var getOutlineTool = {
+  definition: {
+    name: "get_outline",
+    description: "Return the complete list of top-level declarations in a single source file (classes, functions, methods, types), sorted by line number. Use this to understand file structure without reading its full contents.",
+    parameters: {
+      file: {
+        type: "string",
+        description: "Path to the source file (absolute, or relative to project root).",
+        required: true
+      },
+      path: {
+        type: "string",
+        description: "Project root (defaults to current working directory).",
+        required: false
+      }
+    }
+  },
+  async execute(args) {
+    const file = String(args.file ?? "").trim();
+    if (!file) return "Error: `file` is required.";
+    const root = path2.resolve(String(args.path ?? process.cwd()));
+    const absFile = path2.isAbsolute(file) ? file : path2.resolve(root, file);
+    const index = await ensureIndex(root, true);
+    if (!index) return NO_INDEX_HINT;
+    const outline = getOutline(index, absFile);
+    if (outline.length === 0) {
+      return `No indexed symbols found for ${path2.relative(root, absFile) || absFile}. The file may be of an unsupported language (supported: TS/JS/TSX/JSX/Python), unreadable, or not yet re-indexed.`;
+    }
+    const rel = path2.relative(root, absFile) || absFile;
+    const lines = outline.map((o) => {
+      const container = o.container ? ` (in ${o.container})` : "";
+      const exp = o.exported ? " [exported]" : "";
+      return `  ${String(o.line).padStart(5)}: ${o.kind} ${o.name}${container}${exp}`;
+    });
+    return `Outline of ${rel} (${outline.length} symbols):
+${lines.join("\n")}`;
+  }
+};
+var findReferencesTool = {
+  definition: {
+    name: "find_references",
+    description: "Find all textual references to a symbol name across indexed files (whole-word match). MVP: regex-based \u2014 may include unrelated identifiers with the same name. Pair with find_symbol to locate the definition.",
+    parameters: {
+      name: {
+        type: "string",
+        description: "Symbol name to find references for.",
+        required: true
+      },
+      path: {
+        type: "string",
+        description: "Project root (defaults to current working directory).",
+        required: false
+      },
+      max_hits: {
+        type: "number",
+        description: "Max reference hits to return (default 200).",
+        required: false
+      }
+    }
+  },
+  async execute(args) {
+    const name = String(args.name ?? "").trim();
+    if (!name) return "Error: `name` is required.";
+    const root = path2.resolve(String(args.path ?? process.cwd()));
+    const index = await ensureIndex(root, true);
+    if (!index) return NO_INDEX_HINT;
+    const maxHits = typeof args.max_hits === "number" ? args.max_hits : 200;
+    const hits = findReferences(index, name, { maxHits });
+    if (hits.length === 0) {
+      return `No references to "${name}" found in ${index.fileCount} indexed files.`;
+    }
+    const lines = hits.map((h) => {
+      const rel = path2.relative(index.root, h.file) || h.file;
+      return `${rel}:${h.line}:${h.column}  ${h.text}`;
+    });
+    return `Found ${hits.length} reference(s) to "${name}":
+${lines.join("\n")}`;
+  }
+};
+var searchCodeTool = {
+  definition: {
+    name: "search_code",
+    description: 'Semantic (meaning-based) search across indexed code symbols using local sentence embeddings. Use this when you do NOT know the exact symbol name \u2014 it finds code by purpose, e.g. "rate limiting logic", "where users are authenticated", "error recovery retry loops". Returns ranked matches with similarity scores. Requires a prior `/index semantic-rebuild` to build embeddings (one-time 117 MB model download + a few seconds per 1K symbols). For exact name lookups use find_symbol instead.',
+    parameters: {
+      query: {
+        type: "string",
+        description: "Natural-language description of the code you're looking for. English or Chinese both work.",
+        required: true
+      },
+      k: {
+        type: "number",
+        description: "Max results to return (default 10, max 50).",
+        required: false
+      },
+      kind: {
+        type: "string",
+        description: "Restrict to one symbol kind: function, method, class, interface, type, enum, variable, property. Omit to search all.",
+        required: false
+      },
+      path: {
+        type: "string",
+        description: "Project root (defaults to current working directory).",
+        required: false
+      }
+    }
+  },
+  async execute(args) {
+    const query = String(args.query ?? "").trim();
+    if (!query) return "Error: `query` is required.";
+    const root = path2.resolve(String(args.path ?? process.cwd()));
+    const k = Math.min(50, Math.max(1, typeof args.k === "number" ? args.k : 10));
+    const kindFilter = args.kind ? String(args.kind) : void 0;
+    if (!hasSemanticIndex(root)) {
+      return "No semantic index exists for this project yet. Ask the user to run `/index semantic-rebuild` (first run downloads a ~117 MB embedding model; subsequent rebuilds are fast). As a fallback, use grep_files or find_symbol for literal-name lookups.";
+    }
+    let hits;
+    try {
+      const oversampled = await semanticSearch(root, query, kindFilter ? k * 4 : k);
+      hits = kindFilter ? oversampled.filter((h) => h.symbol.kind === kindFilter).slice(0, k) : oversampled;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return `Semantic search failed: ${msg}`;
+    }
+    if (hits.length === 0) {
+      return `No semantic matches found for "${query}". Try a different phrasing, or run \`/index semantic-rebuild\` if the codebase has changed significantly.`;
+    }
+    const lines = hits.map((h) => {
+      const s = h.symbol;
+      const rel = path2.relative(root, s.location.file) || s.location.file;
+      const container = s.container ? ` (in ${s.container})` : "";
+      const exp = s.exported ? " [exported]" : "";
+      const score = h.score.toFixed(3);
+      const sig = s.signature ? `
+    ${s.signature}` : "";
+      return `[score=${score}] ${s.kind} ${s.name}${container}${exp} \u2014 ${rel}:${s.location.line}${sig}`;
+    });
+    return `Top ${hits.length} semantic match(es) for "${query}":
+${lines.join("\n")}`;
+  }
+};
+
 // src/core/token-estimator.ts
 var CJK_REGEX = /[\u2E80-\u9FFF\uA000-\uA4FF\uAC00-\uD7FF\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFFEF]/g;
 function estimateTokens(text) {
@@ -4341,6 +4633,10 @@ var ToolRegistry = class {
     this.register(gitLogTool);
     this.register(gitCommitTool);
     this.register(notebookEditTool);
+    this.register(findSymbolTool);
+    this.register(getOutlineTool);
+    this.register(findReferencesTool);
+    this.register(searchCodeTool);
   }
   register(tool) {
     this.tools.set(tool.definition.name, tool);

package/dist/{chunk-ASNDBI5R.js → chunk-LQ76WLB6.js}

@@ -8,7 +8,7 @@ import {
   CONFIG_FILE_NAME,
   HISTORY_DIR_NAME,
   PLUGINS_DIR_NAME
-} from "./chunk-5P4QTZBI.js";
+} from "./chunk-S4WDPHKS.js";
 
 // src/config/config-manager.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";