@chiway/contextweaver 1.4.0 → 1.5.1

package/dist/chunk-H4MGLXXF.js

@@ -0,0 +1,115 @@
+import {
+  getDefaultEnvFileContent
+} from "./chunk-TPM6YP43.js";
+import {
+  logger
+} from "./chunk-JVKVSTQ3.js";
+
+// src/mcp/tools/shared.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var BASE_DIR = path.join(os.homedir(), ".contextweaver");
+var INDEX_LOCK_TIMEOUT_MS = 10 * 60 * 1e3;
+function isProjectIndexed(projectId) {
+  const dbPath = path.join(BASE_DIR, projectId, "index.db");
+  return fs.existsSync(dbPath);
+}
+async function ensureDefaultEnvFile() {
+  const configDir = BASE_DIR;
+  const envFile = path.join(configDir, ".env");
+  if (fs.existsSync(envFile)) {
+    return;
+  }
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+    logger.info({ configDir }, "\u521B\u5EFA\u914D\u7F6E\u76EE\u5F55");
+  }
+  fs.writeFileSync(envFile, getDefaultEnvFileContent());
+  logger.info({ envFile }, "\u5DF2\u521B\u5EFA\u9ED8\u8BA4 .env \u914D\u7F6E\u6587\u4EF6");
+}
+async function ensureIndexed(repoPath, projectId, options = {}) {
+  const { onProgress, vectorIndex = true } = options;
+  const { withLock } = await import("./lock-HNKQ6X5B.js");
+  const { scan } = await import("./scanner-OVMAMQSQ.js");
+  await withLock(
+    projectId,
+    "index",
+    async () => {
+      const wasIndexed = isProjectIndexed(projectId);
+      if (!wasIndexed) {
+        logger.info(
+          { repoPath, projectId: projectId.slice(0, 10), vectorIndex },
+          "\u4EE3\u7801\u5E93\u672A\u521D\u59CB\u5316\uFF0C\u5F00\u59CB\u9996\u6B21\u7D22\u5F15..."
+        );
+        onProgress?.(0, 100, "\u4EE3\u7801\u5E93\u672A\u7D22\u5F15\uFF0C\u5F00\u59CB\u9996\u6B21\u7D22\u5F15...");
+      } else {
+        logger.debug({ projectId: projectId.slice(0, 10), vectorIndex }, "\u6267\u884C\u589E\u91CF\u7D22\u5F15...");
+      }
+      const startTime = Date.now();
+      const stats = await scan(repoPath, { vectorIndex, onProgress });
+      const elapsed = Date.now() - startTime;
+      logger.info(
+        {
+          projectId: projectId.slice(0, 10),
+          isFirstTime: !wasIndexed,
+          totalFiles: stats.totalFiles,
+          added: stats.added,
+          modified: stats.modified,
+          deleted: stats.deleted,
+          vectorIndex: stats.vectorIndex,
+          elapsedMs: elapsed
+        },
+        "\u7D22\u5F15\u5B8C\u6210"
+      );
+    },
+    INDEX_LOCK_TIMEOUT_MS
+  );
+}
+function formatTextResponse(text) {
+  return {
+    content: [
+      {
+        type: "text",
+        text
+      }
+    ]
+  };
+}
+function formatEnvMissingResponse(missingVars) {
+  const configPath = "~/.contextweaver/.env";
+  const text = `## \u26A0\uFE0F \u914D\u7F6E\u7F3A\u5931
+
+ContextWeaver \u9700\u8981\u914D\u7F6E Embedding API \u624D\u80FD\u5DE5\u4F5C\u3002
+
+### \u7F3A\u5931\u7684\u73AF\u5883\u53D8\u91CF
+${missingVars.map((v) => `- \`${v}\``).join("\n")}
+
+### \u914D\u7F6E\u6B65\u9AA4
+
+\u5DF2\u81EA\u52A8\u521B\u5EFA\u914D\u7F6E\u6587\u4EF6\uFF1A\`${configPath}\`
+
+\u8BF7\u7F16\u8F91\u8BE5\u6587\u4EF6\uFF0C\u586B\u5199\u4F60\u7684 API Key\uFF1A
+
+\`\`\`bash
+# Embedding API \u914D\u7F6E\uFF08\u5FC5\u9700\uFF09
+EMBEDDINGS_API_KEY=your-api-key-here  # \u2190 \u66FF\u6362\u4E3A\u4F60\u7684 API Key
+
+# Reranker \u914D\u7F6E\uFF08\u5FC5\u9700\uFF09
+RERANK_API_KEY=your-api-key-here      # \u2190 \u66FF\u6362\u4E3A\u4F60\u7684 API Key
+\`\`\`
+
+\u4FDD\u5B58\u6587\u4EF6\u540E\u91CD\u65B0\u8C03\u7528\u6B64\u5DE5\u5177\u5373\u53EF\u3002
+`;
+  return formatTextResponse(text);
+}
+async function checkEnvOrRespond(missingVars) {
+  await ensureDefaultEnvFile();
+  return formatEnvMissingResponse(missingVars);
+}
+
+export {
+  ensureIndexed,
+  formatTextResponse,
+  checkEnvOrRespond
+};

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-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-MN6BQJDB.js

