@chiway/contextweaver 1.1.0 → 1.5.0

package/dist/{chunk-6Z4JEEVJ.js → chunk-PPLFJGO3.js}

@@ -1,7 +1,14 @@
 import {
   isDebugEnabled,
   logger
-} from "./chunk-AMQQK4P7.js";
+} from "./chunk-JVKVSTQ3.js";
+
+// src/db/index.ts
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import Database from "better-sqlite3";
 
 // src/search/fts.ts
 var tokenizerCache = /* @__PURE__ */ new WeakMap();
@@ -26,7 +33,7 @@ function detectFtsTokenizer(db) {
 function initFilesFts(db) {
   const tokenizer = detectFtsTokenizer(db);
   const tableExists = db.prepare(`
-        SELECT name FROM sqlite_master 
+        SELECT name FROM sqlite_master
         WHERE type='table' AND name='files_fts'
     `).get();
   if (!tableExists) {
@@ -34,25 +41,40 @@ function initFilesFts(db) {
             CREATE VIRTUAL TABLE files_fts USING fts5(
                 path,
                 content,
+                content='files',
+                content_rowid='rowid',
                 tokenize='${tokenizer}'
             );
         `);
-    logger.info(`\u521B\u5EFA files_fts \u8868\uFF0Ctokenizer=${tokenizer}`);
-    syncFilesFts(db);
-  }
-}
-function syncFilesFts(db) {
-  const fileCount = db.prepare("SELECT COUNT(*) as c FROM files WHERE content IS NOT NULL").get().c;
-  const ftsCount = db.prepare("SELECT COUNT(*) as c FROM files_fts").get().c;
-  if (ftsCount < fileCount) {
-    logger.info(`\u540C\u6B65 FTS \u7D22\u5F15: files=${fileCount}, fts=${ftsCount}`);
-    db.exec(`
-            DELETE FROM files_fts;
-            INSERT INTO files_fts(path, content) 
-            SELECT path, content FROM files WHERE content IS NOT NULL;
-        `);
-    logger.info(`FTS \u7D22\u5F15\u540C\u6B65\u5B8C\u6210: ${fileCount} \u6761\u8BB0\u5F55`);
+    logger.info(`\u521B\u5EFA files_fts \u8868\uFF08\u5916\u90E8\u5185\u5BB9\u8868\uFF09\uFF0Ctokenizer=${tokenizer}`);
   }
+  db.exec(`
+        CREATE TRIGGER IF NOT EXISTS files_ai
+        AFTER INSERT ON files
+        WHEN new.content IS NOT NULL
+        BEGIN
+            INSERT INTO files_fts(rowid, path, content)
+            VALUES (new.rowid, new.path, new.content);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS files_ad
+        AFTER DELETE ON files
+        WHEN old.content IS NOT NULL
+        BEGIN
+            INSERT INTO files_fts(files_fts, rowid, path, content)
+            VALUES('delete', old.rowid, old.path, old.content);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS files_au
+        AFTER UPDATE ON files
+        WHEN old.content IS NOT NULL OR new.content IS NOT NULL
+        BEGIN
+            INSERT INTO files_fts(files_fts, rowid, path, content)
+            SELECT 'delete', old.rowid, old.path, old.content WHERE old.content IS NOT NULL;
+            INSERT INTO files_fts(rowid, path, content)
+            SELECT new.rowid, new.path, new.content WHERE new.content IS NOT NULL;
+        END;
+    `);
 }
 function initChunksFts(db) {
   const tokenizer = detectFtsTokenizer(db);
@@ -82,13 +104,17 @@ function isChunksFtsInitialized(db) {
   return !!result;
 }
 function batchUpsertChunkFts(db, chunks) {
-  const deleteStmt = db.prepare("DELETE FROM chunks_fts WHERE chunk_id = ?");
+  if (chunks.length === 0) return;
+  const paths = Array.from(new Set(chunks.map((c) => c.filePath)));
+  const deleteByPath = db.prepare("DELETE FROM chunks_fts WHERE file_path = ?");
   const insertStmt = db.prepare(
     "INSERT INTO chunks_fts(chunk_id, file_path, chunk_index, breadcrumb, content) VALUES (?, ?, ?, ?, ?)"
   );
   const transaction = db.transaction((items) => {
+    for (const p of paths) {
+      deleteByPath.run(p);
+    }
     for (const item of items) {
-      deleteStmt.run(item.chunkId);
       insertStmt.run(item.chunkId, item.filePath, item.chunkIndex, item.breadcrumb, item.content);
     }
   });
@@ -172,26 +198,6 @@ function searchChunksFts(db, query, limit) {
   }
   return results.sort((a, b) => b.score - a.score);
 }
-function batchUpsertFileFts(db, files) {
-  const deleteFts = db.prepare("DELETE FROM files_fts WHERE path = ?");
-  const insertFts = db.prepare("INSERT INTO files_fts(path, content) VALUES (?, ?)");
-  const transaction = db.transaction((items) => {
-    for (const item of items) {
-      deleteFts.run(item.path);
-      insertFts.run(item.path, item.content);
-    }
-  });
-  transaction(files);
-}
-function batchDeleteFileFts(db, paths) {
-  const stmt = db.prepare("DELETE FROM files_fts WHERE path = ?");
-  const transaction = db.transaction((items) => {
-    for (const path2 of items) {
-      stmt.run(path2);
-    }
-  });
-  transaction(paths);
-}
 function sanitizeQuery(query) {
   return query.replace(/[():"*^./\\:@#$%&=+[\]{}<>|~`!?,;]/g, " ").replace(/\b(AND|OR|NOT|NEAR)\b/gi, " ").replace(/\s+/g, " ").trim();
 }
@@ -342,11 +348,6 @@ function isFtsInitialized(db) {
 }
 
 // src/db/index.ts
-import crypto from "crypto";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import Database from "better-sqlite3";
 var BASE_DIR = path.join(os.homedir(), ".contextweaver");
 function getDirectoryBirthtime(projectPath) {
   const gitDir = path.join(projectPath, ".git");
@@ -405,6 +406,7 @@ function initDb(projectId) {
       value TEXT NOT NULL
     )
   `);
+  migrateSchema(db);
   initFilesFts(db);
   initChunksFts(db);
   db.pragma("synchronous = NORMAL");
@@ -412,6 +414,148 @@ function initDb(projectId) {
   db.pragma("cache_size = -64000");
   return db;
 }
+var CURRENT_SCHEMA_VERSION = 3;
+var METADATA_KEY_SCHEMA_VERSION = "schema_version";
+function getSchemaVersion(db) {
+  const row = db.prepare("SELECT value FROM metadata WHERE key = ?").get(METADATA_KEY_SCHEMA_VERSION);
+  if (!row) return null;
+  const parsed = parseInt(row.value, 10);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function setSchemaVersion(db, version) {
+  db.prepare(`
+    INSERT INTO metadata (key, value)
+    VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(METADATA_KEY_SCHEMA_VERSION, String(version));
+}
+function isOldFilesFtsSchema(db) {
+  const row = db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='files_fts'`).get();
+  if (!row?.sql) return false;
+  return !row.sql.includes("content='files'");
+}
+function migrateSchema(db) {
+  const backupExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='files_fts_v1_backup'`).get();
+  const currentFtsExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='files_fts'`).get();
+  if (backupExists && currentFtsExists && !isOldFilesFtsSchema(db)) {
+    logger.warn("\u68C0\u6D4B\u5230\u6B8B\u7559\u5907\u4EFD\u8868 files_fts_v1_backup\uFF0C\u6E05\u7406\u4E2D");
+    db.exec("DROP TABLE files_fts_v1_backup");
+  }
+  const current = getSchemaVersion(db);
+  if (current === null) {
+    const fileCount = db.prepare("SELECT COUNT(*) as c FROM files").get().c;
+    const ftsExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='files_fts'`).get();
+    if (fileCount === 0 && !ftsExists) {
+      migrateToV3(db);
+      setSchemaVersion(db, CURRENT_SCHEMA_VERSION);
+      return;
+    }
+  }
+  if ((current ?? 1) < 2) {
+    migrateToV2(db);
+    setSchemaVersion(db, 2);
+  }
+  if ((current ?? 2) < 3) {
+    migrateToV3(db);
+    setSchemaVersion(db, 3);
+  }
+}
+function migrateToV2(db) {
+  const ftsExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='files_fts'`).get();
+  if (!ftsExists) {
+    return;
+  }
+  if (!isOldFilesFtsSchema(db)) {
+    return;
+  }
+  logger.info("\u6267\u884C schema \u8FC1\u79FB v1 \u2192 v2: files_fts \u8F6C\u4E3A\u5916\u90E8\u5185\u5BB9\u8868");
+  db.exec("DROP TABLE files_fts");
+  let tokenizer;
+  try {
+    db.exec(
+      `CREATE VIRTUAL TABLE IF NOT EXISTS _fts_probe USING fts5(content, tokenize='trigram');
+       DROP TABLE IF EXISTS _fts_probe;`
+    );
+    tokenizer = "trigram";
+  } catch {
+    tokenizer = "unicode61";
+  }
+  db.exec(`
+    CREATE VIRTUAL TABLE files_fts USING fts5(
+        path,
+        content,
+        content='files',
+        content_rowid='rowid',
+        tokenize='${tokenizer}'
+    );
+  `);
+  db.exec(`INSERT INTO files_fts(files_fts) VALUES('rebuild')`);
+  logger.info("schema \u8FC1\u79FB v1 \u2192 v2 \u5B8C\u6210");
+}
+function migrateToV3(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS pending_marks (
+      path TEXT PRIMARY KEY,
+      hash TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+  `);
+  logger.info("schema \u8FC1\u79FB v2 \u2192 v3 \u5B8C\u6210: pending_marks \u8868\u5DF2\u521B\u5EFA");
+}
+function insertPendingMarks(db, items) {
+  if (items.length === 0) return;
+  const now = Date.now();
+  const insert = db.prepare(`
+    INSERT INTO pending_marks (path, hash, created_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(path) DO UPDATE SET hash = excluded.hash, created_at = excluded.created_at
+  `);
+  const tx = db.transaction((data) => {
+    for (const it of data) {
+      insert.run(it.path, it.hash, now);
+    }
+  });
+  tx(items);
+}
+function deletePendingMarks(db, paths) {
+  if (paths.length === 0) return;
+  const del = db.prepare("DELETE FROM pending_marks WHERE path = ?");
+  const tx = db.transaction((items) => {
+    for (const p of items) del.run(p);
+  });
+  tx(paths);
+}
+function replayPendingMarks(db) {
+  const rows = db.prepare("SELECT path, hash FROM pending_marks").all();
+  if (rows.length === 0) return { applied: 0, discarded: 0 };
+  const update = db.prepare(`
+    UPDATE files SET vector_index_hash = ?
+    WHERE path = ? AND hash = ?
+  `);
+  const del = db.prepare("DELETE FROM pending_marks WHERE path = ?");
+  let applied = 0;
+  let discarded = 0;
+  const tx = db.transaction(() => {
+    for (const r of rows) {
+      const info = update.run(r.hash, r.path, r.hash);
+      if (info.changes > 0) {
+        applied++;
+      } else {
+        discarded++;
+      }
+      del.run(r.path);
+    }
+  });
+  tx();
+  if (applied > 0 || discarded > 0) {
+    logger.info({ applied, discarded }, "pending_marks \u91CD\u653E\u5B8C\u6210");
+  }
+  return { applied, discarded };
+}
+function countPendingMarks(db) {
+  const row = db.prepare("SELECT COUNT(*) as c FROM pending_marks").get();
+  return row.c;
+}
 function closeDb(db) {
   db.close();
 }
