chatlab-cli 0.34.2 → 0.34.3

package/dist/{chunk-INBJ7SND.mjs → chunk-2WYXD5ZP.mjs}

@@ -4273,7 +4273,8 @@ function getLaughAnalysis(db, filter, keywords) {
     totalMessages: 0,
     groupLaughRate: 0
   };
-  const laughKeywords = keywords && keywords.length > 0 ? keywords : [];
+  const laughKeywords = keywords?.map((keyword) => keyword.trim()).filter(Boolean) ?? [];
+  if (laughKeywords.length === 0) return emptyResult;
   const patterns = laughKeywords.map(keywordToPattern);
   const laughRegex = new RegExp(`(${patterns.join("|")})`, "gi");
   const { clause, params } = buildTimeFilter(filter);
@@ -6223,8 +6224,8 @@ function getJourneyStats(db, filter) {
   const indexAvailable = hasSessionIndex(db) && hasTable(db, "message_context");
   const segmentRows = indexAvailable ? querySegmentRows(db, effectiveFilter) : [];
   const segmentCountByMonth = /* @__PURE__ */ new Map();
-  for (const segment2 of segmentRows) {
-    segmentCountByMonth.set(segment2.startMonth, (segmentCountByMonth.get(segment2.startMonth) ?? 0) + 1);
+  for (const segment of segmentRows) {
+    segmentCountByMonth.set(segment.startMonth, (segmentCountByMonth.get(segment.startMonth) ?? 0) + 1);
   }
   const firstRow = monthlyRows[0];
   const lastRow = monthlyRows[monthlyRows.length - 1];
@@ -7702,7 +7703,7 @@ function mergeMembers2(sources, collidingIds) {
 }
 
 // ../../packages/core/src/schema/tables.ts
-var CURRENT_SCHEMA_VERSION = 8;
+var CURRENT_SCHEMA_VERSION = 9;
 var CHAT_DB_TABLES = `
   CREATE TABLE IF NOT EXISTS meta (
     name TEXT NOT NULL,
@@ -7776,13 +7777,6 @@ var CHAT_DB_INDEXES = `
   CREATE INDEX IF NOT EXISTS idx_context_segment ON message_context(segment_id);
 `;
 var CHAT_DB_SCHEMA = CHAT_DB_TABLES + CHAT_DB_INDEXES;
-var FTS_TABLE_SCHEMA = `
-  CREATE VIRTUAL TABLE IF NOT EXISTS message_fts USING fts5(
-    content,
-    content='',
-    content_rowid=id
-  );
-`;
 
 // ../../packages/core/src/schema/migrations.ts
 function getSchemaVersion(db) {
@@ -8040,282 +8034,30 @@ var appLogger = {
   getLogPath: () => instance?.getLogPath() ?? null
 };
 
-// ../../packages/node-runtime/src/nlp/segmenter.ts
-import * as fs8 from "fs";
-import * as path13 from "path";
-import { createRequire } from "module";
-var _nlpDir = null;
-var jiebaInstances = /* @__PURE__ */ new Map();
-var require2 = createRequire(import.meta.url);
-function initNlpDir(nlpDir) {
-  _nlpDir = nlpDir;
-}
-function getNlpDir() {
-  return _nlpDir;
-}
-function existsDictOnDisk(dictId) {
-  if (!_nlpDir) return false;
-  return fs8.existsSync(path13.join(_nlpDir, `${dictId}.dict`));
-}
-function tryLoadDictFromDisk(dictId) {
-  if (!_nlpDir) return null;
-  const dictPath = path13.join(_nlpDir, `${dictId}.dict`);
-  if (!fs8.existsSync(dictPath)) return null;
-  try {
-    return fs8.readFileSync(dictPath);
-  } catch {
-    return null;
-  }
-}
-function getJieba(dictType = "default") {
-  const effectiveType = dictType === "default" ? "zh-CN" : dictType;
-  const cached = jiebaInstances.get(effectiveType);
-  if (cached) {
-    if (cached.fromDiskDict === existsDictOnDisk(effectiveType)) return cached.instance;
-    jiebaInstances.delete(effectiveType);
-    console.error(`[NLP] jieba cache invalidated (dict ${cached.fromDiskDict ? "removed" : "added"}): ${effectiveType}`);
-  }
-  try {
-    const { Jieba } = require2("@node-rs/jieba");
-    let instance2;
-    const diskDict = tryLoadDictFromDisk(effectiveType);
-    if (diskDict) {
-      instance2 = Jieba.withDict(diskDict);
-      console.error(`[NLP] jieba dict loaded: ${effectiveType} (${diskDict.length} bytes)`);
-    } else {
-      instance2 = new Jieba();
-      console.warn(`[NLP] jieba dict missing: ${effectiveType}, fallback to built-in tokenizer`);
-    }
-    jiebaInstances.set(effectiveType, { instance: instance2, fromDiskDict: !!diskDict });
-    return instance2;
-  } catch (error) {
-    console.error(`[NLP] Failed to load jieba module (dict=${effectiveType}):`, error);
-    throw new Error(`jieba \u6A21\u5757\u52A0\u8F7D\u5931\u8D25 (${effectiveType})`);
-  }
-}
-function clearJiebaInstance(dictType) {
-  jiebaInstances.delete(dictType);
-  console.error(`[NLP] jieba instance cleared: ${dictType}`);
-}
-function segmentChinese(text, options = {}) {
-  const { posFilterMode = "meaningful", customPosTags, dictType = "default" } = options;
-  const cleaned = cleanText(text);
-  if (!cleaned) return [];
-  try {
-    const jieba = getJieba(dictType);
-    if (posFilterMode === "all") return jieba.cut(cleaned, false);
-    const tagged = jieba.tag(cleaned);
-    const allowedTags = posFilterMode === "custom" && customPosTags ? new Set(customPosTags) : MEANINGFUL_POS_TAGS;
-    return tagged.filter((item) => allowedTags.has(item.tag)).map((item) => item.word);
-  } catch (error) {
-    console.error("[NLP] Chinese segmentation failed:", error);
-    try {
-      return getJieba("default").cut(cleanText(text), false);
-    } catch {
-      return cleaned.split("");
-    }
-  }
-}
-function segmentEnglish(text) {
-  const cleaned = cleanText(text);
-  if (!cleaned) return [];
-  try {
-    const segmenter = new Intl.Segmenter("en", { granularity: "word" });
-    return [...segmenter.segment(cleaned)].filter((s) => s.isWordLike).map((s) => s.segment.toLowerCase());
-  } catch {
-    return cleaned.toLowerCase().split(/\s+/).filter((w) => w.length > 0);
-  }
-}
-function segmentJapanese(text) {
-  const cleaned = cleanText(text);
-  if (!cleaned) return [];
-  try {
-    const segmenter = new Intl.Segmenter("ja", { granularity: "word" });
-    return [...segmenter.segment(cleaned)].filter((s) => s.isWordLike).map((s) => s.segment);
-  } catch {
-    return cleaned.split("").filter((ch) => ch.trim().length > 0);
-  }
-}
-function segment(text, locale, options = {}) {
-  const {
-    minLength,
-    posFilterMode = "meaningful",
-    customPosTags,
-    enableStopwords = true,
-    dictType = "default"
-  } = options;
-  const isChinese = locale.startsWith("zh");
-  const isJapanese = locale === "ja-JP";
-  const defaultMinLength = isChinese || isJapanese ? 2 : 3;
-  const effectiveMinLength = minLength ?? defaultMinLength;
-  let words;
-  if (isChinese) {
-    words = segmentChinese(text, { posFilterMode, customPosTags, dictType });
-  } else if (isJapanese) {
-    words = segmentJapanese(text);
-  } else {
-    words = segmentEnglish(text);
-  }
-  return words.filter((word) => isValidWord(word, locale, effectiveMinLength, enableStopwords, isStopword));
-}
-function batchSegmentWithFrequency(texts, locale, options = {}) {
-  const {
-    minLength,
-    minCount = 2,
-    topN = 100,
-    posFilterMode,
-    customPosTags,
-    enableStopwords,
-    dictType,
-    excludeWords
-  } = options;
-  const wordFrequency = /* @__PURE__ */ new Map();
-  const excludeSet = excludeWords?.length ? new Set(excludeWords.map((w) => w.toLowerCase())) : null;
-  for (const text of texts) {
-    const words = segment(text, locale, { minLength, posFilterMode, customPosTags, enableStopwords, dictType });
-    for (const word of words) {
-      if (excludeSet && excludeSet.has(word.toLowerCase())) continue;
-      wordFrequency.set(word, (wordFrequency.get(word) || 0) + 1);
-    }
-  }
-  const filtered = /* @__PURE__ */ new Map();
-  let totalWords = 0;
-  for (const [word, count] of wordFrequency) {
-    if (count >= minCount) {
-      filtered.set(word, count);
-      totalWords += count;
-    }
-  }
-  const sorted = [...filtered.entries()].sort((a, b) => b[1] - a[1]).slice(0, topN);
-  return { words: new Map(sorted), uniqueWords: filtered.size, totalWords };
-}
-function batchSegmentChineseWithStats(texts, locale, options = {}) {
-  const {
-    minLength,
-    minCount = 2,
-    topN = 100,
-    posFilterMode = "meaningful",
-    customPosTags,
-    enableStopwords = true,
-    dictType = "default",
-    excludeWords
-  } = options;
-  const effectiveMinLength = minLength ?? 2;
-  const allowedTags = posFilterMode === "custom" && customPosTags ? new Set(customPosTags) : MEANINGFUL_POS_TAGS;
-  const excludeSet = excludeWords?.length ? new Set(excludeWords.map((w) => w.toLowerCase())) : null;
-  const wordFrequency = /* @__PURE__ */ new Map();
-  const posTagStats = /* @__PURE__ */ new Map();
-  try {
-    const jieba = getJieba(dictType);
-    for (const text of texts) {
-      const cleaned = cleanText(text);
-      if (!cleaned) continue;
-      for (const { tag, word } of jieba.tag(cleaned)) {
-        if (!isValidWord(word, locale, effectiveMinLength, enableStopwords, isStopword)) continue;
-        posTagStats.set(tag, (posTagStats.get(tag) || 0) + 1);
-        if (!allowedTags.has(tag)) continue;
-        if (excludeSet && excludeSet.has(word.toLowerCase())) continue;
-        wordFrequency.set(word, (wordFrequency.get(word) || 0) + 1);
-      }
-    }
-  } catch (error) {
-    console.error("[NLP] Chinese single-pass segmentation failed:", error);
-  }
-  const filtered = /* @__PURE__ */ new Map();
-  let totalWords = 0;
-  for (const [word, count] of wordFrequency) {
-    if (count >= minCount) {
-      filtered.set(word, count);
-      totalWords += count;
-    }
-  }
-  const sorted = [...filtered.entries()].sort((a, b) => b[1] - a[1]).slice(0, topN);
-  return { words: new Map(sorted), uniqueWords: filtered.size, totalWords, posTagStats };
-}
-function collectPosTagStats(texts, minWordLength = 2, enableStopwords = true, dictType = "default") {
-  const posStats = /* @__PURE__ */ new Map();
-  try {
-    const jieba = getJieba(dictType);
-    for (const text of texts) {
-      const cleaned = cleanText(text);
-      if (!cleaned) continue;
-      const tagged = jieba.tag(cleaned);
-      for (const item of tagged) {
-        if (!isValidWord(item.word, "zh-CN", minWordLength, enableStopwords, isStopword)) continue;
-        posStats.set(item.tag, (posStats.get(item.tag) || 0) + 1);
-      }
-    }
-  } catch (error) {
-    console.error("[NLP] Failed to collect POS stats:", error);
-  }
-  return posStats;
-}
-function getPosTagDefinitions() {
-  return POS_TAG_DEFINITIONS;
-}
-
-// ../../packages/node-runtime/src/nlp/fts-tokenizer.ts
-function tokenizeForFts(text) {
-  if (!text || text.trim().length === 0) return "";
-  try {
-    const jieba = getJieba();
-    const tokens = jieba.cut(text, false);
-    return tokens.map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0).join(" ");
-  } catch {
-    return fallbackTokenize(text);
-  }
-}
-function fallbackTokenize(text) {
-  return text.toLowerCase().split(/\s+/).filter((t) => t.length > 0).join(" ");
-}
-function escapeToken(token) {
-  return `"${token.replace(/"/g, '""')}"`;
-}
-function tokenizeQueryForFts(keywords) {
-  if (keywords.length === 0) return "";
-  const groups = keywords.map((kw) => {
-    const trimmed = kw.trim();
-    if (!trimmed) return "";
-    try {
-      const jieba = getJieba();
-      const tokens = jieba.cut(trimmed, false).map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0);
-      if (tokens.length === 0) return "";
-      if (tokens.length === 1) return escapeToken(tokens[0]);
-      return tokens.map(escapeToken).join(" ");
-    } catch {
-      const simple = trimmed.toLowerCase().trim();
-      return simple ? escapeToken(simple) : "";
-    }
-  }).filter((g) => g.length > 0);
-  if (groups.length === 0) return "";
-  if (groups.length === 1) return groups[0];
-  return groups.map((g) => g.includes(" ") ? `(${g})` : g).join(" OR ");
-}
-
 // ../../packages/node-runtime/src/migrations/electron-data-migration.ts
