jinzd-ai-cli 0.4.76 → 0.4.78

package/README.md

@@ -30,6 +30,7 @@
 - **Web UI Session Replay** *(v0.4.71+)* — 🎬 button on every saved session opens a timeline replay: every message, tool call, reasoning, and cache-aware token usage at a glance
 - **Conversation Branching** *(v0.4.74+)* — `/branch list/new/switch/delete/rename` inside the REPL, plus a 🌿 "fork here" button on every replay step — explore alternate directions without losing the original thread
 - **Symbol Index** *(v0.4.76+)* — persistent tree-sitter index for TS/JS/TSX/Python powers three new AI tools: `find_symbol`, `get_outline`, `find_references`. Orders of magnitude faster than grep for definition lookups; background refresh on REPL startup, `/index status|rebuild|clear` to manage
+- **Semantic Code Search** *(v0.4.77+)* — `search_code` tool finds code by meaning, not name. Local sentence embeddings (multilingual MiniLM, 117 MB one-time download) score symbols by cosine similarity against natural-language queries in English or Chinese ("where are users authenticated", "哪里做了速率限制"). No API key, runs on CPU. Manage with `/index semantic-rebuild|semantic-clear`
 - **Streaming Tool Use** — Real-time streaming of AI reasoning and tool calls as they happen
 - **Sub-Agents** — Delegate complex subtasks to isolated child agents with independent tool loops
 - **Extended Thinking** — Claude deep reasoning mode with `/think` toggle
@@ -177,6 +178,7 @@ AI autonomously invokes these 27 tools during conversations:
 | `find_symbol` | safe | Locate symbol definitions via persistent tree-sitter index (TS/JS/TSX/Python) |
 | `get_outline` | safe | Enumerate all top-level declarations in one source file |
 | `find_references` | safe | Search indexed files for references to a symbol name |
+| `search_code` | safe | Semantic (meaning-based) code search via local sentence embeddings — bilingual, "grep by meaning" |
 
 **Safety levels**: `safe` = auto-execute, `write` = diff preview + confirmation, `destructive` = prominent warning + confirmation.
 
@@ -199,7 +201,7 @@ AI autonomously invokes these 27 tools during conversations:
 | `/checkpoint` | Save/restore conversation checkpoints |
 | `/fork` | Fork the current session into a new session file |
 | `/branch` | Create/switch/delete branches *within* the current session (B2) |
-| `/index` | Manage tree-sitter symbol index (status/rebuild/clear) — powers `find_symbol` / `get_outline` / `find_references` (C1) |
+| `/index` | Manage symbol + semantic index (status/rebuild/clear/semantic-rebuild/semantic-clear) — powers `find_symbol` / `get_outline` / `find_references` / `search_code` (C1+C2) |
 | `/search <keyword>` | Full-text search across all sessions |
 | `/skill` | Manage agent skill packs |
 | `/mcp` | View MCP server status and tools |