@@ -0,0 +1,85 @@
+import {
+  ensureIndexed,
+  formatTextResponse
+} from "./chunk-H4MGLXXF.js";
+import {
+  generateProjectId,
+  initDb
+} from "./chunk-PPLFJGO3.js";
+import {
+  logger
+} from "./chunk-JVKVSTQ3.js";
+
+// src/mcp/tools/listFiles.ts
+import { z } from "zod";
+var listFilesSchema = z.object({
+  repo_path: z.string().describe(
+    "The absolute file system path to the repository root. (e.g., '/Users/dev/my-project')"
+  ),
+  glob: z.string().optional().describe("Optional glob pattern to filter returned file paths."),
+  language: z.string().optional().describe("Optional language filter matched against files.language."),
+  max_results: z.number().int().positive().max(1e3).optional().describe("Maximum number of files to return. Defaults to 200.")
+});
+function escapeRegexCharacter(char) {
+  return char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function globToRegExp(glob) {
+  const normalized = glob.replace(/\\/g, "/");
+  let pattern = "^";
+  for (let i = 0; i < normalized.length; ) {
+    if (normalized.slice(i, i + 3) === "**/") {
+      pattern += "(?:.*/)?";
+      i += 3;
+      continue;
+    }
+    if (normalized.slice(i, i + 2) === "**") {
+      pattern += ".*";
+      i += 2;
+      continue;
+    }
+    const char = normalized[i];
+    if (char === "*") {
+      pattern += "[^/]*";
+    } else if (char === "?") {
+      pattern += "[^/]";
+    } else {
+      pattern += escapeRegexCharacter(char);
+    }
+    i += 1;
+  }
+  return new RegExp(`${pattern}$`);
+}
+function formatSize(size) {
+  if (size < 1024) {
+    return `${size}B`;
+  }
+  const kb = size / 1024;
+  if (kb < 1024) {
+    return `${kb.toFixed(1)}KB`;
+  }
+  return `${(kb / 1024).toFixed(1)}MB`;
+}
+async function handleListFiles(args, onProgress) {
+  const { repo_path, glob, language, max_results = 200 } = args;
+  const projectId = generateProjectId(repo_path);
+  logger.info({ repo_path, glob, language, max_results }, "MCP list-files \u8C03\u7528\u5F00\u59CB");
+  await ensureIndexed(repo_path, projectId, { onProgress, vectorIndex: false });
+  const db = initDb(projectId);
+  try {
+    const rows = language ? db.prepare("SELECT path, language, size FROM files WHERE language = ? ORDER BY path").all(language) : db.prepare("SELECT path, language, size FROM files ORDER BY path").all();
+    const matcher = glob ? globToRegExp(glob) : null;
+    const filtered = matcher ? rows.filter((row) => matcher.test(row.path)) : rows;
+    const limited = filtered.slice(0, max_results);
+    const body = limited.length > 0 ? limited.map((row) => `- ${row.path} (${row.language}, ${formatSize(row.size)})`).join("\n") : "No files matched the requested filters.";
+    return formatTextResponse(`Found ${limited.length} files
+
+${body}`);
+  } finally {
+    db.close();
+  }
+}
+
+export {
+  listFilesSchema,
+  handleListFiles
+};

package/dist/{chunk-EMSMLPMK.js → chunk-ORYIVY7D.js}

@@ -1,14 +1,15 @@
+import {
+  checkEnvOrRespond,
+  ensureIndexed
+} from "./chunk-H4MGLXXF.js";
 import {
   generateProjectId
-} from "./chunk-RGJSXUFS.js";
+} from "./chunk-PPLFJGO3.js";
 import {
   logger
 } from "./chunk-JVKVSTQ3.js";
 
 // src/mcp/tools/codebaseRetrieval.ts
