@chiway/contextweaver 1.4.0 → 1.5.0

package/dist/{chunk-X7PAYQMT.js → chunk-GDVB6PJ4.js}

@@ -2,10 +2,10 @@ import {
   closeAllIndexers,
   getIndexer,
   invalidateAllExpanderCaches
-} from "./chunk-AB24E3Z7.js";
+} from "./chunk-XMZZZKG7.js";
 import {
   closeAllVectorStores
-} from "./chunk-ZOMGPIU6.js";
+} from "./chunk-3BNHQV5W.js";
 import {
   batchDelete,
   batchUpdateMtime,
@@ -17,9 +17,12 @@ import {
   getAllPaths,
   getFilesNeedingVectorIndex,
   getStoredEmbeddingDimensions,
+  incrementIndexVersion,
+  incrementStat,
   initDb,
+  setStatJson,
   setStoredEmbeddingDimensions
-} from "./chunk-RGJSXUFS.js";
+} from "./chunk-PPLFJGO3.js";
 import {
   logger
 } from "./chunk-JVKVSTQ3.js";
@@ -1382,6 +1385,19 @@ async function scan(rootPath, options = {}) {
         logger.warn({ error: error.message }, "GC \u8DF3\u8FC7");
       }
     }
+    const didWork = stats.added + stats.modified + stats.deleted > 0;
+    if (didWork) {
+      incrementIndexVersion(db);
+    }
+    try {
+      if (didWork) {
+        incrementStat(db, "stats.index.total_runs");
+      }
+      setStatJson(db, "stats.index.last_run_json", stats);
+      setStatJson(db, "stats.index.last_run_at", Date.now());
+    } catch (err) {
+      logger.warn({ error: err.message }, "\u7D22\u5F15\u7EDF\u8BA1\u57CB\u70B9\u5931\u8D25");
+    }
     invalidateAllExpanderCaches();
     return stats;
   } finally {
@@ -1392,5 +1408,7 @@ async function scan(rootPath, options = {}) {
 }
 
 export {
+  initFilter,
+  isFiltered,
   scan
 };

package/dist/{lock-FL54LIQL.js → chunk-HHYPQA3X.js}

@@ -1,7 +1,6 @@
 import {
   logger
 } from "./chunk-JVKVSTQ3.js";
-import "./chunk-SKBAE26T.js";
 
 // src/utils/lock.ts
 import fs from "fs";
@@ -122,6 +121,7 @@ async function withLock(projectId, operation, fn, timeoutMs = 3e4) {
     releaseLock(projectId);
   }
 }
+
 export {
   withLock
 };

package/dist/chunk-ISVCQFB4.js

