jinzd-ai-cli 0.4.141 → 0.4.143

package/dist/{chunk-NHNWUBXB.js → chunk-VNNYHW6N.js}

@@ -6,7 +6,7 @@ import {
   removeFile,
   saveIndex,
   upsertFileSymbols
-} from "./chunk-6VRJGH25.js";
+} from "./chunk-OVWE4E46.js";
 
 // src/symbols/indexer.ts
 import fs2 from "fs";
@@ -30,7 +30,11 @@ var GRAMMAR_FILE = {
   typescript: "tree-sitter-typescript.wasm",
   tsx: "tree-sitter-tsx.wasm",
   javascript: "tree-sitter-javascript.wasm",
-  python: "tree-sitter-python.wasm"
+  python: "tree-sitter-python.wasm",
+  go: "tree-sitter-go.wasm",
+  rust: "tree-sitter-rust.wasm",
+  java: "tree-sitter-java.wasm",
+  cpp: "tree-sitter-cpp.wasm"
 };
 var RUNTIME_WASM = "web-tree-sitter.wasm";
 var parserInitPromise = null;
@@ -271,6 +275,253 @@ function extractPython(root, file) {
   visit(root, void 0, true);
   return out;
 }
+function extractGo(root, file) {
+  const out = [];
+  const isExported = (name) => /^[A-Z]/.test(name);
+  const pushTypeSpec = (spec) => {
+    const name = nameOf(spec);
+    if (!name) return;
+    const typeNode = childByFieldName(spec, "type");
+    let kind = "type";
+    if (typeNode?.type === "struct_type") kind = "class";
+    else if (typeNode?.type === "interface_type") kind = "interface";
+    out.push({
+      name,
+      kind,
+      language: "go",
+      location: locationOf(file, spec),
+      signature: firstLine(spec.text),
+      exported: isExported(name)
+    });
+  };
+  for (const child of root.children) {
+    if (!child) continue;
+    if (child.type === "function_declaration") {
+      const name = nameOf(child);
+      if (name) out.push({ name, kind: "function", language: "go", location: locationOf(file, child), signature: firstLine(child.text), exported: isExported(name) });
+    } else if (child.type === "method_declaration") {
+      const name = nameOf(child);
+      if (!name) continue;
+      const receiver = childByFieldName(child, "receiver");
+      let container;
+      if (receiver) {
+        const paramDecl = receiver.children.find((c) => c?.type === "parameter_declaration");
+        const typeNode = paramDecl ? childByFieldName(paramDecl, "type") : null;
+        if (typeNode) {
+          container = typeNode.text.replace(/^\*/, "").trim();
+        }
+      }
+      out.push({ name, kind: "method", language: "go", location: locationOf(file, child), signature: firstLine(child.text), container, exported: isExported(name) });
+    } else if (child.type === "type_declaration") {
+      for (const spec of child.children) {
+        if (spec?.type === "type_spec" || spec?.type === "type_alias") pushTypeSpec(spec);
+      }
+    } else if (child.type === "const_declaration" || child.type === "var_declaration") {
+      for (const spec of child.children) {
+        if (spec?.type !== "const_spec" && spec?.type !== "var_spec") continue;
+        for (const id of spec.children) {
+          if (id?.type !== "identifier") continue;
+          out.push({ name: id.text, kind: "variable", language: "go", location: locationOf(file, spec), signature: firstLine(spec.text), exported: isExported(id.text) });
+        }
+      }
+    }
+  }
+  return out;
+}
+function extractRust(root, file) {
+  const out = [];
+  const isPub = (node) => node.children.some((c) => c?.type === "visibility_modifier" && c.text.startsWith("pub"));
+  const visit = (node, container) => {
+    const kindMap = {
+      function_item: container ? "method" : "function",
+      struct_item: "class",
+      union_item: "class",
+      enum_item: "enum",
+      trait_item: "interface",
+      type_item: "type",
+      const_item: "variable",
+      static_item: "variable",
+      macro_definition: "function",
+      mod_item: "module"
+    };
+    const kind = kindMap[node.type];
+    if (kind) {
+      const name = nameOf(node);
+      if (name) {
+        out.push({ name, kind, language: "rust", location: locationOf(file, node), signature: firstLine(node.text), container, exported: isPub(node) });
+        if (node.type === "mod_item") {
+          const body = childByFieldName(node, "body");
+          if (body) for (const c of body.children) {
+            if (c) visit(c, name);
+          }
+        }
+      }
+      return;
+    }
+    if (node.type === "impl_item") {
+      const typeNode = childByFieldName(node, "type");
+      const implContainer = typeNode?.text.trim();
+      const body = childByFieldName(node, "body");
+      if (body) for (const c of body.children) {
+        if (c) visit(c, implContainer);
+      }
+      return;
+    }
+    if (node.type === "source_file" || node.type === "declaration_list") {
+      for (const c of node.children) {
+        if (c) visit(c, container);
+      }
+    }
+  };
+  visit(root, void 0);
+  return out;
+}
+function extractJava(root, file) {
+  const out = [];
+  const isPublic = (node) => {
+    const mods = node.children.find((c) => c?.type === "modifiers");
+    return !!mods && mods.children.some((c) => c?.type === "public" || c?.text === "public");
+  };
+  const visit = (node, container) => {
+    const containerKindMap = {
+      class_declaration: "class",
+      interface_declaration: "interface",
+      enum_declaration: "enum",
+      record_declaration: "class",
+      annotation_type_declaration: "interface"
+    };
+    const containerKind = containerKindMap[node.type];
+    if (containerKind) {
+      const name = nameOf(node);
+      if (name) {
+        out.push({ name, kind: containerKind, language: "java", location: locationOf(file, node), signature: firstLine(node.text), container, exported: isPublic(node) });
+        const body = node.children.find((c) => c?.type === "class_body" || c?.type === "interface_body" || c?.type === "enum_body" || c?.type === "record_body" || c?.type === "annotation_type_body");
+        if (body) for (const c of body.children) {
+          if (c) visit(c, name);
+        }
+      }
+      return;
+    }
+    if (node.type === "method_declaration" || node.type === "constructor_declaration" || node.type === "compact_constructor_declaration") {
+      const name = nameOf(node);
+      if (name) out.push({ name, kind: "method", language: "java", location: locationOf(file, node), signature: firstLine(node.text), container, exported: isPublic(node) });
+      return;
+    }
+    if (node.type === "field_declaration") {
+      const exported = isPublic(node);
+      for (const c of node.children) {
+        if (c?.type !== "variable_declarator") continue;
+        const id = childByFieldName(c, "name");
+        if (id?.type === "identifier") out.push({ name: id.text, kind: "property", language: "java", location: locationOf(file, c), signature: firstLine(node.text), container, exported });
+      }
+      return;
+    }
+    if (node.type === "program") {
+      for (const c of node.children) {
+        if (c) visit(c, container);
+      }
+    }
+  };
+  visit(root, void 0);
+  return out;
+}
+function extractCpp(root, file) {
+  const out = [];
+  const declaratorName = (decl) => {
+    if (!decl) return null;
+    if (decl.type === "identifier" || decl.type === "field_identifier" || decl.type === "type_identifier") {
+      return { name: decl.text };
+    }
+    if (decl.type === "qualified_identifier") {
+      const text = decl.text;
+      const idx = text.lastIndexOf("::");
+      if (idx >= 0) return { name: text.slice(idx + 2), container: text.slice(0, idx) };
+      return { name: text };
+    }
+    if (decl.type === "destructor_name" || decl.type === "operator_name") {
+      return { name: decl.text };
+    }
+    const inner = childByFieldName(decl, "declarator");
+    if (inner) return declaratorName(inner);
+    return null;
+  };
+  const visit = (node, container) => {
+    if (node.type === "template_declaration") {
+      for (const c of node.children) {
+        if (c && (c.type === "function_definition" || c.type === "class_specifier" || c.type === "struct_specifier" || c.type === "declaration")) {
+          visit(c, container);
+        }
+      }
+      return;
+    }
+    if (node.type === "function_definition") {
+      const decl = childByFieldName(node, "declarator");
+      const info = declaratorName(decl);
+      if (info) {
+        const finalContainer = info.container ?? container;
+        out.push({
+          name: info.name,
+          kind: finalContainer ? "method" : "function",
+          language: "cpp",
+          location: locationOf(file, node),
+          signature: firstLine(node.text),
+          container: finalContainer
+        });
+      }
+      return;
+    }
+    const specMap = {
+      class_specifier: "class",
+      struct_specifier: "class",
+      union_specifier: "class",
+      enum_specifier: "enum"
+    };
+    const specKind = specMap[node.type];
+    if (specKind) {
+      const name = nameOf(node);
+      if (name) {
+        out.push({ name, kind: specKind, language: "cpp", location: locationOf(file, node), signature: firstLine(node.text), container });
+        const body = node.children.find((c) => c?.type === "field_declaration_list" || c?.type === "enumerator_list");
+        if (body) for (const c of body.children) {
+          if (c) visit(c, name);
+        }
+      }
+      return;
+    }
+    if (node.type === "namespace_definition") {
+      const name = nameOf(node) ?? "<anonymous>";
+      out.push({ name, kind: "module", language: "cpp", location: locationOf(file, node), signature: firstLine(node.text), container });
+      const body = childByFieldName(node, "body");
+      if (body) for (const c of body.children) {
+        if (c) visit(c, name);
+      }
+      return;
+    }
+    if (node.type === "type_definition" || node.type === "alias_declaration") {
+      const decl = node.children[node.children.length - 1];
+      const info = decl ? declaratorName(decl) : null;
+      if (info) out.push({ name: info.name, kind: "type", language: "cpp", location: locationOf(file, node), signature: firstLine(node.text), container });
+      return;
+    }
+    if (node.type === "field_declaration" && container) {
+      const hasFn = node.children.some((c) => c?.type === "function_declarator" || c?.type === "pointer_declarator" && c.children.some((x) => x?.type === "function_declarator"));
+      if (hasFn) return;
+      for (const c of node.children) {
+        if (c?.type === "field_identifier") {
+          out.push({ name: c.text, kind: "property", language: "cpp", location: locationOf(file, node), signature: firstLine(node.text), container });
+        }
+      }
+      return;
+    }
+    if (node.type === "translation_unit" || node.type === "declaration_list" || node.type === "linkage_specification") {
+      for (const c of node.children) {
+        if (c) visit(c, container);
+      }
+    }
+  };
+  visit(root, void 0);
+  return out;
+}
 async function parseSource(file, source, language) {
   const lang = language ?? detectLanguage(path2.extname(file).slice(1));
   if (!lang) return [];
@@ -279,8 +530,20 @@ async function parseSource(file, source, language) {
     const tree = parser.parse(source);
     if (!tree) return [];
     const root = tree.rootNode;
-    if (lang === "python") return extractPython(root, file);
-    return extractTsJs(root, file, lang);
+    switch (lang) {
+      case "python":
+        return extractPython(root, file);
+      case "go":
+        return extractGo(root, file);
+      case "rust":
+        return extractRust(root, file);
+      case "java":
+        return extractJava(root, file);
+      case "cpp":
+        return extractCpp(root, file);
+      default:
+        return extractTsJs(root, file, lang);
+    }
   } catch (err) {
     return [];
   }
@@ -304,7 +567,15 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "venv",
   ".idea",
   ".vscode",
-  "release"
+  "release",
+  "target",
+  // Rust (cargo build) + Java (Maven)
+  "vendor",
+  // Go (vendored deps)
+  ".gradle",
+  // Java (Gradle)
+  "cmake-build-debug",
+  "cmake-build-release"
 ]);
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
 function collectFiles(root, maxFiles) {

package/dist/{chunk-WLS4PIFK.js → chunk-VXFBUMWG.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/core/constants.ts
-var VERSION = "0.4.141";
+var VERSION = "0.4.143";
 var APP_NAME = "ai-cli";
 var CONFIG_DIR_NAME = ".aicli";
 var CONFIG_FILE_NAME = "config.json";

package/dist/{chunk-QICXUOA4.js → chunk-YCIJZ2XS.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   schemaToJsonSchema
-} from "./chunk-4OKDU4U6.js";
+} from "./chunk-2JLVHUMU.js";
 import {
   AuthError,
   ProviderError,
@@ -1275,19 +1275,21 @@ var OpenAICompatibleProvider = class extends BaseProvider {
         if (delta?.tool_calls) {
           for (const tc of delta.tool_calls) {
             const idx = tc.index;
-            if (tc.id && tc.function?.name) {
+            const existing = toolCallAccumulators.get(idx);
+            if (!existing && tc.id && tc.function?.name) {
+              const initialArgs = tc.function.arguments ?? "";
               toolCallAccumulators.set(idx, {
                 id: tc.id,
                 name: tc.function.name,
-                arguments: tc.function.arguments ?? ""
+                arguments: initialArgs
               });
               yield { type: "tool_call_start", index: idx, id: tc.id, name: tc.function.name };
-            } else if (tc.function?.arguments) {
-              const acc = toolCallAccumulators.get(idx);
-              if (acc) {
-                acc.arguments += tc.function.arguments;
-                yield { type: "tool_call_delta", index: idx, argumentsDelta: tc.function.arguments };
+              if (initialArgs) {
+                yield { type: "tool_call_delta", index: idx, argumentsDelta: initialArgs };
               }
+            } else if (existing && tc.function?.arguments) {
+              existing.arguments += tc.function.arguments;
+              yield { type: "tool_call_delta", index: idx, argumentsDelta: tc.function.arguments };
             }
           }
         }

package/dist/{chunk-GJJFXCV2.js → chunk-YPFCJ5KC.js}

@@ -2,15 +2,15 @@
 import {
   hasSemanticIndex,
   semanticSearch
-} from "./chunk-3BICTI5M.js";
+} from "./chunk-UQQJWHRV.js";
 import {
   runTestsTool
-} from "./chunk-EMG2MOZU.js";
+} from "./chunk-IMYOBDJG.js";
 import {
   getDangerLevel,
   isFileWriteTool,
   runTool
-} from "./chunk-4OKDU4U6.js";
+} from "./chunk-2JLVHUMU.js";
 import {
   EnvLoader,
   NetworkError,
@@ -23,7 +23,7 @@ import {
   SUBAGENT_ALLOWED_TOOLS,
   SUBAGENT_DEFAULT_MAX_ROUNDS,
   SUBAGENT_MAX_ROUNDS_LIMIT
-} from "./chunk-WLS4PIFK.js";
+} from "./chunk-VXFBUMWG.js";
 import {
   fileCheckpoints
 } from "./chunk-4BKXL7SM.js";
@@ -33,10 +33,10 @@ import {
 } from "./chunk-7ZJN4KLV.js";
 import {
   indexProject
-} from "./chunk-NHNWUBXB.js";
+} from "./chunk-VNNYHW6N.js";
 import {
   loadIndex
-} from "./chunk-6VRJGH25.js";
+} from "./chunk-OVWE4E46.js";
 
 // src/tools/builtin/bash.ts
 import { spawn } from "child_process";