-import fs from "fs";
-import os from "os";
-import path from "path";
 import { z } from "zod";
 var codebaseRetrievalSchema = z.object({
   repo_path: z.string().describe(
@@ -21,80 +22,6 @@ var codebaseRetrievalSchema = z.object({
     "HARD FILTERS. Precise identifiers to narrow down results. Only use symbols KNOWN to exist to avoid false negatives."
   )
 });
-var BASE_DIR = path.join(os.homedir(), ".contextweaver");
-var INDEX_LOCK_TIMEOUT_MS = 10 * 60 * 1e3;
-async function ensureDefaultEnvFile() {
-  const configDir = BASE_DIR;
-  const envFile = path.join(configDir, ".env");
-  if (fs.existsSync(envFile)) {
-    return;
-  }
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true });
-    logger.info({ configDir }, "\u521B\u5EFA\u914D\u7F6E\u76EE\u5F55");
-  }
-  const defaultEnvContent = `# 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
-
-# \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
-`;
-  fs.writeFileSync(envFile, defaultEnvContent);
-  logger.info({ envFile }, "\u5DF2\u521B\u5EFA\u9ED8\u8BA4 .env \u914D\u7F6E\u6587\u4EF6");
-}
-function isProjectIndexed(projectId) {
-  const dbPath = path.join(BASE_DIR, projectId, "index.db");
-  return fs.existsSync(dbPath);
-}
-async function ensureIndexed(repoPath, projectId, onProgress) {
-  const { withLock } = await import("./lock-FL54LIQL.js");
-  const { scan } = await import("./scanner-2XGJWYHR.js");
-  await withLock(
-    projectId,
-    "index",
-    async () => {
-      const wasIndexed = isProjectIndexed(projectId);
-      if (!wasIndexed) {
-        logger.info(
-          { repoPath, projectId: projectId.slice(0, 10) },
-          "\u4EE3\u7801\u5E93\u672A\u521D\u59CB\u5316\uFF0C\u5F00\u59CB\u9996\u6B21\u7D22\u5F15..."
-        );
-        onProgress?.(0, 100, "\u4EE3\u7801\u5E93\u672A\u7D22\u5F15\uFF0C\u5F00\u59CB\u9996\u6B21\u7D22\u5F15...");
-      } else {
-        logger.debug({ projectId: projectId.slice(0, 10) }, "\u6267\u884C\u589E\u91CF\u7D22\u5F15...");
-      }
-      const startTime = Date.now();
-      const stats = await scan(repoPath, { vectorIndex: true, onProgress });
-      const elapsed = Date.now() - startTime;
-      logger.info(
-        {
-          projectId: projectId.slice(0, 10),
-          isFirstTime: !wasIndexed,
-          totalFiles: stats.totalFiles,
-          added: stats.added,
-          modified: stats.modified,
-          deleted: stats.deleted,
-          vectorIndex: stats.vectorIndex,
-          elapsedMs: elapsed
-        },
-        "\u7D22\u5F15\u5B8C\u6210"
-      );
-    },
-    INDEX_LOCK_TIMEOUT_MS
-  );
-}
 async function handleCodebaseRetrieval(args, onProgress) {
   const { repo_path, information_request, technical_terms } = args;
   logger.info(
@@ -111,11 +38,10 @@ async function handleCodebaseRetrieval(args, onProgress) {
   const allMissingVars = [...embeddingCheck.missingVars, ...rerankerCheck.missingVars];
   if (allMissingVars.length > 0) {
     logger.warn({ missingVars: allMissingVars }, "MCP \u73AF\u5883\u53D8\u91CF\u672A\u914D\u7F6E");
-    await ensureDefaultEnvFile();
-    return formatEnvMissingResponse(allMissingVars);
+    return await checkEnvOrRespond(allMissingVars);
   }
   const projectId = generateProjectId(repo_path);
-  await ensureIndexed(repo_path, projectId, onProgress);
+  await ensureIndexed(repo_path, projectId, { onProgress });
   const query = [information_request, ...technical_terms || []].filter(Boolean).join(" ");
   logger.info(
     {
@@ -124,8 +50,9 @@ async function handleCodebaseRetrieval(args, onProgress) {
     },
     "MCP \u67E5\u8BE2\u6784\u5EFA"
   );
-  const { SearchService } = await import("./SearchService-OS7CYHNJ.js");
-  const service = new SearchService(projectId, repo_path);
+  const { SearchService } = await import("./SearchService-WVD6THR3.js");
+  const { getSearchConfigOverrides } = await import("./loadConfig-XTVT2OWW.js");
+  const service = new SearchService(projectId, repo_path, getSearchConfigOverrides());
   await service.init();
   logger.debug("SearchService \u521D\u59CB\u5316\u5B8C\u6210");
   const contextPack = await service.buildContextPack(query);
@@ -244,40 +171,6 @@ function detectLanguage(filePath) {
   };
   return langMap[ext] || ext || "plaintext";
 }
-function formatEnvMissingResponse(missingVars) {
-  const configPath = "~/.contextweaver/.env";
-  const text = `## \u26A0\uFE0F \u914D\u7F6E\u7F3A\u5931
-
-ContextWeaver \u9700\u8981\u914D\u7F6E Embedding API \u624D\u80FD\u5DE5\u4F5C\u3002
-
-### \u7F3A\u5931\u7684\u73AF\u5883\u53D8\u91CF
-${missingVars.map((v) => `- \`${v}\``).join("\n")}
-
-### \u914D\u7F6E\u6B65\u9AA4
-
-\u5DF2\u81EA\u52A8\u521B\u5EFA\u914D\u7F6E\u6587\u4EF6\uFF1A\`${configPath}\`
-
-\u8BF7\u7F16\u8F91\u8BE5\u6587\u4EF6\uFF0C\u586B\u5199\u4F60\u7684 API Key\uFF1A
-
-\`\`\`bash
-# Embedding API \u914D\u7F6E\uFF08\u5FC5\u9700\uFF09
-EMBEDDINGS_API_KEY=your-api-key-here  # \u2190 \u66FF\u6362\u4E3A\u4F60\u7684 API Key
-
-# Reranker \u914D\u7F6E\uFF08\u5FC5\u9700\uFF09
-RERANK_API_KEY=your-api-key-here      # \u2190 \u66FF\u6362\u4E3A\u4F60\u7684 API Key
-\`\`\`
-
-\u4FDD\u5B58\u6587\u4EF6\u540E\u91CD\u65B0\u8C03\u7528\u6B64\u5DE5\u5177\u5373\u53EF\u3002
-`;
-  return {
-    content: [
-      {
-        type: "text",
-        text
-      }
-    ]
-  };
-}
 
 export {
   codebaseRetrievalSchema,

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

package/dist/chunk-XFIM2T6S.js

@@ -0,0 +1,57 @@
+// src/search/ChunkContentLoader.ts
+var ChunkContentLoader = class _ChunkContentLoader {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * 生成 cache key
+   */
+  static key(slice) {
+    return `${slice.filePath}#${slice.start_index}#${slice.end_index}`;
+  }
+  /**
+   * 批量加载 chunk 正文
+   *
+   * @returns Map<key, code>，key 由 ChunkContentLoader.key 生成
+   */
+  loadMany(slices) {
+    const result = /* @__PURE__ */ new Map();
+    if (slices.length === 0) return result;
+    const byPath = /* @__PURE__ */ new Map();
+    for (const s of slices) {
+      let arr = byPath.get(s.filePath);
+      if (!arr) {
+        arr = [];
+        byPath.set(s.filePath, arr);
+      }
+      arr.push(s);
+    }
+    const stmt = this.db.prepare("SELECT content FROM files WHERE path = ?");
+    for (const [path, spans] of byPath) {
+      const row = stmt.get(path);
+      const content = row?.content ?? null;
+      for (const s of spans) {
+        const k = _ChunkContentLoader.key(s);
+        if (content === null) {
+          result.set(k, "");
+          continue;
+        }
+        const safeStart = Math.max(0, Math.min(s.start_index, content.length));
+        const safeEnd = Math.max(safeStart, Math.min(s.end_index, content.length));
+        result.set(k, content.slice(safeStart, safeEnd));
+      }
+    }
+    return result;
+  }
+  /**
+   * 加载单个 chunk 正文（便捷方法，不推荐在批量场景使用）
+   */
+  loadOne(slice) {
+    const map = this.loadMany([slice]);
+    return map.get(_ChunkContentLoader.key(slice)) ?? "";
+  }
+};
+
+export {
+  ChunkContentLoader
+};