@@ -467,15 +611,6 @@ function batchUpsert(db, files) {
     }
   });
   transaction(files);
-  const ftsFiles = [];
-  for (const f of files) {
-    if (f.content !== null) {
-      ftsFiles.push({ path: f.path, content: f.content });
-    }
-  }
-  if (ftsFiles.length > 0) {
-    batchUpsertFileFts(db, ftsFiles);
-  }
 }
 function batchUpdateMtime(db, items) {
   const update = db.prepare("UPDATE files SET mtime = ? WHERE path = ?");
@@ -498,9 +633,6 @@ function batchDelete(db, paths) {
     }
   });
   transaction(paths);
-  if (paths.length > 0) {
-    batchDeleteFileFts(db, paths);
-  }
 }
 function clear(db) {
   db.exec("DELETE FROM files");
@@ -508,6 +640,10 @@ 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;
 function getMetadata(db, key) {
   const row = db.prepare("SELECT value FROM metadata WHERE key = ?").get(key);
   return row?.value ?? null;
@@ -528,6 +664,99 @@ 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;
+  return null;
+}
+function setLanceDbMigrationState(db, state) {
+  setMetadata(db, METADATA_KEY_LANCEDB_MIGRATION_STATE, state);
+}
+function clearAllVectorIndexHash(db) {
+  const info = db.prepare("UPDATE files SET vector_index_hash = NULL").run();
+  return info.changes;
+}
+function tryAcquireLanceDbMigrationLock(db) {
+  const now = Date.now();
+  const pid = process.pid;
+  const lockValue = JSON.stringify({ pid, acquiredAt: now });
+  const existing = getMetadata(db, METADATA_KEY_LANCEDB_MIGRATION_LOCK);
+  if (existing) {
+    try {
+      const parsed = JSON.parse(existing);
+      if (parsed.pid === pid) return true;
+      if (now - parsed.acquiredAt < MIGRATION_LOCK_STALE_MS) return false;
+      logger.warn(
+        { stalePid: parsed.pid, age: now - parsed.acquiredAt },
+        "\u68C0\u6D4B\u5230\u50F5\u5C38\u8FC1\u79FB\u9501\uFF0C\u5F3A\u5236\u593A\u53D6"
+      );
+    } catch {
+    }
+  }
+  db.prepare(`
+    INSERT INTO metadata (key, value)
+    VALUES (?, ?)
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value
+  `).run(METADATA_KEY_LANCEDB_MIGRATION_LOCK, lockValue);
+  const reread = getMetadata(db, METADATA_KEY_LANCEDB_MIGRATION_LOCK);
+  if (reread !== lockValue) return false;
+  return true;
+}
+function releaseLanceDbMigrationLock(db) {
+  db.prepare("DELETE FROM metadata WHERE key = ?").run(METADATA_KEY_LANCEDB_MIGRATION_LOCK);
+}
 
 export {
   isChunksFtsInitialized,
@@ -539,6 +768,11 @@ export {
   isFtsInitialized,
   generateProjectId,
   initDb,
+  migrateSchema,
+  insertPendingMarks,
+  deletePendingMarks,
+  replayPendingMarks,
+  countPendingMarks,
   closeDb,
   getAllFileMeta,
   getFilesNeedingVectorIndex,
@@ -550,6 +784,17 @@ export {
   batchDelete,
   clear,
   getStoredEmbeddingDimensions,
-  setStoredEmbeddingDimensions
+  setStoredEmbeddingDimensions,
+  incrementStat,
+  setStatJson,
+  getStatJson,
+  getAllStats,
+  collectHealthSnapshot,
+  getIndexVersion,
+  incrementIndexVersion,
+  getLanceDbMigrationState,
+  setLanceDbMigrationState,
+  clearAllVectorIndexHash,
+  tryAcquireLanceDbMigrationLock,
+  releaseLanceDbMigrationLock
 };
-//# sourceMappingURL=chunk-6Z4JEEVJ.js.map

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-RJURH22T.js → chunk-SKBAE26T.js}

@@ -263,4 +263,3 @@ export {
   getRerankerConfig,
   getExcludePatterns
 };
-//# sourceMappingURL=chunk-RJURH22T.js.map

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