@@ -0,0 +1,223 @@
+import {
+  commonPrefixLength
+} from "./chunk-LB42CZEB.js";
+import {
+  ChunkContentLoader
+} from "./chunk-XFIM2T6S.js";
+import {
+  getVectorStore
+} from "./chunk-3BNHQV5W.js";
+import {
+  ensureIndexed,
+  formatTextResponse
+} from "./chunk-VWBKZ6QL.js";
+import {
+  generateProjectId,
+  initDb,
+  searchChunksFts
+} from "./chunk-PPLFJGO3.js";
+import {
+  logger
+} from "./chunk-JVKVSTQ3.js";
+
+// src/mcp/tools/getSymbolDefinition.ts
+import { z } from "zod";
+var getSymbolDefinitionSchema = z.object({
+  repo_path: z.string().describe(
+    "The absolute file system path to the repository root. (e.g., '/Users/dev/my-project')"
+  ),
+  symbol: z.string().min(1).describe("The exact symbol name to resolve."),
+  hint_path: z.string().optional().describe("Optional preferred path used to disambiguate same-name definitions."),
+  max_results: z.number().int().positive().max(20).optional().describe("Maximum number of definitions to return. Defaults to 3.")
+});
+var LANGUAGE_DEFINITION_PATTERNS = {
+  typescript: [
+    "function\\s+{symbol}\\b",
+    "class\\s+{symbol}\\b",
+    "(?:const|let|var)\\s+{symbol}\\b",
+    "interface\\s+{symbol}\\b",
+    "type\\s+{symbol}\\b",
+    "enum\\s+{symbol}\\b"
+  ],
+  javascript: [
+    "function\\s+{symbol}\\b",
+    "class\\s+{symbol}\\b",
+    "(?:const|let|var)\\s+{symbol}\\b"
+  ],
+  python: ["def\\s+{symbol}\\b", "class\\s+{symbol}\\b"],
+  go: ["func\\s+{symbol}\\b", "type\\s+{symbol}\\b", "const\\s+{symbol}\\b", "var\\s+{symbol}\\b"],
+  rust: [
+    "fn\\s+{symbol}\\b",
+    "struct\\s+{symbol}\\b",
+    "enum\\s+{symbol}\\b",
+    "const\\s+{symbol}\\b"
+  ],
+  java: [
+    "class\\s+{symbol}\\b",
+    "interface\\s+{symbol}\\b",
+    "enum\\s+{symbol}\\b",
+    "\\b{symbol}\\s*\\("
+  ],
+  csharp: [
+    "class\\s+{symbol}\\b",
+    "interface\\s+{symbol}\\b",
+    "enum\\s+{symbol}\\b",
+    "\\b{symbol}\\s*\\("
+  ],
+  cpp: ["class\\s+{symbol}\\b", "struct\\s+{symbol}\\b", "\\b{symbol}\\s*\\("],
+  c: ["\\b{symbol}\\s*\\("]
+};
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function breadcrumbTail(breadcrumb) {
+  return breadcrumb.split(">").pop()?.trim() ?? "";
+}
+function countLinesBefore(content, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < content.length; i++) {
+    if (content[i] === "\n") {
+      line += 1;
+    }
+  }
+  return line;
+}
+function computeEndLine(startLine, code) {
+  const normalized = code.replace(/\n+$/u, "");
+  if (!normalized) {
+    return startLine;
+  }
+  return startLine + normalized.split("\n").length - 1;
+}
+function detectLanguage(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() || "";
+  const langMap = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    py: "python",
+    rs: "rust",
+    go: "go",
+    java: "java",
+    c: "c",
+    cpp: "cpp",
+    h: "c",
+    hpp: "cpp",
+    cs: "csharp",
+    md: "markdown",
+    json: "json"
+  };
+  return langMap[ext] || ext || "plaintext";
+}
+function formatDefinition(candidate) {
+  const header = `## ${candidate.chunk.file_path} (L${candidate.startLine}-L${candidate.endLine})`;
+  const breadcrumb = candidate.chunk.breadcrumb ? `> ${candidate.chunk.breadcrumb}` : "";
+  const code = `\`\`\`${detectLanguage(candidate.chunk.file_path)}
+${candidate.code}
+\`\`\``;
+  return [header, breadcrumb, code].filter(Boolean).join("\n");
+}
+function hasDefinitionPattern(language, code, symbol) {
+  const patterns = LANGUAGE_DEFINITION_PATTERNS[language] ?? LANGUAGE_DEFINITION_PATTERNS.typescript;
+  return patterns.some((pattern) => {
+    const source = pattern.replaceAll("{symbol}", escapeRegex(symbol));
+    return new RegExp(source, "u").test(code);
+  });
+}
+function rankCandidates(a, b) {
+  if (a.breadcrumbExact !== b.breadcrumbExact) {
+    return a.breadcrumbExact ? -1 : 1;
+  }
+  if (a.prefixScore !== b.prefixScore) {
+    return b.prefixScore - a.prefixScore;
+  }
+  if (a.score !== b.score) {
+    return b.score - a.score;
+  }
+  return a.chunk.file_path.localeCompare(b.chunk.file_path);
+}
+async function handleGetSymbolDefinition(args, onProgress) {
+  const { repo_path, symbol, hint_path, max_results = 3 } = args;
+  const projectId = generateProjectId(repo_path);
+  logger.info({ repo_path, symbol, hint_path, max_results }, "MCP get-symbol-definition \u8C03\u7528\u5F00\u59CB");
+  await ensureIndexed(repo_path, projectId, { onProgress });
+  const db = initDb(projectId);
+  try {
+    const hits = searchChunksFts(db, symbol, Math.max(max_results * 5, 20));
+    const uniquePaths = Array.from(new Set(hits.map((hit) => hit.filePath)));
+    const vectorStore = await getVectorStore(projectId);
+    const chunkMap = await vectorStore.getFilesChunks(uniquePaths);
+    const chunkByKey = /* @__PURE__ */ new Map();
+    for (const [filePath, chunks] of chunkMap) {
+      for (const chunk of chunks) {
+        chunkByKey.set(`${filePath}#${chunk.chunk_index}`, chunk);
+      }
+    }
+    const slices = Array.from(chunkByKey.values()).map((chunk) => ({
+      filePath: chunk.file_path,
+      start_index: chunk.start_index,
+      end_index: chunk.end_index
+    }));
+    const loader = new ChunkContentLoader(db);
+    const codeMap = loader.loadMany(slices);
+    const fileContentStmt = db.prepare("SELECT content FROM files WHERE path = ?");
+    const fullFileCache = /* @__PURE__ */ new Map();
+    const candidates = /* @__PURE__ */ new Map();
+    for (const hit of hits) {
+      const chunk = chunkByKey.get(`${hit.filePath}#${hit.chunkIndex}`);
+      if (!chunk) {
+        continue;
+      }
+      const codeKey = ChunkContentLoader.key({
+        filePath: chunk.file_path,
+        start_index: chunk.start_index,
+        end_index: chunk.end_index
+      });
+      const code = codeMap.get(codeKey) ?? "";
+      if (!code) {
+        continue;
+      }
+      const breadcrumbExact = breadcrumbTail(chunk.breadcrumb) === symbol;
+      const definitionPattern = hasDefinitionPattern(chunk.language, code, symbol);
+      if (!breadcrumbExact && !definitionPattern) {
+        continue;
+      }
+      let fullContent = fullFileCache.get(chunk.file_path);
+      if (fullContent === void 0) {
+        const row = fileContentStmt.get(chunk.file_path);
+        fullContent = row?.content ?? "";
+        fullFileCache.set(chunk.file_path, fullContent);
+      }
+      const startLine = countLinesBefore(fullContent, chunk.start_index);
+      const candidate = {
+        chunk,
+        code,
+        score: hit.score,
+        breadcrumbExact,
+        prefixScore: hint_path ? commonPrefixLength(hint_path, chunk.file_path) : 0,
+        startLine,
+        endLine: computeEndLine(startLine, code)
+      };
+      const key = `${chunk.file_path}#${chunk.chunk_index}`;
+      const existing = candidates.get(key);
+      if (!existing || rankCandidates(candidate, existing) < 0) {
+        candidates.set(key, candidate);
+      }
+    }
+    const ranked = Array.from(candidates.values()).sort(rankCandidates).slice(0, max_results);
+    const body = ranked.length > 0 ? ranked.map((candidate) => formatDefinition(candidate)).join("\n\n---\n\n") : "No likely symbol definitions found.";
+    return formatTextResponse(
+      `Found ${ranked.length} symbol definitions for "${symbol}"
+
+${body}`
+    );
+  } finally {
+    db.close();
+  }
+}
+
+export {
+  getSymbolDefinitionSchema,
+  handleGetSymbolDefinition
+};