-import * as fs9 from "fs";
+import * as fs8 from "fs";
 import * as os3 from "os";
-import * as path14 from "path";
+import * as path13 from "path";
 var SYSTEM_SUBDIRS = ["ai", "settings", "cache", "logs", "nlp"];
 var STORAGE_CONFIG_FILE = "storage.json";
 function getElectronUserDataDir(options = {}) {
   const home = options.homeDir ?? os3.homedir();
   switch (options.platform ?? process.platform) {
     case "darwin":
-      return path14.join(home, "Library", "Application Support", "ChatLab");
+      return path13.join(home, "Library", "Application Support", "ChatLab");
     case "win32": {
-      const appData = options.appDataDir ?? process.env.APPDATA ?? path14.join(home, "AppData", "Roaming");
-      return path14.join(appData, "ChatLab");
+      const appData = options.appDataDir ?? process.env.APPDATA ?? path13.join(home, "AppData", "Roaming");
+      return path13.join(appData, "ChatLab");
     }
     default:
-      return path14.join(home, ".config", "ChatLab");
+      return path13.join(home, ".config", "ChatLab");
   }
 }
 function readElectronStorageConfig(electronUserData) {
-  const configPath = path14.join(electronUserData, STORAGE_CONFIG_FILE);
-  if (!fs9.existsSync(configPath)) return {};
+  const configPath = path13.join(electronUserData, STORAGE_CONFIG_FILE);
+  if (!fs8.existsSync(configPath)) return {};
   try {
-    return JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+    return JSON.parse(fs8.readFileSync(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -8323,45 +8065,45 @@ function readElectronStorageConfig(electronUserData) {
 function resolveElectronDataDir() {
   const electronUserData = getElectronUserDataDir();
   const storageConfig = readElectronStorageConfig(electronUserData);
-  if (storageConfig.dataDir && path14.isAbsolute(storageConfig.dataDir)) {
+  if (storageConfig.dataDir && path13.isAbsolute(storageConfig.dataDir)) {
     return storageConfig.dataDir;
   }
-  return path14.join(electronUserData, "data");
+  return path13.join(electronUserData, "data");
 }
 function hasDatabases(dir) {
-  const dbDir = path14.join(dir, "databases");
-  if (!fs9.existsSync(dbDir)) return false;
+  const dbDir = path13.join(dir, "databases");
+  if (!fs8.existsSync(dbDir)) return false;
   try {
-    return fs9.readdirSync(dbDir).some((f) => f.endsWith(".db"));
+    return fs8.readdirSync(dbDir).some((f) => f.endsWith(".db"));
   } catch {
     return false;
   }
 }
 function ensureDir2(dirPath) {
-  if (!fs9.existsSync(dirPath)) {
-    fs9.mkdirSync(dirPath, { recursive: true });
+  if (!fs8.existsSync(dirPath)) {
+    fs8.mkdirSync(dirPath, { recursive: true });
   }
 }
 function copyDirMerge(src, dest) {
   const stats = { copied: 0, skipped: 0 };
-  if (!fs9.existsSync(src)) return stats;
+  if (!fs8.existsSync(src)) return stats;
   ensureDir2(dest);
   let entries;
   try {
-    entries = fs9.readdirSync(src, { withFileTypes: true });
+    entries = fs8.readdirSync(src, { withFileTypes: true });
   } catch {
     return stats;
   }
   for (const entry of entries) {
-    const srcPath = path14.join(src, entry.name);
-    const destPath = path14.join(dest, entry.name);
+    const srcPath = path13.join(src, entry.name);
+    const destPath = path13.join(dest, entry.name);
     try {
       if (entry.isDirectory()) {
         const sub = copyDirMerge(srcPath, destPath);
         stats.copied += sub.copied;
         stats.skipped += sub.skipped;
-      } else if (!fs9.existsSync(destPath)) {
-        fs9.copyFileSync(srcPath, destPath);
+      } else if (!fs8.existsSync(destPath)) {
+        fs8.copyFileSync(srcPath, destPath);
         stats.copied++;
       } else {
         stats.skipped++;
@@ -8374,22 +8116,22 @@ function copyDirMerge(src, dest) {
 function writeMigrationLog(logDir, message) {
   try {
     ensureDir2(logDir);
-    const logPath = path14.join(logDir, "app.log");
+    const logPath = path13.join(logDir, "app.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-    fs9.appendFileSync(logPath, `[${ts}] [MIGRATION] ${message}
+    fs8.appendFileSync(logPath, `[${ts}] [MIGRATION] ${message}
 `, "utf-8");
   } catch {
   }
 }
 function wasElectronUsed() {
   const electronUserData = getElectronUserDataDir();
-  if (!fs9.existsSync(electronUserData)) return false;
-  return fs9.existsSync(path14.join(electronUserData, "Preferences")) || fs9.existsSync(path14.join(electronUserData, "Local Storage")) || fs9.existsSync(path14.join(electronUserData, "Session Storage")) || fs9.existsSync(path14.join(electronUserData, "data"));
+  if (!fs8.existsSync(electronUserData)) return false;
+  return fs8.existsSync(path13.join(electronUserData, "Preferences")) || fs8.existsSync(path13.join(electronUserData, "Local Storage")) || fs8.existsSync(path13.join(electronUserData, "Session Storage")) || fs8.existsSync(path13.join(electronUserData, "data"));
 }
 function verifyCliDataPath(databaseDir) {
-  if (fs9.existsSync(databaseDir)) {
+  if (fs8.existsSync(databaseDir)) {
     try {
-      if (fs9.readdirSync(databaseDir).some((f) => f.endsWith(".db"))) return true;
+      if (fs8.readdirSync(databaseDir).some((f) => f.endsWith(".db"))) return true;
     } catch {
     }
   }
@@ -8407,9 +8149,9 @@ function migrateFromElectronIfNeeded(systemDir) {
     let totalSkipped = 0;
     const movedDirs = [];
     for (const subDir of SYSTEM_SUBDIRS) {
-      const srcDir = path14.join(electronDataDir, subDir);
-      const destDir = path14.join(systemDir, subDir);
-      if (!fs9.existsSync(srcDir)) continue;
+      const srcDir = path13.join(electronDataDir, subDir);
+      const destDir = path13.join(systemDir, subDir);
+      if (!fs8.existsSync(srcDir)) continue;
       const { copied, skipped } = copyDirMerge(srcDir, destDir);
       if (copied > 0 || skipped > 0) {
         movedDirs.push(subDir);
@@ -8419,13 +8161,13 @@ function migrateFromElectronIfNeeded(systemDir) {
       }
     }
     for (const subDir of movedDirs) {
-      const srcDir = path14.join(electronDataDir, subDir);
+      const srcDir = path13.join(electronDataDir, subDir);
       try {
-        fs9.rmSync(srcDir, { recursive: true, force: true });
+        fs8.rmSync(srcDir, { recursive: true, force: true });
       } catch {
       }
     }
-    const logsDir = path14.join(systemDir, "logs");
+    const logsDir = path13.join(systemDir, "logs");
     const summary = `CLI first-run: detected Electron data at ${electronDataDir}, pointed user_data_dir there, copied ${totalCopied} system files (${movedDirs.join(", ") || "none"})`;
     writeMigrationLog(logsDir, summary);
     console.log(`[Migration] ${summary}`);
@@ -8439,7 +8181,7 @@ function migrateFromElectronIfNeeded(systemDir) {
     const errorMsg = error instanceof Error ? error.message : String(error);
     console.error("[Migration] Electron data migration failed:", errorMsg);
     try {
-      writeMigrationLog(path14.join(systemDir, "logs"), `Electron migration failed: ${errorMsg}`);
+      writeMigrationLog(path13.join(systemDir, "logs"), `Electron migration failed: ${errorMsg}`);
     } catch {
     }
     return { migrated: false, electronDetected: true, error: errorMsg };
@@ -8447,26 +8189,26 @@ function migrateFromElectronIfNeeded(systemDir) {
 }
 
 // ../../packages/node-runtime/src/cache/session-cache.ts
-import * as fs10 from "fs";
-import * as path15 from "path";
+import * as fs9 from "fs";
+import * as path14 from "path";
 function getCachePath(sessionId, cacheDir) {
-  return path15.join(cacheDir, `${sessionId}.cache.json`);
+  return path14.join(cacheDir, `${sessionId}.cache.json`);
 }
 function readCacheFile(cachePath) {
   try {
-    if (!fs10.existsSync(cachePath)) return null;
-    return JSON.parse(fs10.readFileSync(cachePath, "utf-8"));
+    if (!fs9.existsSync(cachePath)) return null;
+    return JSON.parse(fs9.readFileSync(cachePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCacheFile(cachePath, content) {
   try {
-    const dir = path15.dirname(cachePath);
-    if (!fs10.existsSync(dir)) {
-      fs10.mkdirSync(dir, { recursive: true });
+    const dir = path14.dirname(cachePath);
+    if (!fs9.existsSync(dir)) {
+      fs9.mkdirSync(dir, { recursive: true });
     }
-    fs10.writeFileSync(cachePath, JSON.stringify(content), "utf-8");
+    fs9.writeFileSync(cachePath, JSON.stringify(content), "utf-8");
   } catch {
   }
 }
@@ -8486,7 +8228,7 @@ function invalidateCache(sessionId, cacheDir, key) {
   const cachePath = getCachePath(sessionId, cacheDir);
   try {
     if (!key) {
-      if (fs10.existsSync(cachePath)) fs10.unlinkSync(cachePath);
+      if (fs9.existsSync(cachePath)) fs9.unlinkSync(cachePath);
     } else {
       const file = readCacheFile(cachePath);
       if (file && file[key]) {
@@ -8500,7 +8242,7 @@ function invalidateCache(sessionId, cacheDir, key) {
 function deleteSessionCache(sessionId, cacheDir) {
   const cachePath = getCachePath(sessionId, cacheDir);
   try {
-    if (fs10.existsSync(cachePath)) fs10.unlinkSync(cachePath);
+    if (fs9.existsSync(cachePath)) fs9.unlinkSync(cachePath);
   } catch {
   }
 }
@@ -8554,8 +8296,8 @@ function computeAndSetMembersCache(db, sessionId, cacheDir) {
 }
 
 // ../../packages/node-runtime/src/data-dir-compat.ts
-import fs11 from "fs";
-import path16 from "path";
+import fs10 from "fs";
+import path15 from "path";
 var DataDirCompatibilityError = class extends Error {
   code;
   userDataDir;
@@ -8575,10 +8317,10 @@ var DataDirCompatibilityError = class extends Error {
 };
 function readDataDirCompatibilityMeta(userDataDir) {
   const metaPath = getMetaPath(userDataDir);
-  if (!fs11.existsSync(metaPath)) return null;
+  if (!fs10.existsSync(metaPath)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(fs11.readFileSync(metaPath, "utf-8"));
+    parsed = JSON.parse(fs10.readFileSync(metaPath, "utf-8"));
   } catch (error) {
     throw createInvalidMetaError(userDataDir, metaPath, "Invalid data directory compatibility meta JSON.", error);
   }
@@ -8661,7 +8403,7 @@ function raiseDataDirMinRuntimeVersion(pathProvider, input) {
   return nextMeta;
 }
 function getMetaPath(userDataDir) {
-  return path16.join(userDataDir, ".chatlab-meta.json");
+  return path15.join(userDataDir, ".chatlab-meta.json");
 }
 function validateDataDirCompatibilityMeta(value, userDataDir, metaPath) {
   if (!isRecord2(value)) {
@@ -8732,15 +8474,15 @@ function mergeReasons(existing, next) {
   return [.../* @__PURE__ */ new Set([...existing, next])];
 }
 function writeMetaAtomic(userDataDir, metaPath, meta) {
-  fs11.mkdirSync(userDataDir, { recursive: true });
-  const tempPath = path16.join(userDataDir, `.chatlab-meta.json.${process.pid}.${Date.now()}.tmp`);
+  fs10.mkdirSync(userDataDir, { recursive: true });
+  const tempPath = path15.join(userDataDir, `.chatlab-meta.json.${process.pid}.${Date.now()}.tmp`);
   try {
-    fs11.writeFileSync(tempPath, `${JSON.stringify(meta, null, 2)}
+    fs10.writeFileSync(tempPath, `${JSON.stringify(meta, null, 2)}
 `, "utf-8");
-    fs11.renameSync(tempPath, metaPath);
+    fs10.renameSync(tempPath, metaPath);
   } catch (error) {
     try {
-      if (fs11.existsSync(tempPath)) fs11.unlinkSync(tempPath);
+      if (fs10.existsSync(tempPath)) fs10.unlinkSync(tempPath);
     } catch {
     }
     throw error;
@@ -8777,7 +8519,7 @@ function raiseChatDbCompatibilityGate(pathProvider, runtime) {
     });
   }
 }
-function getChatDbMigrations(deps) {
+function getChatDbMigrations() {
   const hasColumn2 = (db, tableName, columnName) => {
     const tableInfo = db.pragma(`table_info(${tableName})`);
     return tableInfo.some((col) => col.name === columnName);
@@ -8856,39 +8598,8 @@ function getChatDbMigrations(deps) {
     },
     {
       version: 4,
-      description: "Add FTS5 full-text search index",
-      up: (db) => {
-        const hasTable2 = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='message_fts'").get();
-        if (hasTable2) return;
-        db.exec(`
-          CREATE VIRTUAL TABLE IF NOT EXISTS message_fts USING fts5(
-            content,
-            content='',
-            content_rowid=id
-          )
-        `);
-        const tokenize = deps?.tokenizeForFts;
-        if (!tokenize) return;
-        const BATCH_SIZE = 5e3;
-        const insertFts = db.prepare("INSERT INTO message_fts(rowid, content) VALUES (?, ?)");
-        const countRow = db.prepare("SELECT COUNT(*) as total FROM message WHERE type = 0 AND content IS NOT NULL AND content != ''").get();
-        const total = countRow?.total ?? 0;
-        let offset = 0;
-        while (offset < total) {
-          const rows = db.prepare(
-            `SELECT id, content FROM message
-               WHERE type = 0 AND content IS NOT NULL AND content != ''
-               ORDER BY id ASC LIMIT ? OFFSET ?`
-          ).all(BATCH_SIZE, offset);
-          if (rows.length === 0) break;
-          for (const row of rows) {
-            const tokens = tokenize(row.content);
-            if (tokens) {
-              insertFts.run(row.id, tokens);
-            }
-          }
-          offset += BATCH_SIZE;
-        }
+      description: "Preserve the legacy schema migration sequence",
+      up: () => {
       }
     },
     {
@@ -9076,49 +8787,56 @@ function getChatDbMigrations(deps) {
           CREATE INDEX IF NOT EXISTS idx_message_reply_to ON message(reply_to_message_id);
         `);
       }
+    },
+    {
+      version: 9,
+      description: "Remove the obsolete per-session full-text index",
+      up: (db) => {
+        db.exec("DROP TABLE IF EXISTS message_fts");
+      }
     }
   ];
 }
 
 // ../../packages/node-runtime/src/services/contacts/paths.ts
-import path17 from "path";
+import path16 from "path";
 var CONTACTS_DIR_NAME = "contacts";
 var CONTACTS_FACTS_DIR_NAME = "facts";
 function getContactsDir(userDataDir) {
-  return path17.join(userDataDir, CONTACTS_DIR_NAME);
+  return path16.join(userDataDir, CONTACTS_DIR_NAME);
 }
 function getContactsFactsCacheDir(userDataDir) {
-  return path17.join(getContactsDir(userDataDir), CONTACTS_FACTS_DIR_NAME);
+  return path16.join(getContactsDir(userDataDir), CONTACTS_FACTS_DIR_NAME);
 }
 
 // ../../packages/node-runtime/src/services/global-insight/paths.ts
-import path18 from "path";
+import path17 from "path";
 function getGlobalInsightDir(userDataDir) {
-  return path18.join(userDataDir, "insight", "annual-summary");
+  return path17.join(userDataDir, "insight", "annual-summary");
 }
 function getGlobalInsightFactsCacheDir(userDataDir) {
-  return path18.join(getGlobalInsightDir(userDataDir), "facts");
+  return path17.join(getGlobalInsightDir(userDataDir), "facts");
 }
 
 // ../../packages/node-runtime/src/services/people/relationships/paths.ts
-import path19 from "path";
+import path18 from "path";
 var PEOPLE_DIR_NAME = "people";
 var RELATIONSHIPS_DIR_NAME = "relationships";
 var RELATIONSHIPS_FACTS_DIR_NAME = "facts";
 function getPeopleRelationshipsDir(userDataDir) {
-  return path19.join(userDataDir, PEOPLE_DIR_NAME, RELATIONSHIPS_DIR_NAME);
+  return path18.join(userDataDir, PEOPLE_DIR_NAME, RELATIONSHIPS_DIR_NAME);
 }
 function getPeopleRelationshipsFactsCacheDir(userDataDir) {
-  return path19.join(getPeopleRelationshipsDir(userDataDir), RELATIONSHIPS_FACTS_DIR_NAME);
+  return path18.join(getPeopleRelationshipsDir(userDataDir), RELATIONSHIPS_FACTS_DIR_NAME);
 }
 
 // ../../packages/node-runtime/src/database-manager.ts
-import * as fs13 from "fs";
-import * as path21 from "path";
+import * as fs12 from "fs";
+import * as path20 from "path";
 
 // ../../packages/node-runtime/src/services/global-insight/snapshot.ts
-import fs12 from "fs";
-import path20 from "path";
+import fs11 from "fs";
+import path19 from "path";
 
 // ../../packages/node-runtime/src/services/global-insight/time-range.ts
 function normalizeAnnualSummaryRange(input, nowInput = /* @__PURE__ */ new Date()) {
@@ -9169,17 +8887,17 @@ function toAnnualSummaryLocalDate(range) {
 // ../../packages/node-runtime/src/services/global-insight/snapshot.ts
 var SNAPSHOT_TMP_PREFIX = "annual-summary.tmp-";
 function getAnnualSummarySnapshotPath(snapshotDir, range) {
-  return path20.join(snapshotDir, `annual-summary-${toAnnualSummaryRangeKey(range)}.json`);
+  return path19.join(snapshotDir, `annual-summary-${toAnnualSummaryRangeKey(range)}.json`);
 }
 function readAnnualSummarySnapshot(snapshotDir, range, options = {}) {
   const snapshotPath = getAnnualSummarySnapshotPath(snapshotDir, range);
-  if (!fs12.existsSync(snapshotPath)) return null;
+  if (!fs11.existsSync(snapshotPath)) return null;
   try {
-    return JSON.parse(fs12.readFileSync(snapshotPath, "utf-8"));
+    return JSON.parse(fs11.readFileSync(snapshotPath, "utf-8"));
   } catch (error) {
-    const backupPath = path20.join(snapshotDir, `annual-summary.corrupt-${options.now?.() ?? Date.now()}.json`);
+    const backupPath = path19.join(snapshotDir, `annual-summary.corrupt-${options.now?.() ?? Date.now()}.json`);
     try {
-      fs12.renameSync(snapshotPath, backupPath);
+      fs11.renameSync(snapshotPath, backupPath);
     } catch (renameError) {
       appLogger.warn("global-insight", "failed to backup corrupt annual summary snapshot", renameError);
     }
@@ -9188,28 +8906,28 @@ function readAnnualSummarySnapshot(snapshotDir, range, options = {}) {
   }
 }
 function writeAnnualSummarySnapshot(snapshotDir, snapshot) {
-  fs12.mkdirSync(snapshotDir, { recursive: true });
-  const tmpPath = path20.join(snapshotDir, `${SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`);
-  fs12.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
-  fs12.renameSync(tmpPath, getAnnualSummarySnapshotPath(snapshotDir, snapshot.range));
+  fs11.mkdirSync(snapshotDir, { recursive: true });
+  const tmpPath = path19.join(snapshotDir, `${SNAPSHOT_TMP_PREFIX}${process.pid}-${Date.now()}`);
+  fs11.writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), "utf-8");
+  fs11.renameSync(tmpPath, getAnnualSummarySnapshotPath(snapshotDir, snapshot.range));
 }
 function cleanupAnnualSummarySnapshotTempFiles(snapshotDir) {
-  if (!fs12.existsSync(snapshotDir)) return;
-  for (const name of fs12.readdirSync(snapshotDir)) {
+  if (!fs11.existsSync(snapshotDir)) return;
+  for (const name of fs11.readdirSync(snapshotDir)) {
     if (!name.startsWith(SNAPSHOT_TMP_PREFIX)) continue;
     try {
-      fs12.rmSync(path20.join(snapshotDir, name), { force: true });
+      fs11.rmSync(path19.join(snapshotDir, name), { force: true });
     } catch (error) {
       appLogger.warn("global-insight", "failed to remove annual summary snapshot temp file", error);
     }
   }
 }
 function deleteAnnualSummarySnapshots(snapshotDir) {
-  if (!fs12.existsSync(snapshotDir)) return;
-  for (const name of fs12.readdirSync(snapshotDir)) {
+  if (!fs11.existsSync(snapshotDir)) return;
+  for (const name of fs11.readdirSync(snapshotDir)) {
     if (!name.startsWith("annual-summary-") && !name.startsWith("annual-summary.")) continue;
     try {
-      fs12.rmSync(path20.join(snapshotDir, name), { force: true });
+      fs11.rmSync(path19.join(snapshotDir, name), { force: true });
     } catch (error) {
       appLogger.warn("global-insight", "failed to remove annual summary snapshot", error);
     }
@@ -9217,15 +8935,9 @@ function deleteAnnualSummarySnapshots(snapshotDir) {
 }
 
 // ../../packages/node-runtime/src/database-manager.ts
-function createMigrationDeps(overrides) {
-  return {
-    tokenizeForFts,
-    ...overrides
-  };
-}
 function listDatabaseCandidateIds(databaseDir) {
-  if (!fs13.existsSync(databaseDir)) return [];
-  return fs13.readdirSync(databaseDir).filter((fileName) => fileName.endsWith(".db") && !fileName.startsWith("._")).map((fileName) => fileName.slice(0, -3));
+  if (!fs12.existsSync(databaseDir)) return [];
+  return fs12.readdirSync(databaseDir).filter((fileName) => fileName.endsWith(".db") && !fileName.startsWith("._")).map((fileName) => fileName.slice(0, -3));
 }
 var DatabaseManager = class {
   constructor(pathProvider, options = {}) {
@@ -9234,13 +8946,11 @@ var DatabaseManager = class {
       throw new Error("DatabaseManager runtime identity is required for data directory compatibility checks.");
     }
     this.nativeBinding = options?.nativeBinding;
-    this.migrationDeps = createMigrationDeps(options?.migrationDeps);
     this.runtime = options?.runtime ?? null;
   }
   pathProvider;
   cache = /* @__PURE__ */ new Map();
   nativeBinding;
-  migrationDeps;
   runtime;
   /**
    * Open a session DB (read-only by default, cached).
@@ -9251,7 +8961,7 @@ var DatabaseManager = class {
       return this.cache.get(sessionId);
     }
     const dbPath = this.getDbPath(sessionId);
-    if (!fs13.existsSync(dbPath)) return null;
+    if (!fs12.existsSync(dbPath)) return null;
     this.migrateIfNeeded(dbPath);
     this.assertCompatible();
     const adapter = openBetterSqliteDatabase(dbPath, {
@@ -9278,7 +8988,7 @@ var DatabaseManager = class {
       nativeBinding: this.nativeBinding
     });
     try {
-      const migrations = getChatDbMigrations(this.migrationDeps);
+      const migrations = getChatDbMigrations();
       this.runMigrations(adapter, migrations);
     } finally {
       adapter.close();
@@ -9297,13 +9007,13 @@ var DatabaseManager = class {
       this.cache.delete(sessionId);
     }
     const dbPath = this.getDbPath(sessionId);
-    if (!fs13.existsSync(dbPath)) return null;
+    if (!fs12.existsSync(dbPath)) return null;
     const adapter = openBetterSqliteDatabase(dbPath, {
       readonly: false,
       nativeBinding: this.nativeBinding
     });
     if (needsMigration(adapter, CURRENT_SCHEMA_VERSION)) {
-      const migrations = getChatDbMigrations(this.migrationDeps);
+      const migrations = getChatDbMigrations();
       this.runMigrations(adapter, migrations);
       this.assertCompatible();
     } else {
@@ -9365,17 +9075,17 @@ var DatabaseManager = class {
    * 获取数据库文件路径
    */
   getDbPath(sessionId) {
-    return path21.join(this.pathProvider.getDatabaseDir(), `${sessionId}.db`);
+    return path20.join(this.pathProvider.getDatabaseDir(), `${sessionId}.db`);
   }
   openRawSessionDatabase(sessionId, options = {}) {
     this.assertCompatible();
     const dbPath = this.getDbPath(sessionId);
-    if (!options.create && !fs13.existsSync(dbPath)) {
+    if (!options.create && !fs12.existsSync(dbPath)) {
       throw new Error(`Session database not found: ${sessionId}`);
     }
     if (!options.readonly) {
       this.close(sessionId);
-      fs13.mkdirSync(path21.dirname(dbPath), { recursive: true });
+      fs12.mkdirSync(path20.dirname(dbPath), { recursive: true });
     }
     const adapter = openBetterSqliteDatabase(dbPath, {
       readonly: options.readonly ?? false,
@@ -9393,17 +9103,17 @@ var DatabaseManager = class {
   deleteSessionDatabaseFiles(sessionId) {
     this.close(sessionId);
     const dbPath = this.getDbPath(sessionId);
-    const existed = ["", "-wal", "-shm"].some((suffix) => fs13.existsSync(dbPath + suffix));
+    const existed = ["", "-wal", "-shm"].some((suffix) => fs12.existsSync(dbPath + suffix));
     for (const suffix of ["", "-wal", "-shm"]) {
       try {
         const filePath = dbPath + suffix;
-        if (fs13.existsSync(filePath)) fs13.unlinkSync(filePath);
+        if (fs12.existsSync(filePath)) fs12.unlinkSync(filePath);
       } catch {
       }
     }
     const cacheDir = this.pathProvider.getCacheDir();
     deleteSessionCache(sessionId, cacheDir);
-    deleteSessionCache(sessionId, path21.join(cacheDir, "query"));
+    deleteSessionCache(sessionId, path20.join(cacheDir, "query"));
     deleteSessionCache(sessionId, getContactsFactsCacheDir(this.pathProvider.getUserDataDir()));
     deleteSessionCache(sessionId, getGlobalInsightFactsCacheDir(this.pathProvider.getUserDataDir()));
     deleteAnnualSummarySnapshots(getGlobalInsightDir(this.pathProvider.getUserDataDir()));
@@ -9444,12 +9154,12 @@ function shouldRepairCompatibilityGate(schemaVersion) {
 }
 
 // ../../packages/node-runtime/src/cache/analytics-cache.ts
-import * as fs14 from "fs";
+import * as fs13 from "fs";
 function getDbFileVersion(dbPath) {
   const parts = [];
   for (const p of [dbPath, `${dbPath}-wal`]) {
     try {
-      const st = fs14.statSync(p);
+      const st = fs13.statSync(p);
       parts.push(`${Math.floor(st.mtimeMs)}:${st.size}`);
     } catch {
       parts.push("-");
@@ -9605,6 +9315,8 @@ export {
   POS_TAG_DEFINITIONS,
   MEANINGFUL_POS_TAGS,
   isStopword,
+  cleanText,
+  isValidWord,
   buildExcludeKeywordsConditions,
   getMentionAnalysis,
   getMentionGraph,
@@ -9683,28 +9395,17 @@ export {
   generateMessageKey,
   writeParseResultToDb,
   getCollidingPlatformIds,
+  getCollidingPlatformIdsFromMessages,
   normalizePlatformId,
   detectConflictsInMessages,
   mergeMembers2,
   CHAT_DB_INDEXES,
   CHAT_DB_SCHEMA,
-  FTS_TABLE_SCHEMA,
   AiLogger,
   extractErrorInfo,
   extractErrorStack,
   initAppLogger,
   appLogger,
-  initNlpDir,
-  getNlpDir,
-  getJieba,
-  clearJiebaInstance,
-  segment,
-  batchSegmentWithFrequency,
-  batchSegmentChineseWithStats,
-  collectPosTagStats,
-  getPosTagDefinitions,
-  tokenizeForFts,
-  tokenizeQueryForFts,
   wasElectronUsed,
   verifyCliDataPath,
   migrateFromElectronIfNeeded,
@@ -9747,4 +9448,4 @@ export {
   StaticPathProvider,
   createDatabaseManagerAdapter
 };
-//# sourceMappingURL=chunk-INBJ7SND.mjs.map
+//# sourceMappingURL=chunk-2WYXD5ZP.mjs.map