package/dist/batch-CDCTUTIQ.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import {
+  ConfigManager
+} from "./chunk-FCVQ6OP5.js";
+import "./chunk-2ZD3YTVM.js";
+import "./chunk-HELGL4RH.js";
+
+// src/cli/batch.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+function parseBatchInput(jsonl) {
+  const lines = jsonl.split("\n").map((l) => l.trim()).filter(Boolean);
+  if (lines.length === 0) throw new Error("Input file is empty");
+  if (lines.length > 1e5) throw new Error(`Too many requests: ${lines.length} (Anthropic limit: 100000)`);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch (err) {
+      throw new Error(`Line ${i + 1}: invalid JSON (${err instanceof Error ? err.message : String(err)})`);
+    }
+    if (!obj || typeof obj !== "object") {
+      throw new Error(`Line ${i + 1}: expected JSON object`);
+    }
+    const rec = obj;
+    const customId = String(rec.customId ?? rec.custom_id ?? "");
+    if (!customId) throw new Error(`Line ${i + 1}: missing customId`);
+    if (!/^[A-Za-z0-9_-]{1,64}$/.test(customId)) {
+      throw new Error(`Line ${i + 1}: customId "${customId}" must be 1-64 chars of [A-Za-z0-9_-]`);
+    }
+    if (seen.has(customId)) throw new Error(`Line ${i + 1}: duplicate customId "${customId}"`);
+    seen.add(customId);
+    const messages = rec.messages;
+    if (!Array.isArray(messages) || messages.length === 0) {
+      throw new Error(`Line ${i + 1}: messages must be a non-empty array`);
+    }
+    for (let j = 0; j < messages.length; j++) {
+      const m = messages[j];
+      if (!m || m.role !== "user" && m.role !== "assistant") {
+        throw new Error(`Line ${i + 1}: messages[${j}].role must be 'user' or 'assistant'`);
+      }
+      if (typeof m.content !== "string") {
+        throw new Error(`Line ${i + 1}: messages[${j}].content must be a string`);
+      }
+    }
+    out.push({
+      customId,
+      messages,
+      model: typeof rec.model === "string" ? rec.model : void 0,
+      system: typeof rec.system === "string" ? rec.system : void 0,
+      maxTokens: typeof rec.maxTokens === "number" ? rec.maxTokens : typeof rec.max_tokens === "number" ? rec.max_tokens : void 0
+    });
+  }
+  return out;
+}
+function getBatchesPath(config) {
+  return join(config.getConfigDir(), "batches.json");
+}
+function loadTrackedBatches(config) {
+  const p = getBatchesPath(config);
+  if (!existsSync(p)) return [];
+  try {
+    const data = JSON.parse(readFileSync(p, "utf-8"));
+    return Array.isArray(data.batches) ? data.batches : [];
+  } catch {
+    return [];
+  }
+}
+function saveTrackedBatches(config, batches) {
+  mkdirSync(config.getConfigDir(), { recursive: true });
+  writeFileSync(getBatchesPath(config), JSON.stringify({ batches }, null, 2), "utf-8");
+}
+function getClaudeClient(config) {
+  const apiKey = config.getApiKey("claude");
+  if (!apiKey) {
+    throw new Error("No Claude API key configured. Run `aicli config` or set AICLI_API_KEY_CLAUDE.");
+  }
+  return new Anthropic({ apiKey });
+}
+function getDefaultModel(config) {
+  const models = config.get("defaultModels");
+  return models?.claude ?? "claude-sonnet-4-5-20250929";
+}
+async function cmdSubmit(inputFile, options = {}) {
+  const config = new ConfigManager();
+  if (!existsSync(inputFile)) throw new Error(`Input file not found: ${inputFile}`);
+  const raw = readFileSync(inputFile, "utf-8");
+  const requests = parseBatchInput(raw);
+  const defaultModel = getDefaultModel(config);
+  console.log(`Parsed ${requests.length} request(s) from ${inputFile}`);
+  console.log(`Default model: ${defaultModel}`);
+  if (options.dryRun) {
+    console.log("[dry-run] Not submitting. Sample request:");
+    console.log(JSON.stringify(requests[0], null, 2));
+    return;
+  }
+  const client = getClaudeClient(config);
+  const apiRequests = requests.map((r) => ({
+    custom_id: r.customId,
+    params: {
+      model: r.model ?? defaultModel,
+      max_tokens: r.maxTokens ?? 4096,
+      messages: r.messages,
+      ...r.system ? { system: r.system } : {}
+    }
+  }));
+  console.log(`Submitting ${apiRequests.length} request(s) to Anthropic Batches API\u2026`);
+  const batch = await client.messages.batches.create({ requests: apiRequests });
+  const tracked = loadTrackedBatches(config);
+  tracked.unshift({
+    id: batch.id,
+    provider: "claude",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    inputFile,
+    requestCount: requests.length,
+    model: defaultModel
+  });
+  saveTrackedBatches(config, tracked.slice(0, 200));
+  console.log(`
+Batch submitted:`);
+  console.log(`  ID:              ${batch.id}`);
+  console.log(`  Processing:      ${batch.processing_status}`);
+  console.log(`  Expires:         ${batch.expires_at}`);
+  console.log(`
+Check status:  aicli batch status ${batch.id}`);
+  console.log(`Get results:   aicli batch results ${batch.id}`);
+}
+async function cmdList() {
+  const config = new ConfigManager();
+  const tracked = loadTrackedBatches(config);
+  if (tracked.length === 0) {
+    console.log("No tracked batches. Submit one with `aicli batch submit <input.jsonl>`.");
+    return;
+  }
+  const client = getClaudeClient(config);
+  console.log(`
+${tracked.length} tracked batch(es):
+`);
+  console.log("  ID                                        Requests  Status              Created");
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  for (const b of tracked.slice(0, 20)) {
+    let status = "(unknown)";
+    try {
+      const fresh = await client.messages.batches.retrieve(b.id);
+      status = fresh.processing_status;
+    } catch {
+      status = "(fetch-failed)";
+    }
+    const created = new Date(b.createdAt).toLocaleString();
+    console.log(`  ${b.id.padEnd(42)}  ${String(b.requestCount).padStart(8)}  ${status.padEnd(18)}  ${created}`);
+  }
+  console.log("");
+}
+async function cmdStatus(batchId) {
+  const config = new ConfigManager();
+  const client = getClaudeClient(config);
+  const batch = await client.messages.batches.retrieve(batchId);
+  console.log(`
+Batch ${batch.id}`);
+  console.log(`  Processing:      ${batch.processing_status}`);
+  console.log(`  Created:         ${batch.created_at}`);
+  console.log(`  Expires:         ${batch.expires_at}`);
+  if (batch.ended_at) console.log(`  Ended:           ${batch.ended_at}`);
+  const counts = batch.request_counts;
+  if (counts) {
+    console.log(`  Counts:          processing=${counts.processing} succeeded=${counts.succeeded} errored=${counts.errored} canceled=${counts.canceled} expired=${counts.expired}`);
+  }
+  if (batch.results_url) console.log(`  Results URL:     ${batch.results_url}`);
+  console.log("");
+}
+async function cmdResults(batchId, outPath) {
+  const config = new ConfigManager();
+  const client = getClaudeClient(config);
+  const batch = await client.messages.batches.retrieve(batchId);
+  if (batch.processing_status !== "ended") {
+    console.log(`Batch is not ready yet (status: ${batch.processing_status}). Try again later.`);
+    return;
+  }
+  const stream = await client.messages.batches.results(batchId);
+  const lines = [];
+  let ok = 0, err = 0;
+  for await (const result of stream) {
+    lines.push(JSON.stringify(result));
+    const type = result.result?.type;
+    if (type === "succeeded") ok++;
+    else err++;
+  }
+  const body = lines.join("\n") + "\n";
+  if (outPath) {
+    writeFileSync(outPath, body, "utf-8");
+    console.log(`Saved ${lines.length} result(s) to ${outPath} (${ok} succeeded, ${err} failed/errored).`);
+  } else {
+    process.stdout.write(body);
+    process.stderr.write(`
+[Summary] ${lines.length} results: ${ok} succeeded, ${err} failed/errored.
+`);
+  }
+}
+async function cmdCancel(batchId) {
+  const config = new ConfigManager();
+  const client = getClaudeClient(config);
+  const batch = await client.messages.batches.cancel(batchId);
+  console.log(`Canceled batch ${batch.id} (status: ${batch.processing_status}).`);
+}
+export {
+  cmdCancel,
+  cmdList,
+  cmdResults,
+  cmdStatus,
+  cmdSubmit,
+  loadTrackedBatches,
+  parseBatchInput,
+  saveTrackedBatches
+};

