jinzd-ai-cli 0.4.76 → 0.4.78

package/dist/{chunk-34NJTPWZ.js → chunk-TNAPORYF.js}

@@ -6,7 +6,7 @@ import { platform } from "os";
 import chalk from "chalk";
 
 // src/core/constants.ts
-var VERSION = "0.4.76";
+var VERSION = "0.4.78";
 var APP_NAME = "ai-cli";
 var CONFIG_DIR_NAME = ".aicli";
 var CONFIG_FILE_NAME = "config.json";
@@ -41,8 +41,10 @@ var PLAN_MODE_READONLY_TOOLS = /* @__PURE__ */ new Set([
   // C1 symbol index (read-only)
   "get_outline",
   // C1 symbol index (read-only)
-  "find_references"
+  "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
 
@@ -85,7 +87,8 @@ var SUBAGENT_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
   "run_tests",
   "find_symbol",
   "get_outline",
-  "find_references"
+  "find_references",
+  "search_code"
 ]);
 var TEST_TIMEOUT = 3e5;
 var AGENTIC_BEHAVIOR_GUIDELINE = `# Important Behavioral Guidelines

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
+};

package/dist/chunk-XMA222FQ.js

@@ -0,0 +1,167 @@
+// 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
+};