@@ -2056,7 +2056,7 @@ Do NOT split a long document into many write_file(append=true) calls. That patte
     const mode = appendMode ? "appended" : "written";
     void (async () => {
       try {
-        const { updateFile } = await import("./indexer-XGY7XGJM.js");
+        const { updateFile } = await import("./indexer-S6UMGQKA.js");
         await updateFile(process.cwd(), filePath);
       } catch {
       }

package/dist/{constants-E3TCQFXP.js → constants-YVTEGGKB.js}

@@ -36,7 +36,7 @@ import {
   TEST_TIMEOUT,
   VERSION,
   buildUserIdentityPrompt
-} from "./chunk-WLS4PIFK.js";
+} from "./chunk-VXFBUMWG.js";
 import "./chunk-PDX44BCA.js";
 export {
   AGENTIC_BEHAVIOR_GUIDELINE,

package/dist/{doctor-cli-6EM7NIRC.js → doctor-cli-EGD6OLJO.js}

@@ -2,25 +2,25 @@
 import {
   getConfigDirUsage,
   listRecentCrashes
-} from "./chunk-4EUYGWBJ.js";
+} from "./chunk-CSWA553M.js";
 import {
   ProviderRegistry
-} from "./chunk-QICXUOA4.js";
+} from "./chunk-YCIJZ2XS.js";
 import {
   ConfigManager
-} from "./chunk-TQVNVZU6.js";
+} from "./chunk-DX5JYNVN.js";
 import {
   getStatsSnapshot,
   getTopFailingTools,
   getTopUsedTools,
   resetStats
-} from "./chunk-4OKDU4U6.js";
+} from "./chunk-2JLVHUMU.js";
 import "./chunk-2ZD3YTVM.js";
 import {
   DEV_STATE_FILE_NAME,
   MEMORY_FILE_NAME,
   VERSION
-} from "./chunk-WLS4PIFK.js";
+} from "./chunk-VXFBUMWG.js";
 import "./chunk-PDX44BCA.js";
 
 // src/diagnostics/doctor-cli.ts