package/dist/{chunk-KR4FTJWB.js → chunk-EUE6VMGO.js}

@@ -1,21 +1,25 @@
 #!/usr/bin/env node
+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-K3JJX2Z5.js";
-import {
-  EnvLoader,
-  NetworkError,
-  ToolError
-} from "./chunk-2ZD3YTVM.js";
+} from "./chunk-KHYHG2SO.js";
 import {
   CONFIG_DIR_NAME,
   DEFAULT_MAX_TOOL_OUTPUT_CHARS_CAP,
@@ -23,7 +27,7 @@ import {
   SUBAGENT_ALLOWED_TOOLS,
   SUBAGENT_DEFAULT_MAX_ROUNDS,
   SUBAGENT_MAX_ROUNDS_LIMIT
-} from "./chunk-2Q77FT3F.js";
+} from "./chunk-HELGL4RH.js";
 
 // src/tools/builtin/bash.ts
 import { execSync } from "child_process";
@@ -4512,6 +4516,67 @@ var findReferencesTool = {
 ${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;
@@ -4571,6 +4636,7 @@ var ToolRegistry = class {
     this.register(findSymbolTool);
     this.register(getOutlineTool);
     this.register(findReferencesTool);
+    this.register(searchCodeTool);
   }
   register(tool) {
     this.tools.set(tool.definition.name, tool);

package/dist/{chunk-H4DQNZZ6.js → chunk-FCVQ6OP5.js}

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

package/dist/{chunk-XTH7S3AM.js → chunk-GKDETNDH.js}

@@ -2,7 +2,7 @@
 import {
   schemaToJsonSchema,
   truncateForPersist
-} from "./chunk-KR4FTJWB.js";
+} from "./chunk-EUE6VMGO.js";
 import {
   AuthError,
   ProviderError,
@@ -18,7 +18,7 @@ import {
   MCP_PROTOCOL_VERSION,
   MCP_TOOL_PREFIX,
   VERSION
-} from "./chunk-2Q77FT3F.js";
+} from "./chunk-HELGL4RH.js";
 
 // src/providers/claude.ts
 import Anthropic from "@anthropic-ai/sdk";

package/dist/{chunk-2Q77FT3F.js → chunk-HELGL4RH.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // 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";
@@ -36,8 +36,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
 
@@ -80,7 +82,8 @@ var SUBAGENT_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
   "run_tests",
   "find_symbol",
   "get_outline",
-  "find_references"
+  "find_references",
+  "search_code"
 ]);
 var CONTEXT_PRESSURE_THRESHOLD = 0.8;
 var TEST_TIMEOUT = 3e5;

package/dist/chunk-HPDDAXFY.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import {
+  loadIndex
+} from "./chunk-6VRJGH25.js";
+import {
+  EMBEDDING_DIM,
+  embed,
+  embedOne,
+  loadVectorStore,
+  saveVectorStore,
+  searchVectorStore
+} from "./chunk-PFYAAX2S.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-K3JJX2Z5.js → chunk-KHYHG2SO.js}

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

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