package/dist/chunk-IZ6IUHNN.js

@@ -0,0 +1,77 @@
+import {
+  DEFAULT_CONFIG,
+  SEARCH_CONFIG_BOUNDS
+} from "./chunk-BFCIZ52F.js";
+
+// src/search/loadConfig.ts
+import crypto from "crypto";
+var SEARCH_ENV_MAP = {
+  CW_SEARCH_WVEC: "wVec",
+  CW_SEARCH_WLEX: "wLex",
+  CW_SEARCH_RERANK_TOP_N: "rerankTopN",
+  CW_SEARCH_MAX_TOTAL_CHARS: "maxTotalChars",
+  CW_SEARCH_VECTOR_TOP_K: "vectorTopK",
+  CW_SEARCH_SMART_MAX_K: "smartMaxK",
+  CW_SEARCH_IMPORT_FILES_PER_SEED: "importFilesPerSeed"
+};
+var SEARCH_FINGERPRINT_FIELDS = Object.keys(DEFAULT_CONFIG);
+function normalizeWeight(value) {
+  return Math.round(value * 1e6) / 1e6;
+}
+function clampValue(key, rawValue) {
+  const parsed = Number(rawValue);
+  if (!Number.isFinite(parsed)) {
+    return void 0;
+  }
+  const bounds = SEARCH_CONFIG_BOUNDS[key];
+  if (!bounds) {
+    return parsed;
+  }
+  const clamped = Math.min(bounds.max, Math.max(bounds.min, parsed));
+  return bounds.integer ? Math.round(clamped) : clamped;
+}
+function getSearchConfigOverrides() {
+  const overrides = {};
+  const explicitWeights = {};
+  for (const [envKey, configKey] of Object.entries(SEARCH_ENV_MAP)) {
+    const rawValue = process.env[envKey];
+    if (rawValue === void 0 || rawValue.trim() === "") {
+      continue;
+    }
+    const parsed = clampValue(configKey, rawValue);
+    if (parsed === void 0) {
+      continue;
+    }
+    if (configKey === "wVec" || configKey === "wLex") {
+      explicitWeights[configKey] = parsed;
+      continue;
+    }
+    overrides[configKey] = parsed;
+  }
+  if (explicitWeights.wVec !== void 0 && explicitWeights.wLex === void 0) {
+    overrides.wVec = explicitWeights.wVec;
+    overrides.wLex = normalizeWeight(1 - explicitWeights.wVec);
+  } else if (explicitWeights.wLex !== void 0 && explicitWeights.wVec === void 0) {
+    overrides.wLex = explicitWeights.wLex;
+    overrides.wVec = normalizeWeight(1 - explicitWeights.wLex);
+  } else {
+    if (explicitWeights.wVec !== void 0) {
+      overrides.wVec = explicitWeights.wVec;
+    }
+    if (explicitWeights.wLex !== void 0) {
+      overrides.wLex = explicitWeights.wLex;
+    }
+  }
+  return overrides;
+}
+function createSearchConfigFingerprint(config) {
+  const payload = Object.fromEntries(
+    SEARCH_FINGERPRINT_FIELDS.map((field) => [field, config[field]])
+  );
+  return crypto.createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+
+export {
+  getSearchConfigOverrides,
+  createSearchConfigFingerprint
+};

package/dist/chunk-LB42CZEB.js

@@ -0,0 +1,18 @@
+// src/search/resolvers/types.ts
+function commonPrefixLength(path1, path2) {
+  const parts1 = path1.split("/");
+  const parts2 = path2.split("/");
+  let count = 0;
+  for (let i = 0; i < Math.min(parts1.length, parts2.length); i++) {
+    if (parts1[i] === parts2[i]) {
+      count++;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+
+export {
+  commonPrefixLength
+};

package/dist/{chunk-RGJSXUFS.js → chunk-PPLFJGO3.js}

@@ -640,6 +640,7 @@ function clear(db) {
   db.exec("DELETE FROM chunks_fts");
 }
 var METADATA_KEY_EMBEDDING_DIMENSIONS = "embedding_dimensions";
+var METADATA_KEY_INDEX_VERSION = "index_version";
 var METADATA_KEY_LANCEDB_MIGRATION_STATE = "lancedb_migration_displaycode_state";
 var METADATA_KEY_LANCEDB_MIGRATION_LOCK = "lancedb_migration_lock";
 var MIGRATION_LOCK_STALE_MS = 10 * 60 * 1e3;
@@ -663,6 +664,58 @@ function getStoredEmbeddingDimensions(db) {
 function setStoredEmbeddingDimensions(db, dimensions) {
   setMetadata(db, METADATA_KEY_EMBEDDING_DIMENSIONS, String(dimensions));
 }
+function incrementStat(db, key, by = 1) {
+  const delta = Math.trunc(by);
+  db.prepare(`
+    INSERT INTO metadata (key, value)
+    VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = CAST(CAST(value AS INTEGER) + CAST(? AS INTEGER) AS TEXT)
+  `).run(key, String(delta), delta);
+}
+function setStatJson(db, key, value) {
+  setMetadata(db, key, JSON.stringify(value));
+}
+function getStatJson(db, key) {
+  const raw = getMetadata(db, key);
+  if (raw === null) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function getAllStats(db) {
+  const rows = db.prepare(`SELECT key, value FROM metadata WHERE key LIKE 'stats.%'`).all();
+  const out = {};
+  for (const row of rows) out[row.key] = row.value;
+  return out;
+}
+function collectHealthSnapshot(db) {
+  const agg = db.prepare("SELECT COUNT(*) as c, COALESCE(SUM(size), 0) as bytes FROM files").get();
+  const langRows = db.prepare("SELECT language, COUNT(*) as c FROM files GROUP BY language").all();
+  const byLanguage = {};
+  for (const row of langRows) byLanguage[row.language] = row.c;
+  return {
+    totalFiles: agg.c,
+    totalBytes: agg.bytes,
+    byLanguage,
+    pendingMarks: countPendingMarks(db),
+    migrationState: getLanceDbMigrationState(db),
+    embeddingDimensions: getStoredEmbeddingDimensions(db),
+    indexVersion: getIndexVersion(db)
+  };
+}
+function getIndexVersion(db) {
+  const value = getMetadata(db, METADATA_KEY_INDEX_VERSION);
+  if (value === null) return 0;
+  const parsed = parseInt(value, 10);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function incrementIndexVersion(db) {
+  const next = getIndexVersion(db) + 1;
+  setMetadata(db, METADATA_KEY_INDEX_VERSION, String(next));
+  return next;
+}
 function getLanceDbMigrationState(db) {
   const value = getMetadata(db, METADATA_KEY_LANCEDB_MIGRATION_STATE);
   if (value === "pending" || value === "done" || value === "aborted") return value;
@@ -732,6 +785,13 @@ export {
   clear,
   getStoredEmbeddingDimensions,
   setStoredEmbeddingDimensions,
+  incrementStat,
+  setStatJson,
+  getStatJson,
+  getAllStats,
+  collectHealthSnapshot,
+  getIndexVersion,
+  incrementIndexVersion,
   getLanceDbMigrationState,
   setLanceDbMigrationState,
   clearAllVectorIndexHash,

package/dist/chunk-R6CNZXZ7.js

@@ -0,0 +1,143 @@
+import {
+  ChunkContentLoader
+} from "./chunk-XFIM2T6S.js";
+import {
+  getVectorStore
+} from "./chunk-3BNHQV5W.js";
+import {
+  ensureIndexed,
+  formatTextResponse
+} from "./chunk-VWBKZ6QL.js";
+import {
+  generateProjectId,
+  initDb,
+  searchChunksFts
+} from "./chunk-PPLFJGO3.js";
+import {
+  logger
+} from "./chunk-JVKVSTQ3.js";
+
+// src/mcp/tools/findReferences.ts
+import { z } from "zod";
+var findReferencesSchema = z.object({
+  repo_path: z.string().describe(
+    "The absolute file system path to the repository root. (e.g., '/Users/dev/my-project')"
+  ),
+  symbol: z.string().min(1).describe("The exact symbol name to search for."),
+  exclude_definition: z.boolean().optional().describe("Exclude chunks whose breadcrumb tail matches the symbol name."),
+  max_results: z.number().int().positive().max(200).optional().describe("Maximum number of references to return. Defaults to 50.")
+});
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildSymbolPattern(symbol) {
+  return new RegExp(`(?<![\\w$])${escapeRegex(symbol)}(?![\\w$])`, "u");
+}
+function breadcrumbTail(breadcrumb) {
+  const tail = breadcrumb.split(">").pop();
+  return tail?.trim() ?? "";
+}
+function countLinesBefore(content, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < content.length; i++) {
+    if (content[i] === "\n") {
+      line += 1;
+    }
+  }
+  return line;
+}
+function locateMatches(code, pattern, baseLine) {
+  return code.split("\n").flatMap(
+    (text, offset) => pattern.test(text) ? [
+      {
+        line: baseLine + offset,
+        snippet: text.trim()
+      }
+    ] : []
+  );
+}
+async function handleFindReferences(args, onProgress) {
+  const { repo_path, symbol, exclude_definition = false, max_results = 50 } = args;
+  const projectId = generateProjectId(repo_path);
+  logger.info(
+    { repo_path, symbol, exclude_definition, max_results },
+    "MCP find-references \u8C03\u7528\u5F00\u59CB"
+  );
+  await ensureIndexed(repo_path, projectId, { onProgress });
+  const db = initDb(projectId);
+  try {
+    const hits = searchChunksFts(db, symbol, Math.max(max_results * 2, 20));
+    const uniquePaths = Array.from(new Set(hits.map((hit) => hit.filePath)));
+    const vectorStore = await getVectorStore(projectId);
+    const chunkMap = await vectorStore.getFilesChunks(uniquePaths);
+    const chunkByKey = /* @__PURE__ */ new Map();
+    for (const [filePath, chunks] of chunkMap) {
+      for (const chunk of chunks) {
+        chunkByKey.set(`${filePath}#${chunk.chunk_index}`, chunk);
+      }
+    }
+    const slices = Array.from(chunkByKey.values()).map((chunk) => ({
+      filePath: chunk.file_path,
+      start_index: chunk.start_index,
+      end_index: chunk.end_index
+    }));
+    const loader = new ChunkContentLoader(db);
+    const codeMap = loader.loadMany(slices);
+    const fileContentStmt = db.prepare("SELECT content FROM files WHERE path = ?");
+    const fullFileCache = /* @__PURE__ */ new Map();
+    const pattern = buildSymbolPattern(symbol);
+    const matches = [];
+    for (const hit of hits) {
+      if (matches.length >= max_results) {
+        break;
+      }
+      const chunk = chunkByKey.get(`${hit.filePath}#${hit.chunkIndex}`);
+      if (!chunk) {
+        continue;
+      }
+      if (exclude_definition && breadcrumbTail(chunk.breadcrumb) === symbol) {
+        continue;
+      }
+      const sliceKey = ChunkContentLoader.key({
+        filePath: chunk.file_path,
+        start_index: chunk.start_index,
+        end_index: chunk.end_index
+      });
+      const code = codeMap.get(sliceKey) ?? "";
+      if (!code) {
+        continue;
+      }
+      let fullContent = fullFileCache.get(chunk.file_path);
+      if (fullContent === void 0) {
+        const row = fileContentStmt.get(chunk.file_path);
+        fullContent = row?.content ?? "";
+        fullFileCache.set(chunk.file_path, fullContent);
+      }
+      const baseLine = countLinesBefore(fullContent, chunk.start_index);
+      for (const match of locateMatches(code, pattern, baseLine)) {
+        matches.push({
+          filePath: chunk.file_path,
+          line: match.line,
+          breadcrumb: chunk.breadcrumb,
+          snippet: match.snippet
+        });
+        if (matches.length >= max_results) {
+          break;
+        }
+      }
+    }
+    const body = matches.length > 0 ? matches.map(
+      (match) => `- ${match.filePath}:${match.line} | ${match.breadcrumb || "-"} | ${match.snippet}`
+    ).join("\n") : "No exact text references found.";
+    return formatTextResponse(`Found ${matches.length} text references for "${symbol}"
+
+${body}`);
+  } finally {
+    db.close();
+  }
+}
+
+export {
+  findReferencesSchema,
+  handleFindReferences
+};

package/dist/chunk-TPM6YP43.js

@@ -0,0 +1,38 @@
+import {
+  DEFAULT_CONFIG
+} from "./chunk-BFCIZ52F.js";
+
+// src/defaultEnv.ts
+function getDefaultEnvFileContent() {
+  return `# ContextWeaver \u793A\u4F8B\u73AF\u5883\u53D8\u91CF\u914D\u7F6E\u6587\u4EF6
+
+# Embedding API \u914D\u7F6E\uFF08\u5FC5\u9700\uFF09
+EMBEDDINGS_API_KEY=your-api-key-here
+EMBEDDINGS_BASE_URL=https://api.siliconflow.cn/v1/embeddings
+EMBEDDINGS_MODEL=BAAI/bge-m3
+EMBEDDINGS_MAX_CONCURRENCY=10
+EMBEDDINGS_DIMENSIONS=1024
+
+# Reranker \u914D\u7F6E\uFF08\u5FC5\u9700\uFF09
+RERANK_API_KEY=your-api-key-here
+RERANK_BASE_URL=https://api.siliconflow.cn/v1/rerank
+RERANK_MODEL=BAAI/bge-reranker-v2-m3
+RERANK_TOP_N=20
+
+# \u641C\u7D22\u53C2\u6570\uFF08\u53EF\u9009\uFF0C\u8986\u76D6\u5185\u7F6E\u9ED8\u8BA4\u503C\uFF09
+CW_SEARCH_WVEC=${DEFAULT_CONFIG.wVec}
+CW_SEARCH_WLEX=${DEFAULT_CONFIG.wLex}
+CW_SEARCH_RERANK_TOP_N=${DEFAULT_CONFIG.rerankTopN}
+CW_SEARCH_MAX_TOTAL_CHARS=${DEFAULT_CONFIG.maxTotalChars}
+CW_SEARCH_VECTOR_TOP_K=${DEFAULT_CONFIG.vectorTopK}
+CW_SEARCH_SMART_MAX_K=${DEFAULT_CONFIG.smartMaxK}
+CW_SEARCH_IMPORT_FILES_PER_SEED=${DEFAULT_CONFIG.importFilesPerSeed}
+
+# \u7D22\u5F15\u5FFD\u7565\u6A21\u5F0F\uFF08\u53EF\u9009\uFF0C\u9017\u53F7\u5206\u9694\uFF0C\u9ED8\u8BA4\u5DF2\u5305\u542B\u5E38\u89C1\u5FFD\u7565\u9879\uFF09
+# IGNORE_PATTERNS=.venv,node_modules
+`;
+}
+
+export {
+  getDefaultEnvFileContent
+};