package/dist/electron-server.js

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SKET65WZ.js";
 import {
   indexProject
-} from "./chunk-RFQVUMDB.js";
+} from "./chunk-SEFOKYYP.js";
 import {
   AGENTIC_BEHAVIOR_GUIDELINE,
   APP_NAME,
@@ -36,14 +36,14 @@ import {
   VERSION,
   buildUserIdentityPrompt,
   runTestsTool
-} from "./chunk-KQTMR64X.js";
+} from "./chunk-2YEBAHAB.js";
 import {
   hasSemanticIndex,
   semanticSearch
-} from "./chunk-MO7MWNWC.js";
+} from "./chunk-NKR53CPL.js";
 import {
   loadIndex
-} from "./chunk-BJAT4GNC.js";
+} from "./chunk-DQ2OHJNF.js";
 import "./chunk-PASCDYMH.js";
 import {
   loadChatIndex,
@@ -1884,19 +1884,21 @@ var OpenAICompatibleProvider = class extends BaseProvider {
         if (delta?.tool_calls) {
           for (const tc of delta.tool_calls) {
             const idx = tc.index;
-            if (tc.id && tc.function?.name) {
+            const existing = toolCallAccumulators.get(idx);
+            if (!existing && tc.id && tc.function?.name) {
+              const initialArgs = tc.function.arguments ?? "";
               toolCallAccumulators.set(idx, {
                 id: tc.id,
                 name: tc.function.name,
-                arguments: tc.function.arguments ?? ""
+                arguments: initialArgs
               });
               yield { type: "tool_call_start", index: idx, id: tc.id, name: tc.function.name };
-            } else if (tc.function?.arguments) {
-              const acc = toolCallAccumulators.get(idx);
-              if (acc) {
-                acc.arguments += tc.function.arguments;
-                yield { type: "tool_call_delta", index: idx, argumentsDelta: tc.function.arguments };
+              if (initialArgs) {
+                yield { type: "tool_call_delta", index: idx, argumentsDelta: initialArgs };
               }
+            } else if (existing && tc.function?.arguments) {
+              existing.arguments += tc.function.arguments;
+              yield { type: "tool_call_delta", index: idx, argumentsDelta: tc.function.arguments };
             }
           }
         }
@@ -5787,7 +5789,7 @@ Do NOT split a long document into many write_file(append=true) calls. That patte
     const mode = appendMode ? "appended" : "written";
     void (async () => {
       try {
-        const { updateFile } = await import("./indexer-Z6AQTGBK.js");
+        const { updateFile } = await import("./indexer-ISSNIFQY.js");
         await updateFile(process.cwd(), filePath);
       } catch {
       }
@@ -12308,8 +12310,8 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       case "index": {
         const sub = (args[0] ?? "status").toLowerCase();
         const root = process.cwd();
-        const { loadIndex: loadIndex2, clearIndex } = await import("./store-Q7NMUCPP.js");
-        const { indexProject: indexProject2 } = await import("./indexer-Z6AQTGBK.js");
+        const { loadIndex: loadIndex2, clearIndex } = await import("./store-A3TZM6PS.js");
+        const { indexProject: indexProject2 } = await import("./indexer-ISSNIFQY.js");
         const { loadVectorStore, clearVectorStore } = await import("./vector-store-AK6J3RIA.js");
         if (sub === "status") {
           const idx = loadIndex2(root);
@@ -12359,7 +12361,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
             message: `Building semantic index for ${idx.symbolCount} symbols\u2026 (first run downloads ~117 MB model)`
           });
           try {
-            const { rebuildSemanticIndex } = await import("./semantic-FR2ZSQLY.js");
+            const { rebuildSemanticIndex } = await import("./semantic-IJKF5ZZC.js");
             const stats = await rebuildSemanticIndex(root);
             const first = stats.modelFirstLoadMs ? ` (model load+first batch ${stats.modelFirstLoadMs}ms)` : "";
             this.send({
@@ -12546,7 +12548,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       case "test": {
         this.send({ type: "info", message: "\u{1F9EA} Running tests..." });
         try {
-          const { executeTests } = await import("./run-tests-JIJQPL6S.js");
+          const { executeTests } = await import("./run-tests-VK2S7V3X.js");
           const argStr = args.join(" ").trim();
           let testArgs = {};
           if (argStr) {

package/dist/{hub-3T6VKVP2.js → hub-YNT2PVCA.js}

@@ -386,7 +386,7 @@ ${content}`);
   }
 }
 async function runTaskMode(config, providers, configManager, topic) {
-  const { TaskOrchestrator } = await import("./task-orchestrator-Y3EKYGZF.js");
+  const { TaskOrchestrator } = await import("./task-orchestrator-E46H7NUK.js");
   const orchestrator = new TaskOrchestrator(config, providers, configManager);
   let interrupted = false;
   const onSigint = () => {