@huyooo/ai-search 0.2.1

package/dist/chunk-YJIIX54F.js

@@ -0,0 +1,4239 @@
+// src/core/search.ts
+import * as fs7 from "fs/promises";
+import * as path10 from "path";
+
+// src/types.ts
+var FileType = {
+  FOLDER: "folder",
+  FILE: "file",
+  IMAGE: "image",
+  VIDEO: "video",
+  MUSIC: "music",
+  DOCUMENT: "document",
+  CODE: "code",
+  TEXT: "text",
+  PDF: "pdf",
+  ARCHIVE: "archive",
+  APPLICATION: "application",
+  UNKNOWN: "unknown"
+};
+var DEFAULT_CONFIG = {
+  // 排除目录（这些会被合并到规则管理器的 excludedPaths 中）
+  excludeDirs: [
+    "node_modules",
+    ".git",
+    ".svn",
+    "__pycache__",
+    ".cache",
+    ".Trash",
+    "Library",
+    "AppData",
+    "$RECYCLE.BIN"
+  ],
+  // 支持的扩展名（这些会被合并到规则管理器的 allowed extensions 中）
+  extensions: [
+    ".docx",
+    ".doc",
+    ".pdf",
+    ".xlsx",
+    ".xls",
+    ".pptx",
+    ".ppt",
+    ".txt",
+    ".md",
+    ".rtf"
+  ],
+  maxFileSize: 50 * 1024 * 1024,
+  // 50MB
+  embeddingModel: "doubao-embedding-vision-250615",
+  embeddingDimension: 1024,
+  // 向量维度
+  indexConcurrency: 5,
+  // 并行索引并发数
+  enableParallelIndexing: true
+  // 默认启用并行索引
+};
+
+// src/storage/vector.ts
+import * as lancedb from "@lancedb/lancedb";
+var VectorStore = class {
+  db = null;
+  table = null;
+  dbPath;
+  tableName;
+  dimension;
+  constructor(dbPath, tableName = "documents", dimension = 384) {
+    this.dbPath = dbPath;
+    this.tableName = tableName;
+    this.dimension = dimension;
+  }
+  /**
+   * 初始化连接
+   */
+  async init() {
+    this.db = await lancedb.connect(this.dbPath);
+    try {
+      this.table = await this.db.openTable(this.tableName);
+    } catch {
+      const initData = [{ id: "__init__", vector: new Array(this.dimension).fill(0) }];
+      this.table = await this.db.createTable(this.tableName, initData);
+      await this.table.delete('id = "__init__"');
+    }
+  }
+  /**
+   * 添加向量
+   */
+  async add(records) {
+    if (!this.table) {
+      throw new Error("VectorStore not initialized");
+    }
+    if (records.length === 0) return;
+    await this.table.add(records);
+  }
+  /**
+   * 更新向量（删除后重新添加）
+   */
+  async update(record) {
+    if (!this.table) {
+      throw new Error("VectorStore not initialized");
+    }
+    await this.delete(record.id);
+    await this.add([record]);
+  }
+  /**
+   * 根据 ID 获取向量
+   */
+  async getById(id) {
+    if (!this.table) {
+      throw new Error("VectorStore not initialized");
+    }
+    try {
+      const results = await this.table.search().where(`id = "${id}"`).limit(1).toArray();
+      if (results.length === 0) {
+        return null;
+      }
+      return results[0].vector;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * 删除向量
+   */
+  async delete(id) {
+    if (!this.table) {
+      throw new Error("VectorStore not initialized");
+    }
+    await this.table.delete(`id = "${id}"`);
+  }
+  /**
+   * 搜索最相似的向量
+   */
+  async search(queryVector, limit = 10) {
+    if (!this.table) {
+      throw new Error("VectorStore not initialized");
+    }
+    const results = await this.table.vectorSearch(queryVector).limit(limit).toArray();
+    return results.map((r) => ({
+      id: r.id,
+      distance: r._distance
+    }));
+  }
+  /**
+   * 获取记录数量
+   */
+  async count() {
+    if (!this.table) {
+      throw new Error("VectorStore not initialized");
+    }
+    return await this.table.countRows();
+  }
+  /**
+   * 检查 ID 是否存在
+   */
+  async exists(id) {
+    if (!this.table) {
+      throw new Error("VectorStore not initialized");
+    }
+    const results = await this.table.search([]).where(`id = "${id}"`).limit(1).toArray();
+    return results.length > 0;
+  }
+  /**
+   * 关闭连接（清理资源）
+   * 注意：LanceDB 连接会在对象销毁时自动清理，但可以显式重置引用
+   */
+  close() {
+    this.table = null;
+    this.db = null;
+  }
+};
+
+// src/storage/fulltext.ts
+import FlexSearch from "flexsearch";
+import nodejieba from "nodejieba";
+import * as path from "path";
+var FullTextIndex = class {
+  index;
+  indexPath;
+  docCount = 0;
+  constructor(dataDir) {
+    this.indexPath = path.join(dataDir, "fulltext-index.json");
+    this.index = this.createIndex();
+  }
+  createIndex() {
+    return new FlexSearch.Document({
+      document: {
+        id: "id",
+        index: ["title", "content"],
+        store: true
+      },
+      encode: (str) => {
+        const tokens = nodejieba.cut(str);
+        return tokens.filter((t) => t.trim().length > 0 && !/^[\s\p{P}]+$/u.test(t));
+      },
+      cache: 100
+    });
+  }
+  /**
+   * 初始化
+   */
+  async init() {
+  }
+  /**
+   * 添加文档
+   */
+  add(record) {
+    this.index.add(record);
+    this.docCount++;
+  }
+  /**
+   * 更新文档
+   */
+  update(record) {
+    this.remove(record.id);
+    this.add(record);
+  }
+  /**
+   * 删除文档
+   */
+  remove(id) {
+    this.index.remove(id);
+    this.docCount = Math.max(0, this.docCount - 1);
+  }
+  /**
+   * 搜索
+   */
+  search(query, limit = 10) {
+    if (!query.trim()) {
+      return [];
+    }
+    const results = this.index.search(query, {
+      limit: limit * 2,
+      index: ["title", "content"],
+      enrich: true
+    });
+    const idScores = /* @__PURE__ */ new Map();
+    for (const fieldResult of results) {
+      const field = fieldResult.field;
+      const weight = field === "title" ? 2 : 1;
+      if (Array.isArray(fieldResult.result)) {
+        for (let rank = 0; rank < fieldResult.result.length; rank++) {
+          const item = fieldResult.result[rank];
+          const id = typeof item === "object" && item !== null ? item.id ?? item : item;
+          if (typeof id === "string") {
+            const score = weight / (rank + 1);
+            idScores.set(id, (idScores.get(id) || 0) + score);
+          }
+        }
+      }
+    }
+    const maxScore = Math.max(...idScores.values(), 1);
+    return Array.from(idScores.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([id, score]) => ({
+      id,
+      score: score / maxScore
+      // 标准化到 0-1
+    }));
+  }
+  /**
+   * 获取文档数量
+   */
+  getDocCount() {
+    return this.docCount;
+  }
+  /**
+   * 根据 ID 获取文档内容
+   */
+  getContent(id) {
+    try {
+      const doc = this.index.get(id);
+      if (doc && typeof doc === "object") {
+        return doc.content || null;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * 保存索引
+   */
+  async save() {
+  }
+  /**
+   * 加载索引
+   */
+  async load() {
+  }
+  /**
+   * 清空索引
+   */
+  clear() {
+    this.index = this.createIndex();
+    this.docCount = 0;
+  }
+};
+
+// src/storage/meta.ts
+import Database from "better-sqlite3";
+import * as path2 from "path";
+import * as fs from "fs";
+var MetaStore = class {
+  db;
+  dbPath;
+  constructor(dataDir) {
+    this.dbPath = path2.join(dataDir, "meta.db");
+    fs.mkdirSync(dataDir, { recursive: true });
+    this.db = new Database(this.dbPath);
+    this.init();
+  }
+  /**
+   * 初始化数据库表
+   */
+  init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS documents (
+        id TEXT PRIMARY KEY,
+        path TEXT UNIQUE NOT NULL,
+        name TEXT NOT NULL,
+        file_type TEXT NOT NULL,
+        extension TEXT NOT NULL,
+        title TEXT,
+        content TEXT,
+        file_size INTEGER NOT NULL,
+        created_at TEXT NOT NULL,
+        modified_at TEXT NOT NULL,
+        indexed_at TEXT NOT NULL,
+        content_hash TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_documents_path ON documents(path);
+      CREATE INDEX IF NOT EXISTS idx_documents_file_type ON documents(file_type);
+      CREATE INDEX IF NOT EXISTS idx_documents_modified_at ON documents(modified_at);
+      CREATE INDEX IF NOT EXISTS idx_documents_content_hash ON documents(content_hash);
+    `);
+  }
+  /**
+   * 添加或更新文档
+   */
+  upsert(doc) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO documents 
+      (id, path, name, file_type, extension, title, content, file_size, created_at, modified_at, indexed_at, content_hash)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      doc.id,
+      doc.path,
+      doc.name,
+      doc.fileType,
+      doc.extension,
+      doc.title || null,
+      doc.content,
+      doc.fileSize,
+      doc.createdAt.toISOString(),
+      doc.modifiedAt.toISOString(),
+      doc.indexedAt.toISOString(),
+      doc.contentHash
+    );
+  }
+  /**
+   * 根据 ID 获取文档
+   */
+  getById(id) {
+    const stmt = this.db.prepare("SELECT * FROM documents WHERE id = ?");
+    const row = stmt.get(id);
+    if (!row) return null;
+    return this.rowToDocument(row);
+  }
+  /**
+   * 根据路径获取文档
+   */
+  getByPath(filePath) {
+    const stmt = this.db.prepare("SELECT * FROM documents WHERE path = ?");
+    const row = stmt.get(filePath);
+    if (!row) return null;
+    return this.rowToDocument(row);
+  }
+  /**
+   * 根据路径和修改时间获取文档（更精确的唯一性检查）
+   */
+  getByPathAndTime(filePath, modifiedTime) {
+    const stmt = this.db.prepare(
+      "SELECT * FROM documents WHERE path = ? AND modified_at = ?"
+    );
+    const row = stmt.get(filePath, modifiedTime.toISOString());
+    if (!row) return null;
+    return this.rowToDocument(row);
+  }
+  /**
+   * 根据内容哈希获取文档（用于检测重复内容）
+   */
+  getByHash(contentHash) {
+    const stmt = this.db.prepare("SELECT * FROM documents WHERE content_hash = ? LIMIT 1");
+    const row = stmt.get(contentHash);
+    if (!row) return null;
+    return this.rowToDocument(row);
+  }
+  /**
+   * 根据内容哈希获取所有相同内容的文档路径
+   */
+  getPathsByHash(contentHash) {
+    const stmt = this.db.prepare("SELECT path FROM documents WHERE content_hash = ?");
+    const rows = stmt.all(contentHash);
+    return rows.map((row) => row.path);
+  }
+  /**
+   * 根据 ID 列表获取文档
+   */
+  getByIds(ids) {
+    if (ids.length === 0) return [];
+    const placeholders = ids.map(() => "?").join(",");
+    const stmt = this.db.prepare(`SELECT * FROM documents WHERE id IN (${placeholders})`);
+    const rows = stmt.all(...ids);
+    return rows.map((row) => this.rowToDocument(row));
+  }
+  /**
+   * 删除文档
+   */
+  delete(id) {
+    const stmt = this.db.prepare("DELETE FROM documents WHERE id = ?");
+    stmt.run(id);
+  }
+  /**
+   * 根据路径删除文档
+   */
+  deleteByPath(filePath) {
+    const stmt = this.db.prepare("DELETE FROM documents WHERE path = ?");
+    stmt.run(filePath);
+  }
+  /**
+   * 获取所有文档
+   */
+  getAll() {
+    const stmt = this.db.prepare("SELECT * FROM documents");
+    const rows = stmt.all();
+    return rows.map((row) => this.rowToDocument(row));
+  }
+  /**
+   * 获取所有文档路径和哈希（用于增量更新）
+   */
+  getAllPathsAndHashes() {
+    const stmt = this.db.prepare("SELECT id, path, content_hash, modified_at FROM documents");
+    const rows = stmt.all();
+    const result = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      result.set(row.path, {
+        id: row.id,
+        hash: row.content_hash,
+        modifiedAt: new Date(row.modified_at)
+      });
+    }
+    return result;
+  }
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    const totalStmt = this.db.prepare("SELECT COUNT(*) as count FROM documents");
+    const total = totalStmt.get().count;
+    const byTypeStmt = this.db.prepare(
+      "SELECT file_type, COUNT(*) as count FROM documents GROUP BY file_type"
+    );
+    const byTypeRows = byTypeStmt.all();
+    const byType = {};
+    for (const row of byTypeRows) {
+      byType[row.file_type] = row.count;
+    }
+    const lastUpdatedStmt = this.db.prepare(
+      "SELECT MAX(indexed_at) as last FROM documents"
+    );
+    const lastRow = lastUpdatedStmt.get();
+    const lastUpdated = lastRow.last ? new Date(lastRow.last) : void 0;
+    let indexSize = 0;
+    try {
+      const stat6 = fs.statSync(this.dbPath);
+      indexSize = stat6.size;
+    } catch {
+    }
+    return {
+      totalDocuments: total,
+      byType,
+      directories: [],
+      // 这个需要从配置获取
+      lastUpdated,
+      indexSize
+    };
+  }
+  /**
+   * 清空所有数据
+   */
+  clear() {
+    this.db.exec("DELETE FROM documents");
+  }
+  /**
+   * 关闭数据库连接
+   */
+  close() {
+    this.db.close();
+  }
+  /**
+   * 数据行转换为文档对象
+   */
+  rowToDocument(row) {
+    return {
+      id: row.id,
+      path: row.path,
+      name: row.name,
+      fileType: row.file_type,
+      extension: row.extension,
+      title: row.title,
+      content: row.content,
+      fileSize: row.file_size,
+      createdAt: new Date(row.created_at),
+      modifiedAt: new Date(row.modified_at),
+      indexedAt: new Date(row.indexed_at),
+      contentHash: row.content_hash
+    };
+  }
+};
+
+// src/parsers/index.ts
+import mammoth from "mammoth";
+import pdfParse from "pdf-parse";
+import xlsx from "xlsx";
+import JSZip from "jszip";
+import { parseString } from "xml2js";
+import * as fs2 from "fs/promises";
+import * as path3 from "path";
+async function parseWord(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  if (ext === ".doc") {
+    const title = path3.basename(filePath, ext);
+    return {
+      content: "",
+      title,
+      metadata: { unsupported: true, reason: "\u65E7\u7248 .doc \u683C\u5F0F\u6682\u4E0D\u652F\u6301\uFF0C\u8BF7\u8F6C\u6362\u4E3A .docx" }
+    };
+  }
+  try {
+    const buffer = await fs2.readFile(filePath);
+    const result = await mammoth.extractRawText({ buffer });
+    const content = result.value.trim();
+    const lines = content.split("\n").filter((l) => l.trim());
+    const title = lines[0]?.slice(0, 100);
+    return { content, title };
+  } catch (error) {
+    const title = path3.basename(filePath, ext);
+    return {
+      content: "",
+      title,
+      metadata: {
+        error: true,
+        reason: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+async function parsePDF(filePath) {
+  const pathLower = filePath.toLowerCase();
+  if (pathLower.includes(".xcassets") || pathLower.includes(".imageset") || pathLower.includes(".appiconset")) {
+    return {
+      content: "",
+      title: path3.basename(filePath, ".pdf"),
+      metadata: { skipped: true, reason: "\u8D44\u6E90\u6587\u4EF6\uFF0C\u8DF3\u8FC7\u89E3\u6790" }
+    };
+  }
+  try {
+    const originalWarn = console.warn;
+    const warnings = [];
+    console.warn = (...args) => {
+      const msg = args.join(" ");
+      if (msg.includes("Ignoring invalid character") || msg.includes("Warning:") && msg.includes("hex string")) {
+        return;
+      }
+      originalWarn.apply(console, args);
+    };
+    try {
+      const buffer = await fs2.readFile(filePath);
+      const data = await pdfParse(buffer);
+      const content = data.text.trim();
+      console.warn = originalWarn;
+      if (!content) {
+        return {
+          content: "",
+          title: path3.basename(filePath, ".pdf"),
+          metadata: { empty: true }
+        };
+      }
+      const title = data.info?.Title || content.split("\n")[0]?.slice(0, 100);
+      return {
+        content,
+        title,
+        metadata: {
+          pages: data.numpages,
+          info: data.info
+        }
+      };
+    } finally {
+      console.warn = originalWarn;
+    }
+  } catch (error) {
+    const title = path3.basename(filePath, ".pdf");
+    return {
+      content: "",
+      title,
+      metadata: {
+        error: true,
+        reason: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+async function parseExcel(filePath) {
+  try {
+    const workbook = xlsx.readFile(filePath);
+    const sheets = [];
+    for (const sheetName of workbook.SheetNames) {
+      const sheet = workbook.Sheets[sheetName];
+      const text = xlsx.utils.sheet_to_txt(sheet);
+      if (text.trim()) {
+        sheets.push(`[${sheetName}]
+${text}`);
+      }
+    }
+    const content = sheets.join("\n\n");
+    const title = workbook.SheetNames[0];
+    return {
+      content,
+      title,
+      metadata: {
+        sheetCount: workbook.SheetNames.length,
+        sheetNames: workbook.SheetNames
+      }
+    };
+  } catch (error) {
+    const title = path3.basename(filePath, path3.extname(filePath));
+    return {
+      content: "",
+      title,
+      metadata: {
+        error: true,
+        reason: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+async function parseText(filePath) {
+  const content = await fs2.readFile(filePath, "utf-8");
+  const lines = content.split("\n").filter((l) => l.trim());
+  let title = lines[0]?.slice(0, 100);
+  if (title?.startsWith("#")) {
+    title = title.replace(/^#+\s*/, "");
+  }
+  return { content: content.trim(), title };
+}
+async function parsePPT(filePath) {
+  const title = path3.basename(filePath, path3.extname(filePath));
+  try {
+    const absolutePath = path3.isAbsolute(filePath) ? filePath : path3.resolve(filePath);
+    const fileBuffer = await fs2.readFile(absolutePath);
+    const zip = await JSZip.loadAsync(fileBuffer);
+    const slides = [];
+    const slideFiles = [];
+    zip.forEach((relativePath) => {
+      if (relativePath.startsWith("ppt/slides/slide") && relativePath.endsWith(".xml")) {
+        slideFiles.push(relativePath);
+      }
+    });
+    slideFiles.sort((a, b) => {
+      const matchA = a.match(/slide(\d+)\.xml/);
+      const matchB = b.match(/slide(\d+)\.xml/);
+      const numA = matchA ? parseInt(matchA[1]) : 0;
+      const numB = matchB ? parseInt(matchB[1]) : 0;
+      return numA - numB;
+    });
+    for (const slidePath of slideFiles) {
+      const slideMatch = slidePath.match(/slide(\d+)\.xml/);
+      const slideNumber = slideMatch ? parseInt(slideMatch[1]) : 0;
+      const slideFile = zip.file(slidePath);
+      if (!slideFile) continue;
+      const slideXml = await slideFile.async("string");
+      if (!slideXml) continue;
+      const slideJson = await new Promise((resolve2, reject) => {
+        parseString(slideXml, {
+          explicitArray: false,
+          mergeAttrs: true,
+          trim: true,
+          normalize: true
+        }, (err, result) => {
+          if (err) reject(err);
+          else resolve2(result);
+        });
+      });
+      const extractTextFromXml = (obj, inTextNode = false) => {
+        const texts = [];
+        if (typeof obj === "string") {
+          if (inTextNode) {
+            const trimmed = obj.trim();
+            if (trimmed && trimmed.length > 0) {
+              texts.push(trimmed);
+            }
+          }
+        } else if (Array.isArray(obj)) {
+          for (const item of obj) {
+            texts.push(...extractTextFromXml(item, inTextNode));
+          }
+        } else if (obj && typeof obj === "object") {
+          if (obj["a:t"]) {
+            const fieldTexts = extractTextFromXml(obj["a:t"], true);
+            texts.push(...fieldTexts);
+          }
+          for (const value of Object.values(obj)) {
+            texts.push(...extractTextFromXml(value, inTextNode));
+          }
+        }
+        return texts;
+      };
+      const slideTexts = extractTextFromXml(slideJson);
+      const filteredTexts = slideTexts.filter((t) => {
+        const trimmed = t.trim();
+        if (!trimmed || trimmed.length === 0) return false;
+        if (/^-?\d+$/.test(trimmed)) return false;
+        if (/^\{[0-9A-F-]+\}$/i.test(trimmed)) return false;
+        if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) return false;
+        if (trimmed.includes("xmlns") || trimmed.includes("schemas.openxmlformats")) return false;
+        const formatKeywords = [
+          "ctrTitle",
+          "zh-CN",
+          "en-US",
+          "body",
+          "title",
+          "subtitle",
+          "connsite",
+          "islide",
+          "\u7EC4\u5408",
+          "\u77E9\u5F62",
+          "\u4EFB\u610F\u591A\u8FB9\u5F62",
+          "\u6587\u672C\u6846",
+          "\u6587\u672C\u5360\u4F4D\u7B26",
+          "\u56FE\u6587\u6846",
+          "\u76F4\u63A5\u8FDE\u63A5\u7B26",
+          "\u692D\u5706",
+          "rId",
+          "accent",
+          "minor",
+          "lt",
+          "ctr",
+          "rect",
+          "square",
+          "roundRect",
+          "ellipse",
+          "none",
+          "solid",
+          "horz",
+          "Bullet",
+          "noStrike",
+          "Arial",
+          "\u65B9\u6B63",
+          "Component",
+          "Icon",
+          "Group",
+          "Presenter",
+          "subTitle",
+          "quarter",
+          "Shape",
+          "Number",
+          "Text",
+          "TextBox",
+          "Picture",
+          "QR",
+          "adj",
+          "Thank you",
+          "IMPORTANT NOTE",
+          "Template file",
+          "20XX.XX.XX"
+        ];
+        if (formatKeywords.some((keyword) => trimmed.includes(keyword))) return false;
+        if (/^\*\/.*[wh]$/.test(trimmed)) return false;
+        if (/^connsite[XY]\d+$/.test(trimmed)) return false;
+        if (/^[0-9A-F]{6}$/i.test(trimmed)) return false;
+        if (trimmed.length === 1) {
+          return false;
+        }
+        if (/^[a-zA-Z-]+$/.test(trimmed) && trimmed.length < 3) return false;
+        const hasChinese = /[\u4e00-\u9fa5]/.test(trimmed);
+        const chineseCount = (trimmed.match(/[\u4e00-\u9fa5]/g) || []).length;
+        if (hasChinese && chineseCount < 2) return false;
+        if (!hasChinese && trimmed.length < 3) return false;
+        return true;
+      });
+      if (filteredTexts.length > 0) {
+        const uniqueTexts = [...new Set(filteredTexts)];
+        const mergedTexts = [];
+        for (let i = 0; i < uniqueTexts.length; i++) {
+          const current = uniqueTexts[i].trim();
+          if (!current) continue;
+          const hasChinese = /[\u4e00-\u9fa5]/.test(current);
+          const isShort = current.length <= 3 && hasChinese;
+          if (isShort && mergedTexts.length > 0) {
+            const lastIndex = mergedTexts.length - 1;
+            const lastText = mergedTexts[lastIndex];
+            if (/[\u4e00-\u9fa5]/.test(lastText)) {
+              mergedTexts[lastIndex] = lastText + current;
+              continue;
+            }
+          }
+          if ((/^\d+%?$/.test(current) || /^\d+\.\d+$/.test(current)) && mergedTexts.length > 0) {
+            const lastIndex = mergedTexts.length - 1;
+            const lastText = mergedTexts[lastIndex];
+            if (/[\u4e00-\u9fa5]/.test(lastText)) {
+              mergedTexts[lastIndex] = lastText + current;
+              continue;
+            }
+          }
+          mergedTexts.push(current);
+        }
+        const slideContent = mergedTexts.join("\n\n").trim();
+        if (slideContent) {
+          slides.push({
+            number: slideNumber,
+            content: slideContent
+          });
+        }
+      }
+    }
+    if (slides.length === 0) {
+      return {
+        content: `[PPT\u6587\u6863] ${title}`,
+        title,
+        metadata: {
+          error: false,
+          slides: []
+        }
+      };
+    }
+    const markdownContent = slides.map((slide, index) => {
+      const slideHeader = `## \u5E7B\u706F\u7247 ${slide.number}${index === 0 ? "\uFF08\u5C01\u9762\uFF09" : ""}
+
+`;
+      return slideHeader + slide.content;
+    }).join("\n\n---\n\n");
+    const extractedTitle = slides[0]?.content.split("\n")[0]?.slice(0, 100) || title;
+    return {
+      content: markdownContent,
+      title: extractedTitle,
+      metadata: {
+        slides: slides.map((s) => ({
+          number: s.number,
+          content: s.content
+        })),
+        totalSlides: slides.length
+      }
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.warn(`PPT \u89E3\u6790\u5931\u8D25: ${filePath} - ${errorMsg}`);
+    return {
+      content: `[PPT\u6587\u6863] ${title}`,
+      title,
+      metadata: {
+        error: true,
+        reason: errorMsg
+      }
+    };
+  }
+}
+async function parseDocument(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".docx":
+    case ".doc":
+      return parseWord(filePath);
+    case ".pdf":
+      return parsePDF(filePath);
+    case ".xlsx":
+    case ".xls":
+      return parseExcel(filePath);
+    case ".pptx":
+    case ".ppt":
+      return parsePPT(filePath);
+    case ".txt":
+    case ".md":
+    case ".rtf":
+    case ".text":
+      return parseText(filePath);
+    default:
+      try {
+        return await parseText(filePath);
+      } catch {
+        return { content: "", title: path3.basename(filePath) };
+      }
+  }
+}
+function isSupportedDocument(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  return [".docx", ".doc", ".pdf", ".xlsx", ".xls", ".pptx", ".ppt", ".txt", ".md", ".rtf"].includes(ext);
+}
+function getDocumentType(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  if ([".docx", ".doc"].includes(ext)) return "word";
+  if (ext === ".pdf") return "pdf";
+  if ([".xlsx", ".xls"].includes(ext)) return "excel";
+  if ([".pptx", ".ppt"].includes(ext)) return "powerpoint";
+  if ([".txt", ".md", ".rtf"].includes(ext)) return "text";
+  return "unknown";
+}
+
+// src/embeddings/index.ts
+var arkApiKey = null;
+var currentModel = "doubao-embedding-vision-250615";
+var initialized = false;
+var ARK_EMBEDDING_URL = "https://ark.cn-beijing.volces.com/api/v3/embeddings/multimodal";
+var embeddingDimension = 1024;
+var DEFAULT_INSTRUCTIONS = {
+  /** 文档索引指令 */
+  document: "\u5C06\u4EE5\u4E0B\u6587\u6863\u5185\u5BB9\u8F6C\u6362\u4E3A\u8BED\u4E49\u5411\u91CF\uFF0C\u7528\u4E8E\u540E\u7EED\u7684\u76F8\u4F3C\u5EA6\u68C0\u7D22",
+  /** 查询检索指令 */
+  query: "\u5C06\u4EE5\u4E0B\u641C\u7D22\u67E5\u8BE2\u8F6C\u6362\u4E3A\u8BED\u4E49\u5411\u91CF\uFF0C\u7528\u4E8E\u68C0\u7D22\u76F8\u5173\u6587\u6863"
+};
+async function initEmbedder(apiKey, modelName = "doubao-embedding-vision-250615", dimensions = 1024) {
+  const key = apiKey || process.env.ARK_API_KEY;
+  if (!key) {
+    throw new Error("\u7F3A\u5C11 ARK_API_KEY\uFF0C\u8BF7\u901A\u8FC7\u53C2\u6570\u6216\u73AF\u5883\u53D8\u91CF\u63D0\u4F9B");
+  }
+  arkApiKey = key;
+  currentModel = modelName;
+  embeddingDimension = dimensions;
+  initialized = true;
+  console.log(`\u8C46\u5305 Embedding \u6A21\u578B\u5DF2\u914D\u7F6E: ${modelName}, \u7EF4\u5EA6: ${dimensions}`);
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+var RETRY_CONFIG = {
+  maxRetries: 3,
+  // 最大重试次数
+  baseDelay: 1e3,
+  // 基础延迟 1 秒
+  maxDelay: 1e4
+  // 最大延迟 10 秒
+};
+async function embed(text, options) {
+  if (!initialized || !arkApiKey) {
+    await initEmbedder();
+  }
+  const maxLength = options?.maxLength ?? 8192;
+  const instructions = options?.instructions;
+  const truncated = text.slice(0, maxLength);
+  const requestBody = {
+    model: currentModel,
+    encoding_format: "float",
+    dimensions: embeddingDimension,
+    input: [
+      {
+        type: "text",
+        text: truncated
+      }
+    ]
+  };
+  if (instructions) {
+    requestBody.instructions = instructions;
+  }
+  let lastError = null;
+  for (let attempt = 0; attempt <= RETRY_CONFIG.maxRetries; attempt++) {
+    try {
+      const response = await fetch(ARK_EMBEDDING_URL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${arkApiKey}`
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (response.ok) {
+        const result = await response.json();
+        if (!result.data?.embedding) {
+          throw new Error(`\u8C46\u5305 Embedding API \u8FD4\u56DE\u683C\u5F0F\u9519\u8BEF: ${JSON.stringify(result)}`);
+        }
+        return result.data.embedding;
+      }
+      if (response.status === 429 && attempt < RETRY_CONFIG.maxRetries) {
+        const retryDelay = Math.min(
+          RETRY_CONFIG.baseDelay * Math.pow(2, attempt),
+          RETRY_CONFIG.maxDelay
+        );
+        await delay(retryDelay);
+        continue;
+      }
+      const errorText = await response.text();
+      throw new Error(`\u8C46\u5305 Embedding API \u9519\u8BEF (${response.status}): ${errorText}`);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < RETRY_CONFIG.maxRetries) {
+        const retryDelay = Math.min(
+          RETRY_CONFIG.baseDelay * Math.pow(2, attempt),
+          RETRY_CONFIG.maxDelay
+        );
+        await delay(retryDelay);
+        continue;
+      }
+    }
+  }
+  throw lastError || new Error("Embedding \u8BF7\u6C42\u5931\u8D25");
+}
+async function embedDocument(text, maxLength = 8192) {
+  return embed(text, {
+    maxLength,
+    instructions: DEFAULT_INSTRUCTIONS.document
+  });
+}
+async function embedQuery(text, maxLength = 8192) {
+  return embed(text, {
+    maxLength,
+    instructions: DEFAULT_INSTRUCTIONS.query
+  });
+}
+async function embedBatch(texts, maxLength = 8192) {
+  if (!initialized || !arkApiKey) {
+    await initEmbedder();
+  }
+  const results = [];
+  for (const text of texts) {
+    const vector = await embedDocument(text, maxLength);
+    results.push(vector);
+  }
+  return results;
+}
+async function embedBatchConcurrent(texts, concurrency = 5, maxLength = 8192) {
+  if (!initialized || !arkApiKey) {
+    await initEmbedder();
+  }
+  const results = new Array(texts.length);
+  const executing = [];
+  for (let i = 0; i < texts.length; i++) {
+    const promise = (async (index) => {
+      results[index] = await embedDocument(texts[index], maxLength);
+    })(i);
+    executing.push(promise);
+    if (executing.length >= concurrency) {
+      await Promise.race(executing);
+      const completed = executing.filter((p) => {
+        const state = p;
+        return state._state === "fulfilled" || state._state === "rejected";
+      });
+      for (const c of completed) {
+        const idx = executing.indexOf(c);
+        if (idx > -1) executing.splice(idx, 1);
+      }
+    }
+  }
+  await Promise.all(executing);
+  return results;
+}
+async function embedImage(imageUrl) {
+  if (!initialized || !arkApiKey) {
+    await initEmbedder();
+  }
+  const response = await fetch(ARK_EMBEDDING_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${arkApiKey}`
+    },
+    body: JSON.stringify({
+      model: currentModel,
+      encoding_format: "float",
+      dimensions: embeddingDimension,
+      input: [
+        {
+          type: "image_url",
+          image_url: {
+            url: imageUrl
+          }
+        }
+      ]
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`\u8C46\u5305 Embedding API \u9519\u8BEF (${response.status}): ${errorText}`);
+  }
+  const result = await response.json();
+  if (!result.data?.embedding) {
+    throw new Error(`\u8C46\u5305 Embedding API \u8FD4\u56DE\u683C\u5F0F\u9519\u8BEF: ${JSON.stringify(result)}`);
+  }
+  return result.data.embedding;
+}
+async function embedVideo(videoUrl) {
+  if (!initialized || !arkApiKey) {
+    await initEmbedder();
+  }
+  const response = await fetch(ARK_EMBEDDING_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${arkApiKey}`
+    },
+    body: JSON.stringify({
+      model: currentModel,
+      encoding_format: "float",
+      dimensions: embeddingDimension,
+      input: [
+        {
+          type: "video_url",
+          video_url: {
+            url: videoUrl
+          }
+        }
+      ]
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`\u8C46\u5305 Embedding API \u9519\u8BEF (${response.status}): ${errorText}`);
+  }
+  const result = await response.json();
+  if (!result.data?.embedding) {
+    throw new Error(`\u8C46\u5305 Embedding API \u8FD4\u56DE\u683C\u5F0F\u9519\u8BEF: ${JSON.stringify(result)}`);
+  }
+  return result.data.embedding;
+}
+async function embedMultimodal(inputs) {
+  if (!initialized || !arkApiKey) {
+    await initEmbedder();
+  }
+  const response = await fetch(ARK_EMBEDDING_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${arkApiKey}`
+    },
+    body: JSON.stringify({
+      model: currentModel,
+      encoding_format: "float",
+      dimensions: embeddingDimension,
+      input: inputs
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`\u8C46\u5305 Embedding API \u9519\u8BEF (${response.status}): ${errorText}`);
+  }
+  const result = await response.json();
+  if (!result.data?.embedding) {
+    throw new Error(`\u8C46\u5305 Embedding API \u8FD4\u56DE\u683C\u5F0F\u9519\u8BEF: ${JSON.stringify(result)}`);
+  }
+  return result.data.embedding;
+}
+function getEmbeddingDimension() {
+  return embeddingDimension;
+}
+function setEmbeddingDimension(dimension) {
+  embeddingDimension = dimension;
+}
+function disposeEmbedder() {
+  arkApiKey = null;
+  initialized = false;
+}
+function isEmbedderInitialized() {
+  return initialized && arkApiKey !== null;
+}
+
+// src/core/scanner.ts
+import { fdir } from "fdir";
+import * as path5 from "path";
+import * as os2 from "os";
+
+// src/core/rules.ts
+import * as path4 from "path";
+import * as os from "os";
+var DEFAULT_EXTENSION_RULES = {
+  allowed: [
+    ".docx",
+    ".doc",
+    ".pdf",
+    ".xlsx",
+    ".xls",
+    ".pptx",
+    ".ppt",
+    ".txt",
+    ".md",
+    ".rtf"
+  ],
+  excluded: [
+    // .doc 格式明确不支持（解析困难）
+    ".doc"
+  ]
+};
+var DEFAULT_DIRECTORY_RULES = {
+  // 版本控制目录（非隐藏的）
+  excludedNames: [
+    "node_modules"
+  ],
+  // 缓存和临时目录（非隐藏的）
+  buildDirs: [
+    "__pycache__",
+    "build",
+    "dist",
+    "out",
+    "target"
+  ],
+  // 资源目录（非隐藏的）
+  resourceDirs: [
+    "Assets.xcassets"
+  ],
+  // 系统目录（平台特定）
+  windowsSystemDirs: [
+    "Windows",
+    "Program Files",
+    "Program Files (x86)",
+    "ProgramData",
+    "System Volume Information",
+    "AppData",
+    "Library",
+    "$RECYCLE.BIN"
+  ],
+  // 用户配置的排除路径（默认空，由用户配置）
+  excludedPaths: []
+};
+var DEFAULT_FILE_RULES = {
+  // 默认排除所有隐藏文件（以 . 开头）
+  excludeHidden: true,
+  excludedPatterns: [],
+  excludedPathContains: [
+    // 资源文件路径模式（即使文件名不是隐藏的，但路径中包含这些模式也要排除）
+    ".imageset",
+    ".xcassets",
+    ".appiconset"
+  ]
+};
+var DEFAULT_PATH_RULES = {
+  windows: {
+    onlyUserDirs: true,
+    excludedRootDirs: [
+      "Windows",
+      "Program Files",
+      "Program Files (x86)",
+      "ProgramData",
+      "System Volume Information"
+    ]
+  }
+};
+var DEFAULT_SCAN_RULES = {
+  extensions: DEFAULT_EXTENSION_RULES,
+  directories: DEFAULT_DIRECTORY_RULES,
+  files: DEFAULT_FILE_RULES,
+  paths: DEFAULT_PATH_RULES
+};
+var ScanRulesManager = class {
+  rules;
+  excludedDirNamesSet;
+  allowedExtensionsSet;
+  excludedExtensionsSet;
+  constructor(rules = DEFAULT_SCAN_RULES) {
+    this.rules = rules;
+    this.excludedDirNamesSet = new Set(
+      [
+        ...rules.directories.excludedNames,
+        ...rules.directories.buildDirs,
+        ...rules.directories.resourceDirs
+      ].map((name) => name.toLowerCase())
+    );
+    this.allowedExtensionsSet = new Set(
+      rules.extensions.allowed.map((ext) => ext.toLowerCase())
+    );
+    this.excludedExtensionsSet = new Set(
+      rules.extensions.excluded.map((ext) => ext.toLowerCase())
+    );
+  }
+  /**
+   * 检查文件扩展名是否允许
+   */
+  isExtensionAllowed(ext) {
+    const extLower = ext.toLowerCase();
+    if (this.excludedExtensionsSet.has(extLower)) {
+      return false;
+    }
+    return this.allowedExtensionsSet.has(extLower);
+  }
+  /**
+   * 检查目录是否应该被排除（用于 fdir 的 exclude 方法）
+   * 这是性能优化的关键：在进入目录之前就排除，避免扫描目录内的文件
+   */
+  shouldExcludeDirectory(dirName) {
+    if (this.rules.files.excludeHidden && dirName.startsWith(".")) {
+      return true;
+    }
+    return this.excludedDirNamesSet.has(dirName.toLowerCase());
+  }
+  /**
+   * 检查文件是否应该被排除
+   * 注意：隐藏目录已经在 shouldExcludeDirectory 中被排除，不会进入这里
+   * 这里主要处理隐藏文件和路径模式匹配
+   */
+  shouldExcludeFile(filePath, fileName) {
+    if (this.rules.files.excludeHidden && fileName.startsWith(".")) {
+      return true;
+    }
+    const normalizedPath = filePath.replace(/[/\\]/g, path4.sep);
+    const pathLower = normalizedPath.toLowerCase();
+    for (const pattern of this.rules.files.excludedPathContains) {
+      if (pathLower.includes(pattern.toLowerCase())) {
+        return true;
+      }
+    }
+    const parts = normalizedPath.split(path4.sep).filter((p) => p.length > 0);
+    for (const excludedPath of this.rules.directories.excludedPaths) {
+      const normalizedExclude = excludedPath.replace(/[/\\]/g, path4.sep);
+      if (parts.includes(normalizedExclude) || parts.some((p) => p === path4.basename(normalizedExclude))) {
+        return true;
+      }
+    }
+    if (os.platform() === "win32") {
+      return this.shouldExcludeWindowsPath(normalizedPath);
+    }
+    return false;
+  }
+  /**
+   * Windows 平台路径排除检查
+   */
+  shouldExcludeWindowsPath(normalizedPath) {
+    const winRules = this.rules.paths.windows;
+    const winRootMatch = normalizedPath.match(/^([A-Z]:)\\([^\\]+)/);
+    if (winRootMatch) {
+      const drive = winRootMatch[1];
+      const firstDir = winRootMatch[2];
+      if (this.rules.directories.windowsSystemDirs.includes(firstDir)) {
+        return true;
+      }
+      if (winRules.onlyUserDirs && drive === "C:" && firstDir !== "Users") {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * 获取所有排除的目录名（用于 fdir exclude）
+   */
+  getExcludedDirectoryNames() {
+    return /* @__PURE__ */ new Set([
+      ...this.rules.directories.excludedNames,
+      ...this.rules.directories.buildDirs,
+      ...this.rules.directories.resourceDirs
+    ]);
+  }
+  /**
+   * 更新规则（允许运行时修改）
+   */
+  updateRules(newRules) {
+    this.rules = {
+      ...this.rules,
+      ...newRules,
+      extensions: { ...this.rules.extensions, ...newRules.extensions },
+      directories: { ...this.rules.directories, ...newRules.directories },
+      files: { ...this.rules.files, ...newRules.files },
+      paths: { ...this.rules.paths, ...newRules.paths }
+    };
+    this.excludedDirNamesSet = new Set(
+      [
+        ...this.rules.directories.excludedNames,
+        ...this.rules.directories.buildDirs,
+        ...this.rules.directories.resourceDirs
+      ].map((name) => name.toLowerCase())
+    );
+    this.allowedExtensionsSet = new Set(
+      this.rules.extensions.allowed.map((ext) => ext.toLowerCase())
+    );
+    this.excludedExtensionsSet = new Set(
+      this.rules.extensions.excluded.map((ext) => ext.toLowerCase())
+    );
+  }
+  /**
+   * 获取当前规则配置
+   */
+  getRules() {
+    return this.rules;
+  }
+};
+function createRulesManager(customRules) {
+  const rules = customRules ? {
+    extensions: { ...DEFAULT_EXTENSION_RULES, ...customRules.extensions },
+    directories: { ...DEFAULT_DIRECTORY_RULES, ...customRules.directories },
+    files: { ...DEFAULT_FILE_RULES, ...customRules.files },
+    paths: { ...DEFAULT_PATH_RULES, ...customRules.paths }
+  } : DEFAULT_SCAN_RULES;
+  return new ScanRulesManager(rules);
+}
+
+// src/core/scanner.ts
+function expandPath(p) {
+  if (p.startsWith("~")) {
+    return path5.join(os2.homedir(), p.slice(1));
+  }
+  return p;
+}
+async function scanDirectories(directories, config) {
+  const onProgress = config?.onProgress;
+  const customRules = config?.customRules || {};
+  if (config?.excludeDirs && config.excludeDirs.length > 0) {
+    const existingPaths = customRules.directories?.excludedPaths || [];
+    customRules.directories = {
+      ...customRules.directories,
+      excludedNames: customRules.directories?.excludedNames || [],
+      excludedPaths: [...existingPaths, ...config.excludeDirs],
+      windowsSystemDirs: customRules.directories?.windowsSystemDirs || [],
+      buildDirs: customRules.directories?.buildDirs || [],
+      resourceDirs: customRules.directories?.resourceDirs || []
+    };
+  }
+  if (config?.extensions && config.extensions.length > 0) {
+    const existingAllowed = customRules.extensions?.allowed || [];
+    customRules.extensions = {
+      ...customRules.extensions,
+      allowed: [...existingAllowed, ...config.extensions],
+      excluded: customRules.extensions?.excluded || []
+    };
+  }
+  const rulesManager = createRulesManager(customRules);
+  const allFiles = [];
+  let totalScanned = 0;
+  for (const dir of directories) {
+    const expandedDir = expandPath(dir);
+    onProgress?.({ scanned: totalScanned, currentDir: expandedDir });
+    try {
+      let fileCount = 0;
+      let lastLogTime = Date.now();
+      const logInterval = 2e3;
+      const crawler = new fdir().withFullPaths().exclude((dirName) => {
+        return rulesManager.shouldExcludeDirectory(dirName);
+      }).filter((filePath, isDirectory) => {
+        if (isDirectory) {
+          return false;
+        }
+        fileCount++;
+        totalScanned++;
+        const now = Date.now();
+        if (fileCount % 5e3 === 0 || now - lastLogTime >= logInterval) {
+          onProgress?.({ scanned: totalScanned, currentDir: expandedDir });
+          console.log(`  \u{1F50D} \u5DF2\u626B\u63CF ${totalScanned.toLocaleString()} \u4E2A\u6587\u4EF6...`);
+          lastLogTime = now;
+        }
+        const fileName = path5.basename(filePath);
+        if (rulesManager.shouldExcludeFile(filePath, fileName)) {
+          return false;
+        }
+        const ext = path5.extname(filePath);
+        return rulesManager.isExtensionAllowed(ext);
+      });
+      const files = await crawler.crawl(expandedDir).withPromise();
+      allFiles.push(...files);
+      onProgress?.({ scanned: totalScanned, currentDir: expandedDir });
+    } catch (err) {
+      console.warn(`  \u26A0\uFE0F  \u626B\u63CF\u76EE\u5F55\u5931\u8D25: ${dir}`, err);
+    }
+  }
+  console.log(`  \u{1F4CA} \u626B\u63CF\u5B8C\u6210\uFF0C\u5171\u627E\u5230 ${allFiles.length} \u4E2A\u6587\u4EF6`);
+  return allFiles;
+}
+function getDefaultDirectories() {
+  const home = os2.homedir();
+  const platform3 = os2.platform();
+  const userDirs = [
+    path5.join(home, "Documents"),
+    path5.join(home, "Desktop"),
+    path5.join(home, "Downloads"),
+    path5.join(home, "Pictures"),
+    path5.join(home, "Music")
+  ];
+  if (platform3 === "darwin") {
+    userDirs.push(path5.join(home, "Movies"));
+  } else {
+    userDirs.push(path5.join(home, "Videos"));
+  }
+  return userDirs;
+}
+
+// src/core/utils.ts
+import * as crypto from "crypto";
+import * as fs3 from "fs/promises";
+import * as path6 from "path";
+async function hashFile(filePath) {
+  const stats = await fs3.stat(filePath);
+  const hashInput = `${filePath}:${stats.size}:${stats.mtime.getTime()}`;
+  return crypto.createHash("md5").update(hashInput).digest("hex").slice(0, 16);
+}
+function generateId() {
+  return crypto.randomUUID();
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function formatDate(date) {
+  return date.toISOString().split("T")[0];
+}
+function getFileType(filePath) {
+  const ext = path6.extname(filePath).toLowerCase();
+  if ([".docx", ".doc", ".rtf"].includes(ext)) return FileType.DOCUMENT;
+  if (ext === ".pdf") return FileType.PDF;
+  if ([".xlsx", ".xls"].includes(ext)) return FileType.DOCUMENT;
+  if ([".pptx", ".ppt"].includes(ext)) return FileType.DOCUMENT;
+  if ([".txt", ".md"].includes(ext)) return FileType.TEXT;
+  return FileType.FILE;
+}
+function extractSnippet(content, query, maxLength = 200) {
+  const cleanContent = content.replace(/\s+/g, " ").trim();
+  const queryTokens = query.toLowerCase().split(/\s+/).filter((t) => t.length > 1);
+  const lowerContent = cleanContent.toLowerCase();
+  let bestIndex = -1;
+  for (const token of queryTokens) {
+    const idx = lowerContent.indexOf(token);
+    if (idx !== -1 && (bestIndex === -1 || idx < bestIndex)) {
+      bestIndex = idx;
+    }
+  }
+  if (bestIndex === -1) {
+    const snippet2 = cleanContent.slice(0, maxLength);
+    return snippet2 + (cleanContent.length > maxLength ? "..." : "");
+  }
+  const contextBefore = Math.floor(maxLength * 0.3);
+  const contextAfter = Math.floor(maxLength * 0.7);
+  const start = Math.max(0, bestIndex - contextBefore);
+  const end = Math.min(cleanContent.length, bestIndex + contextAfter);
+  let snippet = cleanContent.slice(start, end);
+  if (start > 0) snippet = "..." + snippet;
+  if (end < cleanContent.length) snippet = snippet + "...";
+  return snippet;
+}
+function reciprocalRankFusion(lists, k = 60) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const { results, weight = 1 } of lists) {
+    for (let rank = 0; rank < results.length; rank++) {
+      const id = results[rank].id;
+      const rrf = weight / (k + rank + 1);
+      scores.set(id, (scores.get(id) || 0) + rrf);
+    }
+  }
+  const sortedScores = Array.from(scores.entries()).sort((a, b) => b[1] - a[1]);
+  if (sortedScores.length === 0) {
+    return [];
+  }
+  const maxScore = sortedScores[0][1];
+  return sortedScores.map(([id, score]) => ({
+    id,
+    score: maxScore > 0 ? score / maxScore : 0
+  }));
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/core/progress.ts
+var LISTENERS_KEY = /* @__PURE__ */ Symbol.for("ai-search-progress-listeners");
+function getGlobalProgressListeners() {
+  const g = globalThis;
+  if (!g[LISTENERS_KEY]) {
+    g[LISTENERS_KEY] = /* @__PURE__ */ new Set();
+  }
+  return g[LISTENERS_KEY];
+}
+function addGlobalProgressListener(listener) {
+  getGlobalProgressListeners().add(listener);
+}
+function removeGlobalProgressListener(listener) {
+  getGlobalProgressListeners().delete(listener);
+}
+function notifyGlobalProgress(progress) {
+  const listeners = getGlobalProgressListeners();
+  listeners.forEach((listener) => {
+    try {
+      listener(progress);
+    } catch (error) {
+      console.error("[DocumentSearch] \u5168\u5C40\u8FDB\u5EA6\u76D1\u542C\u5668\u9519\u8BEF:", error);
+    }
+  });
+}
+
+// src/core/watch.ts
+import * as path7 from "path";
+import chokidar from "chokidar";
+var DirectoryWatcher = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  watchers = /* @__PURE__ */ new Map();
+  debounceTimers = /* @__PURE__ */ new Map();
+  /** 检查文件扩展名是否支持 */
+  isSupportedFile(filePath) {
+    const ext = path7.extname(filePath).toLowerCase();
+    const extensions = this.deps.config.extensions || DEFAULT_CONFIG.extensions || [];
+    return extensions.includes(ext);
+  }
+  /** 检查是否应该排除 */
+  shouldExclude(filePath) {
+    const excludeDirs = this.deps.config.excludeDirs || DEFAULT_CONFIG.excludeDirs || [];
+    return excludeDirs.some((excludeDir) => filePath.includes(excludeDir));
+  }
+  /**
+   * 监听目录变化并自动更新索引
+   */
+  watch(directory, options) {
+    const {
+      ignoreInitial = true,
+      debounce = 1e3,
+      onEvent
+    } = options || {};
+    if (this.watchers.has(directory)) {
+      this.unwatch(directory);
+    }
+    const debouncedHandler = (eventType, filePath) => {
+      const timerKey = `${eventType}:${filePath}`;
+      const existingTimer = this.debounceTimers.get(timerKey);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+      const timer = setTimeout(async () => {
+        this.debounceTimers.delete(timerKey);
+        const event = {
+          type: eventType,
+          path: filePath,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        onEvent?.(event);
+        try {
+          if (eventType === "add" || eventType === "change") {
+            if (this.isSupportedFile(filePath) && !this.shouldExclude(filePath)) {
+              await this.deps.indexFile(filePath);
+              await this.deps.fullTextIndex.save();
+            }
+          } else if (eventType === "unlink") {
+            await this.deps.removeFile(filePath);
+          }
+        } catch (error) {
+          console.warn(`\u6587\u4EF6\u76D1\u542C\u5904\u7406\u5931\u8D25: ${filePath}`, error);
+        }
+      }, debounce);
+      this.debounceTimers.set(timerKey, timer);
+    };
+    const watcher = chokidar.watch(directory, {
+      ignored: (filePath) => {
+        if (this.shouldExclude(filePath)) {
+          return true;
+        }
+        if (path7.extname(filePath)) {
+          return !this.isSupportedFile(filePath);
+        }
+        return false;
+      },
+      ignoreInitial,
+      persistent: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 500,
+        pollInterval: 100
+      }
+    });
+    watcher.on("add", (filePath) => debouncedHandler("add", filePath));
+    watcher.on("change", (filePath) => debouncedHandler("change", filePath));
+    watcher.on("unlink", (filePath) => debouncedHandler("unlink", filePath));
+    watcher.on("unlinkDir", (dirPath) => {
+      const event = {
+        type: "unlinkDir",
+        path: dirPath,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      onEvent?.(event);
+    });
+    this.watchers.set(directory, watcher);
+    console.log(`\u{1F4C1} \u5F00\u59CB\u76D1\u542C\u76EE\u5F55: ${directory}`);
+  }
+  /**
+   * 停止监听目录
+   */
+  unwatch(directory) {
+    const watcher = this.watchers.get(directory);
+    if (watcher) {
+      watcher.close();
+      this.watchers.delete(directory);
+      console.log(`\u{1F4C1} \u505C\u6B62\u76D1\u542C\u76EE\u5F55: ${directory}`);
+    }
+    for (const [key, timer] of this.debounceTimers.entries()) {
+      if (key.includes(directory)) {
+        clearTimeout(timer);
+        this.debounceTimers.delete(key);
+      }
+    }
+  }
+  /**
+   * 停止所有监听
+   */
+  unwatchAll() {
+    for (const directory of this.watchers.keys()) {
+      this.unwatch(directory);
+    }
+  }
+  /**
+   * 获取正在监听的目录列表
+   */
+  getWatchedDirectories() {
+    return Array.from(this.watchers.keys());
+  }
+  /**
+   * 清理所有定时器
+   */
+  clearTimers() {
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+  }
+};
+
+// src/core/maintenance.ts
+import * as fs4 from "fs/promises";
+async function cleanup(deps) {
+  const allDocs = deps.metaStore.getAll();
+  let removed = 0;
+  let updated = 0;
+  for (const doc of allDocs) {
+    try {
+      await fs4.access(doc.path);
+      const stat6 = await fs4.stat(doc.path);
+      const contentHash = await hashFile(doc.path);
+      if (doc.contentHash !== contentHash || doc.modifiedAt.getTime() !== stat6.mtime.getTime()) {
+        await deps.indexFile(doc.path);
+        updated++;
+      }
+    } catch {
+      await deps.removeFile(doc.path);
+      removed++;
+    }
+  }
+  await deps.fullTextIndex.save();
+  return { removed, updated };
+}
+async function optimize(deps) {
+  await cleanup(deps);
+  await deps.fullTextIndex.save();
+  console.log("\u7D22\u5F15\u4F18\u5316\u5B8C\u6210");
+}
+async function healthCheck(deps) {
+  const allDocs = deps.metaStore.getAll();
+  let invalidIndexes = 0;
+  let staleIndexes = 0;
+  const integrity = {
+    meta: true,
+    vectors: true,
+    fulltext: true
+  };
+  try {
+    const stats = deps.metaStore.getStats();
+    integrity.meta = stats.totalDocuments >= 0;
+  } catch {
+    integrity.meta = false;
+  }
+  try {
+    await deps.vectorStore.search(new Array(getEmbeddingDimension()).fill(0), 1);
+    integrity.vectors = true;
+  } catch {
+    integrity.vectors = false;
+  }
+  try {
+    deps.fullTextIndex.search("test", 1);
+    integrity.fulltext = true;
+  } catch {
+    integrity.fulltext = false;
+  }
+  const sampleSize = Math.min(100, allDocs.length);
+  const sampleDocs = allDocs.slice(0, sampleSize);
+  for (const doc of sampleDocs) {
+    try {
+      await fs4.access(doc.path);
+      const stat6 = await fs4.stat(doc.path);
+      const contentHash = await hashFile(doc.path);
+      if (doc.contentHash !== contentHash || doc.modifiedAt.getTime() !== stat6.mtime.getTime()) {
+        staleIndexes++;
+      }
+    } catch {
+      invalidIndexes++;
+    }
+  }
+  if (allDocs.length > sampleSize) {
+    const ratio = invalidIndexes / sampleSize;
+    invalidIndexes = Math.floor(ratio * allDocs.length);
+    const staleRatio = staleIndexes / sampleSize;
+    staleIndexes = Math.floor(staleRatio * allDocs.length);
+  }
+  const healthy = integrity.meta && integrity.vectors && integrity.fulltext && invalidIndexes === 0 && staleIndexes === 0 && deps.indexErrors.size === 0;
+  return {
+    healthy,
+    totalDocuments: allDocs.length,
+    invalidIndexes,
+    staleIndexes,
+    errorCount: deps.indexErrors.size,
+    integrity
+  };
+}
+function getIndexErrors(deps) {
+  return Array.from(deps.indexErrors.values());
+}
+async function retryFailedIndexes(deps) {
+  const errors = getIndexErrors(deps);
+  const filePaths = errors.map((e) => e.filePath);
+  deps.indexErrors.clear();
+  return deps.indexFiles(filePaths);
+}
+
+// src/core/backup.ts
+import * as fs5 from "fs/promises";
+import * as path8 from "path";
+async function copyDirectory(source, target) {
+  await fs5.mkdir(target, { recursive: true });
+  const entries = await fs5.readdir(source, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path8.join(source, entry.name);
+    const targetPath = path8.join(target, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(sourcePath, targetPath);
+    } else {
+      await fs5.copyFile(sourcePath, targetPath);
+    }
+  }
+}
+async function calculateDirSize(dir) {
+  const entries = await fs5.readdir(dir, { withFileTypes: true });
+  let size = 0;
+  for (const entry of entries) {
+    const fullPath = path8.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      size += await calculateDirSize(fullPath);
+    } else {
+      const stat6 = await fs5.stat(fullPath);
+      size += stat6.size;
+    }
+  }
+  return size;
+}
+async function exportIndex(deps, outputPath) {
+  const outputDir = path8.dirname(outputPath);
+  await fs5.mkdir(outputDir, { recursive: true });
+  const exportDir = path8.join(outputDir, path8.basename(outputPath, path8.extname(outputPath)));
+  await fs5.mkdir(exportDir, { recursive: true });
+  const components = {
+    meta: false,
+    vectors: false,
+    fulltext: false
+  };
+  try {
+    const metaDbPath = path8.join(deps.config.dataDir, "meta.db");
+    const targetMetaPath = path8.join(exportDir, "meta.db");
+    await fs5.copyFile(metaDbPath, targetMetaPath);
+    components.meta = true;
+  } catch (error) {
+    console.warn("\u5BFC\u51FA\u5143\u6570\u636E\u5931\u8D25:", error);
+  }
+  try {
+    const vectorsDir = path8.join(deps.config.dataDir, "vectors");
+    const targetVectorsDir = path8.join(exportDir, "vectors");
+    await copyDirectory(vectorsDir, targetVectorsDir);
+    components.vectors = true;
+  } catch (error) {
+    console.warn("\u5BFC\u51FA\u5411\u91CF\u6570\u636E\u5931\u8D25:", error);
+  }
+  try {
+    const fulltextPath = path8.join(deps.config.dataDir, "fulltext.json");
+    const targetFulltextPath = path8.join(exportDir, "fulltext.json");
+    try {
+      await fs5.access(fulltextPath);
+      await fs5.copyFile(fulltextPath, targetFulltextPath);
+      components.fulltext = true;
+    } catch {
+    }
+  } catch (error) {
+    console.warn("\u5BFC\u51FA\u5168\u6587\u7D22\u5F15\u5931\u8D25:", error);
+  }
+  const stats = deps.getStats();
+  const exportInfo = {
+    exportPath: exportDir,
+    timestamp: /* @__PURE__ */ new Date(),
+    components,
+    stats
+  };
+  const infoPath = path8.join(exportDir, "export-info.json");
+  await fs5.writeFile(infoPath, JSON.stringify(exportInfo, null, 2), "utf-8");
+  return exportInfo;
+}
+async function importIndex(deps, inputPath, createStores) {
+  const stat6 = await fs5.stat(inputPath);
+  let importDir;
+  if (stat6.isDirectory()) {
+    importDir = inputPath;
+  } else {
+    throw new Error("\u76EE\u524D\u53EA\u652F\u6301\u4ECE\u76EE\u5F55\u5BFC\u5165\uFF0C\u8BF7\u5148\u89E3\u538B\u5907\u4EFD\u6587\u4EF6");
+  }
+  const infoPath = path8.join(importDir, "export-info.json");
+  try {
+    await fs5.readFile(infoPath, "utf-8");
+  } catch {
+  }
+  let newMetaStore = deps.metaStore;
+  let newVectorStore = deps.vectorStore;
+  let newFullTextIndex = deps.fullTextIndex;
+  const sourceMetaPath = path8.join(importDir, "meta.db");
+  const targetMetaPath = path8.join(deps.config.dataDir, "meta.db");
+  try {
+    await fs5.access(sourceMetaPath);
+    await fs5.copyFile(sourceMetaPath, targetMetaPath);
+    newMetaStore = new createStores.MetaStore(deps.config.dataDir);
+  } catch (error) {
+    console.warn("\u5BFC\u5165\u5143\u6570\u636E\u5931\u8D25:", error);
+  }
+  const sourceVectorsDir = path8.join(importDir, "vectors");
+  const targetVectorsDir = path8.join(deps.config.dataDir, "vectors");
+  try {
+    await fs5.access(sourceVectorsDir);
+    await copyDirectory(sourceVectorsDir, targetVectorsDir);
+    newVectorStore = new createStores.VectorStore(
+      targetVectorsDir,
+      "documents",
+      getEmbeddingDimension()
+    );
+    await newVectorStore.init();
+  } catch (error) {
+    console.warn("\u5BFC\u5165\u5411\u91CF\u6570\u636E\u5931\u8D25:", error);
+  }
+  const sourceFulltextPath = path8.join(importDir, "fulltext.json");
+  const targetFulltextPath = path8.join(deps.config.dataDir, "fulltext.json");
+  try {
+    await fs5.access(sourceFulltextPath);
+    await fs5.copyFile(sourceFulltextPath, targetFulltextPath);
+    newFullTextIndex = new createStores.FullTextIndex(deps.config.dataDir);
+    await newFullTextIndex.init();
+  } catch (error) {
+    console.warn("\u5BFC\u5165\u5168\u6587\u7D22\u5F15\u5931\u8D25:", error);
+  }
+  deps.reinitializeStores(newMetaStore, newVectorStore, newFullTextIndex);
+  console.log("\u7D22\u5F15\u5BFC\u5165\u5B8C\u6210");
+}
+async function listBackups(backupDir) {
+  try {
+    const entries = await fs5.readdir(backupDir, { withFileTypes: true });
+    const backups = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const backupPath = path8.join(backupDir, entry.name);
+      const infoPath = path8.join(backupPath, "export-info.json");
+      try {
+        const infoContent = await fs5.readFile(infoPath, "utf-8");
+        const exportInfo = JSON.parse(infoContent);
+        const totalSize = await calculateDirSize(backupPath);
+        backups.push({
+          path: backupPath,
+          timestamp: new Date(exportInfo.timestamp),
+          size: totalSize
+        });
+      } catch {
+      }
+    }
+    backups.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
+    return backups;
+  } catch {
+    return [];
+  }
+}
+
+// src/core/pipeline.ts
+import * as path9 from "path";
+import * as fs6 from "fs/promises";
+import { createHash as createHash2 } from "crypto";
+
+// src/core/chunker.ts
+var DEFAULT_OPTIONS = {
+  chunkSize: 800,
+  // 目标块大小
+  overlap: 100,
+  // 重叠大小
+  minChunkSize: 100
+  // 最小块大小
+};
+var SEPARATORS = [
+  "\n\n\n",
+  // 多空行（章节分隔）
+  "\n\n",
+  // 段落分隔
+  "\n",
+  // 换行
+  "\u3002",
+  // 中文句号
+  "\uFF01",
+  // 中文感叹号
+  "\uFF1F",
+  // 中文问号
+  "\uFF1B",
+  // 中文分号
+  ". ",
+  // 英文句号
+  "! ",
+  // 英文感叹号
+  "? ",
+  // 英文问号
+  "; ",
+  // 英文分号
+  "\uFF0C",
+  // 中文逗号
+  ", ",
+  // 英文逗号
+  " "
+  // 空格
+];
+function splitText(text, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (!text.trim()) return [];
+  if (text.length <= opts.chunkSize) {
+    return [{
+      content: text,
+      index: 0,
+      startOffset: 0,
+      endOffset: text.length
+    }];
+  }
+  const rawChunks = recursiveSplit(text, opts.chunkSize, 0);
+  return mergeAndOverlap(rawChunks, text, opts);
+}
+function recursiveSplit(text, targetSize, separatorIndex) {
+  if (text.length <= targetSize) {
+    return [text];
+  }
+  while (separatorIndex < SEPARATORS.length) {
+    const separator = SEPARATORS[separatorIndex];
+    const parts = text.split(separator);
+    if (parts.length > 1) {
+      const chunks = [];
+      let current = "";
+      for (const part of parts) {
+        const withSep = current ? current + separator + part : part;
+        if (withSep.length <= targetSize) {
+          current = withSep;
+        } else if (current) {
+          chunks.push(current);
+          if (part.length > targetSize) {
+            chunks.push(...recursiveSplit(part, targetSize, separatorIndex + 1));
+            current = "";
+          } else {
+            current = part;
+          }
+        } else {
+          chunks.push(...recursiveSplit(part, targetSize, separatorIndex + 1));
+        }
+      }
+      if (current) {
+        chunks.push(current);
+      }
+      return chunks;
+    }
+    separatorIndex++;
+  }
+  return forceChunk(text, targetSize);
+}
+function forceChunk(text, targetSize) {
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    chunks.push(text.slice(start, start + targetSize));
+    start += targetSize;
+  }
+  return chunks;
+}
+function mergeAndOverlap(rawChunks, originalText, opts) {
+  const result = [];
+  let currentOffset = 0;
+  for (let i = 0; i < rawChunks.length; i++) {
+    let content = rawChunks[i].trim();
+    if (!content) {
+      const idx = originalText.indexOf(rawChunks[i], currentOffset);
+      if (idx >= 0) {
+        currentOffset = idx + rawChunks[i].length;
+      }
+      continue;
+    }
+    if (content.length < opts.minChunkSize && result.length > 0) {
+      const lastChunk = result[result.length - 1];
+      if (lastChunk.content.length + content.length < opts.chunkSize * 1.5) {
+        lastChunk.content += "\n" + content;
+        lastChunk.endOffset = currentOffset + rawChunks[i].length;
+        continue;
+      }
+    }
+    const startOffset = originalText.indexOf(content.slice(0, 50), Math.max(0, currentOffset - 10));
+    const actualStart = startOffset >= 0 ? startOffset : currentOffset;
+    if (opts.overlap > 0 && result.length > 0) {
+      const lastChunk = result[result.length - 1];
+      const overlapText = lastChunk.content.slice(-opts.overlap);
+      const sentenceStart = findSentenceStart(overlapText);
+      if (sentenceStart > 0) {
+        content = overlapText.slice(sentenceStart) + "\n" + content;
+      }
+    }
+    result.push({
+      content,
+      index: result.length,
+      startOffset: actualStart,
+      endOffset: actualStart + content.length
+    });
+    currentOffset = actualStart + rawChunks[i].length;
+  }
+  return result;
+}
+function findSentenceStart(text) {
+  const sentenceEnders = ["\u3002", "\uFF01", "\uFF1F", ". ", "! ", "? ", "\n"];
+  for (const ender of sentenceEnders) {
+    const idx = text.lastIndexOf(ender);
+    if (idx >= 0) {
+      return idx + ender.length;
+    }
+  }
+  return 0;
+}
+function getChunkStats(chunks) {
+  if (chunks.length === 0) {
+    return { count: 0, avgSize: 0, minSize: 0, maxSize: 0, totalSize: 0 };
+  }
+  const sizes = chunks.map((c) => c.content.length);
+  const totalSize = sizes.reduce((a, b) => a + b, 0);
+  return {
+    count: chunks.length,
+    avgSize: Math.round(totalSize / chunks.length),
+    minSize: Math.min(...sizes),
+    maxSize: Math.max(...sizes),
+    totalSize
+  };
+}
+
+// src/core/pipeline.ts
+async function hashFile2(filePath) {
+  const content = await fs6.readFile(filePath);
+  return createHash2("md5").update(content).digest("hex");
+}
+var DEFAULT_CONFIG2 = {
+  concurrency: 50,
+  // 高并发
+  chunk: {
+    chunkSize: 8e3,
+    // 8k 字符/块 ≈ 多个段落，小文档自然 1 个 chunk
+    overlap: 500,
+    // 500 字符重叠
+    minChunkSize: 500
+    // 最小块 500 字符
+  }
+};
+var IndexingPipeline = class {
+  config;
+  onProgress;
+  storeCallback;
+  skipCheck;
+  cancelled = false;
+  // 取消标志
+  stats = {
+    totalFiles: 0,
+    completed: 0,
+    stored: 0,
+    skipped: 0,
+    failed: 0,
+    totalTime: 0
+  };
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+  }
+  /** 取消正在执行的任务 */
+  cancel() {
+    this.cancelled = true;
+    console.log("  \u26A0\uFE0F \u7D22\u5F15\u4EFB\u52A1\u5DF2\u53D6\u6D88");
+  }
+  /** 检查是否已取消 */
+  isCancelled() {
+    return this.cancelled;
+  }
+  /**
+   * 处理单个文件（完整流程：解析 → 分块 → 嵌入 → 存储）
+   */
+  async processFile(filePath) {
+    try {
+      if (this.skipCheck) {
+        const stat6 = await fs6.stat(filePath);
+        if (this.skipCheck(filePath, stat6.mtime)) {
+          this.stats.skipped++;
+          return;
+        }
+      }
+      const parsed = await parseDocument(filePath);
+      if (!parsed.content.trim()) {
+        this.stats.skipped++;
+        return;
+      }
+      if (this.cancelled) return;
+      const contentHash = await hashFile2(filePath);
+      if (this.cancelled) return;
+      const chunks = splitText(parsed.content, this.config.chunk);
+      const totalChunks = chunks.length;
+      const embedPromises = chunks.map((chunk) => embedDocument(chunk.content));
+      const vectors = await Promise.all(embedPromises);
+      if (this.cancelled) return;
+      const storePromises = chunks.map(async (chunk, i) => {
+        if (this.cancelled) return false;
+        const doc = {
+          filePath,
+          content: chunk.content,
+          title: parsed.title || path9.basename(filePath),
+          contentHash,
+          vector: vectors[i],
+          chunkIndex: i,
+          totalChunks
+        };
+        const result = await this.storeCallback(doc);
+        return result.stored;
+      });
+      const results = await Promise.all(storePromises);
+      const storedCount = results.filter(Boolean).length;
+      if (storedCount > 0) {
+        this.stats.stored++;
+      } else {
+        this.stats.skipped++;
+      }
+    } catch (error) {
+      this.stats.failed++;
+      console.error(`  \u274C \u5904\u7406\u5931\u8D25 [${filePath}]:`, error instanceof Error ? error.message : error);
+    }
+  }
+  /**
+   * 执行流水线
+   */
+  async run(files, storeCallback, onProgress, skipCheck) {
+    const startTime = Date.now();
+    this.cancelled = false;
+    this.stats = {
+      totalFiles: files.length,
+      completed: 0,
+      stored: 0,
+      skipped: 0,
+      failed: 0,
+      totalTime: 0
+    };
+    this.onProgress = onProgress;
+    this.storeCallback = storeCallback;
+    this.skipCheck = skipCheck;
+    console.log(`  \u{1F680} \u5F00\u59CB\u5904\u7406 ${files.length} \u4E2A\u6587\u4EF6 (\u5E76\u53D1: ${this.config.concurrency})`);
+    const executing = [];
+    let index = 0;
+    while ((index < files.length || executing.length > 0) && !this.cancelled) {
+      while (index < files.length && executing.length < this.config.concurrency && !this.cancelled) {
+        const filePath = files[index++];
+        const fileIndex = index;
+        const promise = this.processFile(filePath).then(() => {
+          if (this.cancelled) return;
+          this.stats.completed++;
+          this.reportProgress(filePath);
+          console.log(`  \u{1F4C4} [${this.stats.completed}/${this.stats.totalFiles}] (\u5E76\u53D1:${executing.length}) ${filePath}`);
+        }).finally(() => {
+          const idx = executing.indexOf(promise);
+          if (idx > -1) executing.splice(idx, 1);
+        });
+        executing.push(promise);
+      }
+      if (executing.length > 0) {
+        await Promise.race(executing);
+      }
+    }
+    if (executing.length > 0) {
+      await Promise.all(executing);
+    }
+    this.stats.totalTime = Date.now() - startTime;
+    if (this.cancelled) {
+      console.log(`
+  \u26A0\uFE0F \u7D22\u5F15\u5DF2\u53D6\u6D88:`);
+      console.log(`     - \u5DF2\u5904\u7406: ${this.stats.completed}/${this.stats.totalFiles}`);
+    } else {
+      console.log(`
+  \u2705 \u5904\u7406\u5B8C\u6210:`);
+    }
+    console.log(`     - \u603B\u8017\u65F6: ${(this.stats.totalTime / 1e3).toFixed(1)}s`);
+    console.log(`     - \u65B0\u589E/\u66F4\u65B0: ${this.stats.stored} \u4E2A`);
+    console.log(`     - \u8DF3\u8FC7: ${this.stats.skipped} \u4E2A`);
+    console.log(`     - \u5931\u8D25: ${this.stats.failed} \u4E2A`);
+    return this.stats;
+  }
+  /** 报告进度 */
+  reportProgress(currentFile) {
+    const { completed, totalFiles } = this.stats;
+    this.onProgress?.({
+      indexed: completed,
+      total: totalFiles,
+      currentFile,
+      stage: completed === totalFiles ? "done" : "storing"
+    });
+  }
+};
+function createIndexingPipeline(config) {
+  return new IndexingPipeline(config);
+}
+
+// src/core/search.ts
+var DocumentSearch = class {
+  config;
+  vectorStore;
+  fullTextIndex;
+  metaStore;
+  initialized = false;
+  directoryWatcher;
+  indexErrors = /* @__PURE__ */ new Map();
+  maxRetries = 3;
+  /** 索引锁：防止同一文件被并发索引 */
+  indexingLocks = /* @__PURE__ */ new Set();
+  /** 当前运行的流水线（用于取消） */
+  currentPipeline = null;
+  constructor(config) {
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    const dataDir = this.config.dataDir;
+    this.vectorStore = new VectorStore(
+      path10.join(dataDir, "vectors"),
+      "documents",
+      getEmbeddingDimension()
+    );
+    this.fullTextIndex = new FullTextIndex(dataDir);
+    this.metaStore = new MetaStore(dataDir);
+    this.directoryWatcher = new DirectoryWatcher({
+      config: this.config,
+      fullTextIndex: this.fullTextIndex,
+      indexFile: (filePath) => this.indexFile(filePath),
+      removeFile: (filePath) => this.removeFile(filePath)
+    });
+  }
+  /**
+   * 初始化搜索引擎
+   */
+  async init() {
+    if (this.initialized) return;
+    await initEmbedder(
+      this.config.arkApiKey,
+      this.config.embeddingModel,
+      this.config.embeddingDimension
+    );
+    await this.vectorStore.init();
+    await this.fullTextIndex.init();
+    this.initialized = true;
+    console.log("DocumentSearch \u521D\u59CB\u5316\u5B8C\u6210");
+  }
+  /**
+   * 索引单个文件（带重试机制和并发安全）
+   */
+  async indexFile(filePath, retryCount = 0) {
+    await this.ensureInitialized();
+    const normalizedPath = path10.normalize(filePath);
+    if (this.indexingLocks.has(normalizedPath)) {
+      return;
+    }
+    this.indexingLocks.add(normalizedPath);
+    try {
+      const stat6 = await fs7.stat(filePath);
+      if (stat6.size > (this.config.maxFileSize || DEFAULT_CONFIG.maxFileSize)) {
+        return;
+      }
+      const existing = this.metaStore.getByPath(filePath);
+      if (existing) {
+        const timeMatch = existing.modifiedAt.getTime() === stat6.mtime.getTime();
+        const sizeMatch = existing.fileSize === stat6.size;
+        if (timeMatch && sizeMatch) {
+          return;
+        }
+        if (sizeMatch) {
+          const contentHash2 = await hashFile(filePath);
+          if (existing.contentHash === contentHash2) {
+            existing.modifiedAt = stat6.mtime;
+            existing.fileSize = stat6.size;
+            this.metaStore.upsert(existing);
+            return;
+          }
+        }
+      }
+      const contentHash = await hashFile(filePath);
+      const duplicateByHash = this.metaStore.getByHash(contentHash);
+      if (duplicateByHash && duplicateByHash.path !== filePath) {
+        const docId2 = generateId();
+        const doc2 = {
+          id: docId2,
+          path: filePath,
+          name: path10.basename(filePath),
+          fileType: getFileType(filePath),
+          extension: path10.extname(filePath).toLowerCase(),
+          title: duplicateByHash.title,
+          // 复用标题
+          content: duplicateByHash.content,
+          // 复用内容
+          fileSize: stat6.size,
+          createdAt: stat6.birthtime,
+          modifiedAt: stat6.mtime,
+          indexedAt: /* @__PURE__ */ new Date(),
+          contentHash
+        };
+        this.metaStore.upsert(doc2);
+        const existingVector = await this.vectorStore.getById(duplicateByHash.id);
+        if (existingVector) {
+          await this.vectorStore.update({ id: docId2, vector: existingVector });
+        }
+        this.fullTextIndex.update({
+          id: docId2,
+          title: doc2.title || doc2.name,
+          content: doc2.content
+        });
+        return;
+      }
+      const parsed = await parseDocument(filePath);
+      if (!parsed.content.trim()) {
+        if (parsed.metadata?.error) {
+          const reason = parsed.metadata.reason;
+          if (reason?.includes("bad XRef") || reason?.includes("FormatError") || reason?.includes("XRef")) {
+            console.warn(`\u8DF3\u8FC7\u635F\u574F\u7684 PDF \u6587\u4EF6: ${filePath} - ${reason}`);
+          } else {
+            console.warn(`\u8DF3\u8FC7\u65E0\u6CD5\u89E3\u6790\u7684\u6587\u4EF6: ${filePath} - ${reason}`);
+          }
+        }
+        return;
+      }
+      const vector = await embedDocument(parsed.content);
+      const docId = existing?.id || generateId();
+      const doc = {
+        id: docId,
+        path: filePath,
+        name: path10.basename(filePath),
+        fileType: getFileType(filePath),
+        extension: path10.extname(filePath).toLowerCase(),
+        title: parsed.title,
+        content: parsed.content,
+        fileSize: stat6.size,
+        createdAt: stat6.birthtime,
+        modifiedAt: stat6.mtime,
+        indexedAt: /* @__PURE__ */ new Date(),
+        contentHash
+      };
+      this.metaStore.upsert(doc);
+      await this.vectorStore.update({ id: docId, vector });
+      this.fullTextIndex.update({
+        id: docId,
+        title: doc.title || doc.name,
+        content: doc.content
+      });
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      const errorStack = err instanceof Error ? err.stack : String(err);
+      const isCommonError = errorMsg.includes("bad XRef") || errorMsg.includes("FormatError") || errorMsg.includes("Invalid PDF") || errorMsg.includes("XRef") || errorStack?.includes("pdf-parse") || errorStack?.includes("pdf.js");
+      const indexError = {
+        filePath,
+        error: errorMsg,
+        retryCount,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.indexErrors.set(filePath, indexError);
+      if (!isCommonError && retryCount < this.maxRetries) {
+        console.warn(`\u7D22\u5F15\u6587\u4EF6\u5931\u8D25\uFF0C\u5C06\u91CD\u8BD5 (${retryCount + 1}/${this.maxRetries}): ${filePath}`);
+        await sleep(1e3 * (retryCount + 1));
+        return this.indexFile(filePath, retryCount + 1);
+      }
+      if (isCommonError) {
+        console.warn(`\u8DF3\u8FC7\u635F\u574F\u7684 PDF \u6587\u4EF6: ${filePath} - ${errorMsg}`);
+      } else {
+        console.warn(`\u7D22\u5F15\u6587\u4EF6\u5931\u8D25: ${filePath} - ${errorMsg}`);
+      }
+      return;
+    } finally {
+      this.indexingLocks.delete(normalizedPath);
+    }
+  }
+  /**
+   * 索引目录（流水线架构）
+   * 三阶段并行处理：解析 → 嵌入 → 存储
+   * 智能增量索引：只处理新增、修改的文件，跳过未变化的文件
+   */
+  async indexDirectory(directory, onProgress, pipelineConfig) {
+    await this.ensureInitialized();
+    const startTime = Date.now();
+    console.log(`
+\u{1F4C1} \u5F00\u59CB\u7D22\u5F15\u76EE\u5F55: ${directory}`);
+    console.log(`  \u23F1\uFE0F  \u5F00\u59CB\u65F6\u95F4: ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`);
+    const notifyProgress = (progress) => {
+      onProgress?.(progress);
+      notifyGlobalProgress(progress);
+    };
+    notifyProgress({ indexed: 0, total: 0, stage: "scanning" });
+    const phase1Start = Date.now();
+    const indexedDocs = this.metaStore.getAll();
+    const indexedPathsInDir = new Set(
+      indexedDocs.filter((doc) => doc.path.startsWith(directory)).map((doc) => doc.path)
+    );
+    console.log(`  \u23F1\uFE0F  \u52A0\u8F7D\u5DF2\u7D22\u5F15\u5217\u8868: ${Date.now() - phase1Start}ms`);
+    console.log(`  \u{1F4CA} \u5DF2\u7D22\u5F15: ${indexedPathsInDir.size} \u4E2A\u6587\u4EF6`);
+    const scanStart = Date.now();
+    console.log(`  \u{1F50D} \u6B63\u5728\u626B\u63CF\u6587\u4EF6\u7CFB\u7EDF...`);
+    let scannedCount = 0;
+    const files = await scanDirectories([directory], {
+      excludeDirs: this.config.excludeDirs,
+      extensions: this.config.extensions,
+      maxFileSize: this.config.maxFileSize,
+      directories: [directory],
+      onProgress: (progress) => {
+        scannedCount = progress.scanned;
+        notifyProgress({
+          indexed: progress.scanned,
+          total: 0,
+          currentFile: progress.currentDir,
+          stage: "scanning"
+        });
+      }
+    });
+    console.log(`  \u23F1\uFE0F  \u626B\u63CF\u8017\u65F6: ${Date.now() - scanStart}ms`);
+    console.log(`  \u{1F4C4} \u627E\u5230 ${files.length} \u4E2A\u6587\u4EF6 (\u626B\u63CF\u4E86 ${scannedCount.toLocaleString()} \u4E2A)`);
+    const analyzeStart = Date.now();
+    notifyProgress({ indexed: 0, total: 0, stage: "parsing", currentFile: "\u6B63\u5728\u5206\u6790\u6587\u4EF6\u53D8\u66F4..." });
+    const filesSet = new Set(files);
+    const normalizedFilesSet = new Set(files.map((f) => path10.normalize(f)));
+    const normalizedIndexedPaths = new Set(
+      Array.from(indexedPathsInDir).map((p) => path10.normalize(p))
+    );
+    const filesToProcess = [];
+    for (const file of files) {
+      const existing = this.metaStore.getByPath(file);
+      if (!existing) {
+        filesToProcess.push(file);
+      } else {
+        filesToProcess.push(file);
+      }
+    }
+    const deletedFiles = [];
+    for (const indexedPath of indexedPathsInDir) {
+      const normalizedIndexedPath = path10.normalize(indexedPath);
+      if (!normalizedFilesSet.has(normalizedIndexedPath) && !filesSet.has(indexedPath)) {
+        deletedFiles.push(indexedPath);
+      }
+    }
+    console.log(`  \u23F1\uFE0F  \u5206\u6790\u53D8\u66F4: ${Date.now() - analyzeStart}ms`);
+    let deletedCount = 0;
+    if (deletedFiles.length > 0) {
+      console.log(`  \u{1F5D1}\uFE0F  \u6E05\u7406 ${deletedFiles.length} \u4E2A\u5DF2\u5220\u9664\u6587\u4EF6\u7684\u7D22\u5F15...`);
+      const deleteResult = await this.removeFiles(deletedFiles);
+      deletedCount = deleteResult.success;
+      console.log(`  \u2705 \u5DF2\u6E05\u7406 ${deletedCount} \u4E2A\u7D22\u5F15`);
+    }
+    console.log(`
+  \u{1F4C8} \u7D22\u5F15\u7EDF\u8BA1:`);
+    console.log(`    - \u626B\u63CF\u6587\u4EF6: ${files.length}`);
+    console.log(`    - \u9700\u8981\u5904\u7406: ${filesToProcess.length}`);
+    console.log(`    - \u5DF2\u5220\u9664: ${deletedFiles.length}`);
+    const indexedMtimeMap = /* @__PURE__ */ new Map();
+    for (const doc of indexedDocs) {
+      if (doc.path.startsWith(directory) && doc.modifiedAt) {
+        indexedMtimeMap.set(doc.path, doc.modifiedAt.getTime());
+      }
+    }
+    this.currentPipeline = createIndexingPipeline(pipelineConfig);
+    const docIdCache = /* @__PURE__ */ new Map();
+    const stats = await this.currentPipeline.run(
+      filesToProcess,
+      // 存储回调（每个 chunk 调用一次）
+      async (doc) => {
+        try {
+          const chunkIndex = doc.chunkIndex ?? 0;
+          const totalChunks = doc.totalChunks ?? 1;
+          if (chunkIndex === 0) {
+            const existing = this.metaStore.getByPath(doc.filePath);
+            if (existing && existing.contentHash === doc.contentHash) {
+              return { stored: false, skipped: true };
+            }
+            if (existing && existing.chunkCount) {
+              for (let i = 0; i < existing.chunkCount; i++) {
+                const oldChunkId = `${existing.id}_${i}`;
+                await this.vectorStore.delete(oldChunkId);
+                this.fullTextIndex.remove(oldChunkId);
+              }
+            }
+            const stat6 = await fs7.stat(doc.filePath);
+            const docId2 = existing?.id || generateId();
+            docIdCache.set(doc.filePath, docId2);
+            const indexedDoc = {
+              id: docId2,
+              path: doc.filePath,
+              name: path10.basename(doc.filePath),
+              fileType: getFileType(doc.filePath),
+              extension: path10.extname(doc.filePath).toLowerCase(),
+              title: doc.title,
+              content: doc.content,
+              // 第一个 chunk 的内容
+              fileSize: stat6.size,
+              createdAt: stat6.birthtime,
+              modifiedAt: stat6.mtime,
+              indexedAt: /* @__PURE__ */ new Date(),
+              contentHash: doc.contentHash,
+              chunkCount: totalChunks
+              // 记录 chunk 数量
+            };
+            this.metaStore.upsert(indexedDoc);
+          }
+          const docId = docIdCache.get(doc.filePath) || this.metaStore.getByPath(doc.filePath)?.id;
+          if (!docId) {
+            return { stored: false, skipped: false };
+          }
+          const chunkId = `${docId}_${chunkIndex}`;
+          await this.vectorStore.update({ id: chunkId, vector: doc.vector });
+          this.fullTextIndex.update({
+            id: chunkId,
+            title: doc.title,
+            content: doc.content
+          });
+          return { stored: true, skipped: false };
+        } catch {
+          return { stored: false, skipped: false };
+        }
+      },
+      notifyProgress,
+      // 快速跳过检查（基于 mtime）
+      (filePath, mtime) => {
+        const indexedMtime = indexedMtimeMap.get(filePath);
+        if (!indexedMtime) return false;
+        return mtime.getTime() <= indexedMtime;
+      }
+    );
+    const wasCancelled = this.currentPipeline?.isCancelled() ?? false;
+    this.currentPipeline = null;
+    await this.fullTextIndex.save();
+    const totalTime = Date.now() - startTime;
+    if (wasCancelled) {
+      console.log(`
+  \u26A0\uFE0F \u7D22\u5F15\u5DF2\u53D6\u6D88:`);
+    } else {
+      console.log(`
+  \u2705 \u7D22\u5F15\u5B8C\u6210:`);
+    }
+    console.log(`  \u23F1\uFE0F  \u603B\u8017\u65F6: ${(totalTime / 1e3).toFixed(1)}s`);
+    console.log(`    \u{1F4E5} \u65B0\u589E/\u66F4\u65B0: ${stats.stored} \u4E2A\u6587\u4EF6`);
+    console.log(`    \u23ED\uFE0F  \u8DF3\u8FC7: ${stats.skipped} \u4E2A\u6587\u4EF6`);
+    console.log(`    \u274C \u5931\u8D25: ${stats.failed} \u4E2A\u6587\u4EF6`);
+    console.log(`    \u{1F5D1}\uFE0F  \u5220\u9664: ${deletedCount} \u4E2A\u6587\u4EF6`);
+    console.log(`    \u{1F4CA} \u603B\u8BA1: ${this.metaStore.getAll().filter((doc) => doc.path.startsWith(directory)).length} \u4E2A\u5DF2\u7D22\u5F15\u6587\u4EF6
+`);
+    if (wasCancelled) {
+      notifyProgress({ indexed: stats.completed, total: filesToProcess.length, stage: "cancelled" });
+    } else {
+      notifyProgress({ indexed: filesToProcess.length, total: filesToProcess.length, stage: "done" });
+    }
+  }
+  /**
+   * 取消正在进行的索引任务
+   * @returns 是否成功取消（如果没有运行中的任务则返回 false）
+   */
+  cancelIndexing() {
+    if (this.currentPipeline) {
+      this.currentPipeline.cancel();
+      console.log("[AI-Search] \u7D22\u5F15\u4EFB\u52A1\u5DF2\u53D1\u51FA\u53D6\u6D88\u4FE1\u53F7");
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 检查是否正在索引
+   */
+  isIndexing() {
+    return this.currentPipeline !== null && !this.currentPipeline.isCancelled();
+  }
+  /**
+   * 索引默认目录
+   */
+  async indexDefaultDirectories(onProgress) {
+    const directories = this.config.indexDirectories || getDefaultDirectories();
+    for (const dir of directories) {
+      await this.indexDirectory(dir, onProgress);
+    }
+  }
+  /**
+   * 搜索文档
+   */
+  async search(query, options) {
+    await this.ensureInitialized();
+    const limit = options?.limit || 10;
+    const mode = options?.mode || "hybrid";
+    let vectorResults = [];
+    let textResults = [];
+    if (mode === "semantic" || mode === "hybrid") {
+      const queryVector = await embedQuery(query);
+      vectorResults = await this.vectorStore.search(queryVector, limit * 2);
+    }
+    if (mode === "keyword" || mode === "hybrid") {
+      textResults = this.fullTextIndex.search(query, limit * 2);
+    }
+    let fusedResults;
+    if (mode === "hybrid") {
+      const hasVectorResults = vectorResults.length > 0;
+      const hasTextResults = textResults.length > 0;
+      if (hasVectorResults && hasTextResults) {
+        fusedResults = reciprocalRankFusion([
+          {
+            results: vectorResults.map((r) => ({
+              id: r.id,
+              score: Math.max(0, 1 - r.distance)
+              // 距离转相似度
+            })),
+            weight: 0.6
+            // 语义搜索权重更高
+          },
+          {
+            results: textResults,
+            weight: 0.4
+          }
+        ]);
+      } else if (hasVectorResults) {
+        fusedResults = this.normalizeVectorScores(vectorResults);
+      } else if (hasTextResults) {
+        fusedResults = textResults;
+      } else {
+        fusedResults = [];
+      }
+    } else if (mode === "semantic") {
+      fusedResults = this.normalizeVectorScores(vectorResults);
+    } else {
+      fusedResults = textResults;
+    }
+    const parseChunkId = (chunkId) => {
+      const lastUnderscore = chunkId.lastIndexOf("_");
+      const chunkIndex = parseInt(chunkId.slice(lastUnderscore + 1), 10);
+      return {
+        docId: chunkId.slice(0, lastUnderscore),
+        chunkIndex
+      };
+    };
+    const topChunkIds = fusedResults.slice(0, limit * 2).map((r) => r.id);
+    const docIds = [...new Set(topChunkIds.map((id) => parseChunkId(id).docId))];
+    const documents = this.metaStore.getByIds(docIds);
+    const docMap = new Map(documents.map((d) => [d.id, d]));
+    const scoreMap = new Map(fusedResults.map((r) => [r.id, r.score]));
+    const results = [];
+    const seenDocs = /* @__PURE__ */ new Set();
+    for (const chunkId of topChunkIds) {
+      if (results.length >= limit) break;
+      const { docId, chunkIndex } = parseChunkId(chunkId);
+      if (seenDocs.has(docId)) continue;
+      const doc = docMap.get(docId);
+      if (!doc) continue;
+      const score = scoreMap.get(chunkId) || 0;
+      if (!this.matchesFilters(doc, options)) {
+        continue;
+      }
+      seenDocs.add(docId);
+      const chunkContent = this.fullTextIndex.getContent(chunkId);
+      results.push({
+        // FileItem 兼容字段
+        id: doc.path,
+        // 使用路径作为 ID，与 file-explorer 兼容
+        name: doc.name,
+        type: doc.fileType,
+        size: formatSize(doc.fileSize),
+        dateModified: formatDate(doc.modifiedAt),
+        url: `file://${doc.path}`,
+        thumbnailUrl: void 0,
+        // 文档类型通常没有缩略图
+        // 搜索特有字段
+        score,
+        snippet: extractSnippet(chunkContent || doc.content, query),
+        matchType: mode === "hybrid" ? "hybrid" : mode === "semantic" ? "semantic" : "keyword",
+        // chunk 信息（可选）
+        chunkIndex
+      });
+    }
+    return results;
+  }
+  /**
+   * 检查文档是否匹配所有过滤条件
+   */
+  matchesFilters(doc, options) {
+    if (!options) return true;
+    const combineMode = options.combineMode || "AND";
+    const filters = [];
+    if (options.fileTypes) {
+      filters.push(options.fileTypes.includes(doc.fileType));
+    }
+    if (options.dateRange) {
+      let dateMatch = true;
+      if (options.dateRange.start && doc.modifiedAt < options.dateRange.start) {
+        dateMatch = false;
+      }
+      if (options.dateRange.end && doc.modifiedAt > options.dateRange.end) {
+        dateMatch = false;
+      }
+      filters.push(dateMatch);
+    }
+    if (options.directories && options.directories.length > 0) {
+      const dirMatch = options.directories.some((dir) => doc.path.startsWith(dir));
+      filters.push(dirMatch);
+    }
+    if (options.sizeRange) {
+      let sizeMatch = true;
+      if (options.sizeRange.min !== void 0 && doc.fileSize < options.sizeRange.min) {
+        sizeMatch = false;
+      }
+      if (options.sizeRange.max !== void 0 && doc.fileSize > options.sizeRange.max) {
+        sizeMatch = false;
+      }
+      filters.push(sizeMatch);
+    }
+    if (options.fileNamePattern) {
+      const pattern = this.wildcardToRegex(options.fileNamePattern);
+      filters.push(pattern.test(doc.name));
+    }
+    if (options.titleContains) {
+      const title = doc.title || doc.name;
+      filters.push(title.toLowerCase().includes(options.titleContains.toLowerCase()));
+    }
+    if (filters.length === 0) return true;
+    if (combineMode === "AND") {
+      return filters.every((f) => f);
+    } else {
+      return filters.some((f) => f);
+    }
+  }
+  /**
+   * 将通配符模式转换为正则表达式
+   * * 匹配任意字符
+   * ? 匹配单个字符
+   */
+  wildcardToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`, "i");
+  }
+  /**
+   * 标准化向量搜索分数
+   * 将距离转换为 0-1 的相似度分数
+   */
+  normalizeVectorScores(vectorResults) {
+    if (vectorResults.length === 0) {
+      return [];
+    }
+    const scores = vectorResults.map((r) => ({
+      id: r.id,
+      rawScore: 1 / (1 + r.distance)
+    }));
+    const maxScore = Math.max(...scores.map((s) => s.rawScore));
+    return scores.map((s) => ({
+      id: s.id,
+      score: maxScore > 0 ? s.rawScore / maxScore : 0
+    }));
+  }
+  /**
+   * 删除文件索引
+   */
+  async removeFile(filePath) {
+    const doc = this.metaStore.getByPath(filePath);
+    if (!doc) return;
+    await this.vectorStore.delete(doc.id);
+    this.fullTextIndex.remove(doc.id);
+    this.metaStore.deleteByPath(filePath);
+  }
+  /**
+   * 获取统计信息
+   */
+  getStats() {
+    const stats = this.metaStore.getStats();
+    stats.directories = this.config.indexDirectories || getDefaultDirectories();
+    return stats;
+  }
+  /**
+   * 清空所有索引
+   */
+  async clear() {
+    this.metaStore.clear();
+    this.fullTextIndex.clear();
+  }
+  /**
+   * 保存索引
+   */
+  async save() {
+    await this.fullTextIndex.save();
+  }
+  /**
+   * 批量索引文件（根据配置自动选择串行或并行）
+   */
+  async indexFiles(filePaths, onProgress) {
+    const enableParallel = this.config.enableParallelIndexing !== false;
+    if (enableParallel && filePaths.length > 1) {
+      return this.indexFilesParallel(filePaths, onProgress);
+    }
+    return this.indexFilesSerial(filePaths, onProgress);
+  }
+  /**
+   * 串行索引文件（原实现）
+   */
+  async indexFilesSerial(filePaths, onProgress) {
+    await this.ensureInitialized();
+    const result = {
+      success: 0,
+      failed: 0,
+      errors: []
+    };
+    const total = filePaths.length;
+    onProgress?.({ indexed: 0, total, stage: "parsing" });
+    for (let i = 0; i < filePaths.length; i++) {
+      const filePath = filePaths[i];
+      try {
+        await this.indexFile(filePath);
+        result.success++;
+      } catch (error) {
+        result.failed++;
+        result.errors.push({
+          path: filePath,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      onProgress?.({
+        indexed: i + 1,
+        total,
+        currentFile: filePath,
+        stage: i === filePaths.length - 1 ? "done" : "parsing"
+      });
+      if (i % 10 === 0) {
+        await sleep(10);
+      }
+    }
+    await this.fullTextIndex.save();
+    return result;
+  }
+  /**
+   * 并行索引文件（控制并发数）
+   */
+  async indexFilesParallel(filePaths, onProgress, concurrency) {
+    await this.ensureInitialized();
+    const result = {
+      success: 0,
+      failed: 0,
+      errors: []
+    };
+    const total = filePaths.length;
+    const concurrencyLimit = concurrency || this.config.indexConcurrency || 5;
+    onProgress?.({ indexed: 0, total, stage: "parsing" });
+    let processed = 0;
+    let currentIndex = 0;
+    const running = /* @__PURE__ */ new Set();
+    const processNext = async () => {
+      while (currentIndex < total) {
+        const fileIndex = currentIndex++;
+        const filePath = filePaths[fileIndex];
+        const task = (async () => {
+          try {
+            await this.indexFile(filePath);
+            result.success++;
+          } catch (error) {
+            result.failed++;
+            result.errors.push({
+              path: filePath,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          } finally {
+            processed++;
+            onProgress?.({
+              indexed: processed,
+              total,
+              currentFile: filePath,
+              stage: processed === total ? "done" : "parsing"
+            });
+          }
+        })();
+        running.add(task);
+        task.finally(() => {
+          running.delete(task);
+        });
+        if (running.size >= concurrencyLimit) {
+          await Promise.race(running);
+        }
+      }
+    };
+    const workers = Array.from({ length: Math.min(concurrencyLimit, total) }, () => processNext());
+    await Promise.all(workers);
+    await Promise.all(running);
+    await this.fullTextIndex.save();
+    return result;
+  }
+  /**
+   * 批量删除文件索引
+   */
+  async removeFiles(filePaths) {
+    const result = {
+      success: 0,
+      failed: 0,
+      errors: []
+    };
+    let notFound = 0;
+    for (const filePath of filePaths) {
+      try {
+        const doc = this.metaStore.getByPath(filePath);
+        if (!doc) {
+          notFound++;
+          continue;
+        }
+        await this.removeFile(filePath);
+        result.success++;
+      } catch (error) {
+        result.failed++;
+        result.errors.push({
+          path: filePath,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    if (notFound > 0 && result.errors.length < 10) {
+      result.errors.push({
+        path: `[${notFound} \u4E2A\u6587\u4EF6\u4E0D\u5B58\u5728\u4E8E\u7D22\u5F15\u4E2D]`,
+        error: "\u6587\u4EF6\u53EF\u80FD\u5DF2\u88AB\u5220\u9664\u6216\u8DEF\u5F84\u4E0D\u5339\u914D"
+      });
+    }
+    return result;
+  }
+  /**
+   * 批量更新文件索引（重新索引）
+   */
+  async updateFiles(filePaths, onProgress) {
+    await this.removeFiles(filePaths);
+    return this.indexFiles(filePaths, onProgress);
+  }
+  // ==================== 目录监听（委托给 DirectoryWatcher）====================
+  /** 监听目录变化并自动更新索引 */
+  watchDirectory(directory, options) {
+    this.directoryWatcher.watch(directory, options);
+  }
+  /** 停止监听目录 */
+  unwatchDirectory(directory) {
+    this.directoryWatcher.unwatch(directory);
+  }
+  /** 停止所有监听 */
+  unwatchAll() {
+    this.directoryWatcher.unwatchAll();
+  }
+  /** 获取正在监听的目录列表 */
+  getWatchedDirectories() {
+    return this.directoryWatcher.getWatchedDirectories();
+  }
+  // ==================== 维护功能（委托给 maintenance 模块）====================
+  /** 获取维护依赖 */
+  getMaintenanceDeps() {
+    return {
+      metaStore: this.metaStore,
+      vectorStore: this.vectorStore,
+      fullTextIndex: this.fullTextIndex,
+      indexErrors: this.indexErrors,
+      indexFile: (filePath) => this.indexFile(filePath),
+      removeFile: (filePath) => this.removeFile(filePath),
+      indexFiles: (filePaths) => this.indexFiles(filePaths)
+    };
+  }
+  /** 清理无效索引（文件已删除但索引还在） */
+  async cleanup() {
+    await this.ensureInitialized();
+    return cleanup(this.getMaintenanceDeps());
+  }
+  /** 优化索引（压缩、碎片整理） */
+  async optimize() {
+    await this.ensureInitialized();
+    return optimize(this.getMaintenanceDeps());
+  }
+  /** 健康检查 */
+  async healthCheck() {
+    await this.ensureInitialized();
+    return healthCheck(this.getMaintenanceDeps());
+  }
+  /** 获取索引错误列表 */
+  getIndexErrors() {
+    return getIndexErrors(this.getMaintenanceDeps());
+  }
+  /** 重试失败的索引 */
+  async retryFailedIndexes() {
+    return retryFailedIndexes(this.getMaintenanceDeps());
+  }
+  /** 确保已初始化 */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.init();
+    }
+  }
+  // ==================== 备份功能（委托给 backup 模块）====================
+  /** 获取备份依赖 */
+  getBackupDeps() {
+    return {
+      config: this.config,
+      metaStore: this.metaStore,
+      vectorStore: this.vectorStore,
+      fullTextIndex: this.fullTextIndex,
+      getStats: () => this.getStats(),
+      reinitializeStores: (newMetaStore, newVectorStore, newFullTextIndex) => {
+        this.metaStore = newMetaStore;
+        this.vectorStore = newVectorStore;
+        this.fullTextIndex = newFullTextIndex;
+      }
+    };
+  }
+  /** 导出索引数据 */
+  async exportIndex(outputPath) {
+    await this.ensureInitialized();
+    return exportIndex(this.getBackupDeps(), outputPath);
+  }
+  /** 导入索引数据 */
+  async importIndex(inputPath) {
+    await this.ensureInitialized();
+    return importIndex(this.getBackupDeps(), inputPath, {
+      MetaStore,
+      VectorStore,
+      FullTextIndex
+    });
+  }
+  /** 列出备份 */
+  async listBackups(backupDir) {
+    return listBackups(backupDir);
+  }
+  // ==================== 资源清理 ====================
+  /** 销毁资源，释放所有占用的资源 */
+  async destroy() {
+    this.unwatchAll();
+    this.directoryWatcher.clearTimers();
+    this.indexingLocks.clear();
+    try {
+      this.metaStore.close();
+    } catch (error) {
+      console.warn("\u5173\u95ED MetaStore \u5931\u8D25:", error);
+    }
+    try {
+      this.vectorStore.close();
+    } catch (error) {
+      console.warn("\u5173\u95ED VectorStore \u5931\u8D25:", error);
+    }
+    try {
+      disposeEmbedder();
+    } catch (error) {
+      console.warn("\u6E05\u7406 Embedding \u6A21\u578B\u5931\u8D25:", error);
+    }
+    this.indexErrors.clear();
+    this.initialized = false;
+    console.log("DocumentSearch \u8D44\u6E90\u5DF2\u6E05\u7406");
+  }
+};
+
+// src/tools/index.ts
+var SEARCH_PLUGIN_KEY = /* @__PURE__ */ Symbol.for("ai-search-plugin-instance");
+function getGlobalSearchPlugin() {
+  const g = globalThis;
+  return g[SEARCH_PLUGIN_KEY] ?? null;
+}
+function setGlobalSearchPlugin(instance) {
+  const g = globalThis;
+  g[SEARCH_PLUGIN_KEY] = instance;
+}
+function searchPlugin(options) {
+  return createSearchPluginInstance(options);
+}
+function getSearchPlugin() {
+  return getGlobalSearchPlugin();
+}
+async function createSearchPluginInstance(options) {
+  const { dataDir, workspace, arkApiKey: arkApiKey2, embeddingDimension: embeddingDimension2 } = options;
+  try {
+    console.log("\u{1F4C2} \u6B63\u5728\u521D\u59CB\u5316\u6587\u6863\u641C\u7D22\u5F15\u64CE...", dataDir);
+    const search = new DocumentSearch({
+      dataDir,
+      arkApiKey: arkApiKey2,
+      embeddingDimension: embeddingDimension2
+    });
+    await search.init();
+    console.log("\u2705 \u6587\u6863\u641C\u7D22\u5F15\u64CE\u521D\u59CB\u5316\u5B8C\u6210:", dataDir);
+    const workspaceState = {
+      directory: null,
+      indexed: false,
+      filesIndexed: 0
+    };
+    const setWorkspace = async (directory) => {
+      workspaceState.directory = directory;
+      workspaceState.indexed = false;
+      workspaceState.filesIndexed = 0;
+      console.log(`\u{1F4C1} \u5F00\u59CB\u7D22\u5F15\u5DE5\u4F5C\u7A7A\u95F4: ${directory}`);
+      try {
+        await search.indexDirectory(directory, (progress) => {
+          if (progress.stage !== "scanning" && progress.total > 0) {
+            workspaceState.filesIndexed = progress.indexed;
+            if (progress.indexed % 100 === 0) {
+              console.log(`  \u{1F4C4} \u5DF2\u7D22\u5F15 ${progress.indexed}/${progress.total} \u4E2A\u6587\u4EF6...`);
+            }
+          }
+        });
+        workspaceState.indexed = true;
+        console.log(`\u2705 \u5DE5\u4F5C\u7A7A\u95F4\u7D22\u5F15\u5B8C\u6210\uFF0C\u5171 ${workspaceState.filesIndexed} \u4E2A\u6587\u4EF6`);
+      } catch (error) {
+        console.error("\u274C \u5DE5\u4F5C\u7A7A\u95F4\u7D22\u5F15\u5931\u8D25:", error);
+        throw error;
+      }
+    };
+    if (workspace) {
+      console.log(`\u{1F4C1} \u68C0\u6D4B\u5230\u5DE5\u4F5C\u7A7A\u95F4\uFF0C\u5C06\u5728\u540E\u53F0\u5F00\u59CB\u7D22\u5F15: ${workspace}`);
+      setWorkspace(workspace).catch((error) => {
+        console.error("\u274C \u540E\u53F0\u7D22\u5F15\u5931\u8D25:", error);
+      });
+    }
+    const tools = [
+      createSearchDocumentsTool(search, workspaceState),
+      createIndexFileTool(search),
+      createIndexDirectoryTool(search),
+      createIndexFilesTool(search),
+      createRemoveFilesTool(search),
+      createUpdateFilesTool(search),
+      createGetStatsTool(search, workspaceState),
+      createClearIndexTool(search),
+      createSetWorkspaceTool(search, workspaceState),
+      createGetWorkspaceTool(workspaceState),
+      createWatchDirectoryTool(search),
+      createUnwatchDirectoryTool(search),
+      createGetWatchedDirectoriesTool(search),
+      createCleanupIndexTool(search),
+      createExportIndexTool(search),
+      createImportIndexTool(search),
+      createListBackupsTool(search),
+      createOptimizeIndexTool(search),
+      createHealthCheckTool(search),
+      createGetIndexErrorsTool(search),
+      createRetryFailedIndexesTool(search)
+    ];
+    const instance = {
+      tools,
+      setWorkspace,
+      getWorkspaceState: () => ({ ...workspaceState }),
+      search
+    };
+    setGlobalSearchPlugin(instance);
+    return instance;
+  } catch (error) {
+    console.error("\u274C \u641C\u7D22\u63D2\u4EF6\u521D\u59CB\u5316\u5931\u8D25:", error);
+    throw error;
+  }
+}
+function createSearchDocumentsTool(search, workspaceState) {
+  return {
+    name: "search_local_documents",
+    description: `\u641C\u7D22\u7528\u6237\u7535\u8111\u4E0A\u7684\u672C\u5730\u6587\u6863\uFF0C\u652F\u6301\u8BED\u4E49\u641C\u7D22\uFF08\u7406\u89E3\u610F\u56FE\uFF09\u548C\u5173\u952E\u8BCD\u641C\u7D22\u3002
+
+\u26A0\uFE0F \u91CD\u8981\uFF1A\u67E5\u627E\u6587\u6863\u65F6\uFF0C\u4F18\u5148\u4F7F\u7528\u6B64\u5DE5\u5177\u800C\u4E0D\u662F execute_command \u6267\u884C find \u547D\u4EE4\uFF01
+- \u6B64\u5DE5\u5177\u652F\u6301\u8BED\u4E49\u7406\u89E3\uFF0C\u53EF\u4EE5\u6839\u636E\u5185\u5BB9\u67E5\u627E\u6587\u6863\uFF0C\u4E0D\u4EC5\u4EC5\u662F\u6587\u4EF6\u540D\u5339\u914D
+- \u5DF2\u7D22\u5F15\u7684\u6587\u6863\u53EF\u4EE5\u76F4\u63A5\u641C\u7D22\uFF0C\u65E0\u9700\u904D\u5386\u6587\u4EF6\u7CFB\u7EDF
+- \u652F\u6301\u6309\u6587\u4EF6\u7C7B\u578B\u8FC7\u6EE4\uFF08\u5982\u53EA\u641C\u7D22 PDF\uFF1Afile_types="pdf"\uFF09
+
+\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B\uFF1A
+- Word \u6587\u6863 (.docx, .doc)
+- PDF \u6587\u4EF6 (.pdf)
+- Excel \u8868\u683C (.xlsx, .xls)
+- PPT \u6F14\u793A\u6587\u7A3F (.pptx, .ppt)
+- \u6587\u672C\u6587\u4EF6 (.txt, .md)
+
+\u4F7F\u7528\u573A\u666F\uFF1A
+- \u7528\u6237\u60F3\u67E5\u627E\u67D0\u4E2A\u4E3B\u9898\u7684\u6587\u6863\uFF0C\u5982"\u627E\u4E00\u4E0B\u53BB\u5E74\u7684\u91C7\u8D2D\u5408\u540C"\u3001"\u641C\u7D22\u5173\u4E8E\u7CD6\u5C3F\u75C5\u7684PDF\u6587\u6863"
+- \u7528\u6237\u9700\u8981\u7279\u5B9A\u5185\u5BB9\u7684\u6587\u4EF6\uFF0C\u5982"\u5173\u4E8E\u7528\u6237\u9690\u79C1\u653F\u7B56\u7684\u6587\u6863"
+- \u7528\u6237\u8BB0\u4E0D\u6E05\u6587\u4EF6\u540D\u4F46\u8BB0\u5F97\u5185\u5BB9\uFF0C\u5982"\u6709\u4E2A\u6587\u6863\u63D0\u5230\u4E86\u5B63\u5EA6\u9500\u552E\u76EE\u6807"
+- \u7528\u6237\u60F3\u627E\u7279\u5B9A\u7C7B\u578B\u7684\u6587\u4EF6\uFF0C\u5982"\u627E\u6240\u6709PDF\u6587\u4EF6"\uFF08\u4F7F\u7528 file_types="pdf"\uFF09
+
+\u641C\u7D22\u8303\u56F4\uFF1A
+- \u5982\u679C\u8BBE\u7F6E\u4E86\u5DE5\u4F5C\u7A7A\u95F4\uFF0C\u9ED8\u8BA4\u53EA\u641C\u7D22\u5DE5\u4F5C\u7A7A\u95F4\u5185\u7684\u6587\u6863
+- \u53EF\u4EE5\u901A\u8FC7 scope \u53C2\u6570\u9009\u62E9\u641C\u7D22\u8303\u56F4\uFF1Aworkspace\uFF08\u5DE5\u4F5C\u7A7A\u95F4\uFF09\u3001all\uFF08\u5168\u90E8\u5DF2\u7D22\u5F15\uFF09
+- \u4F7F\u7528 set_search_workspace \u5DE5\u5177\u53EF\u4EE5\u8BBE\u7F6E\u5DE5\u4F5C\u7A7A\u95F4`,
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: '\u641C\u7D22\u5185\u5BB9\uFF0C\u53EF\u4EE5\u662F\u5173\u952E\u8BCD\u6216\u81EA\u7136\u8BED\u8A00\u63CF\u8FF0\uFF0C\u5982"\u91C7\u8D2D\u5408\u540C"\u6216"\u5173\u4E8E\u9879\u76EE\u9884\u7B97\u7684\u6587\u6863"'
+        },
+        limit: {
+          type: "number",
+          description: "\u8FD4\u56DE\u7ED3\u679C\u6570\u91CF\uFF0C\u9ED8\u8BA4 10\uFF0C\u6700\u5927 50"
+        },
+        mode: {
+          type: "string",
+          enum: ["semantic", "keyword", "hybrid"],
+          description: "\u641C\u7D22\u6A21\u5F0F\uFF1Asemantic\uFF08\u8BED\u4E49\uFF0C\u7406\u89E3\u610F\u56FE\uFF09\u3001keyword\uFF08\u7CBE\u786E\u5173\u952E\u8BCD\uFF09\u3001hybrid\uFF08\u6DF7\u5408\uFF0C\u63A8\u8350\uFF09"
+        },
+        file_types: {
+          type: "string",
+          description: '\u9650\u5B9A\u6587\u4EF6\u7C7B\u578B\uFF0C\u9017\u53F7\u5206\u9694\uFF0C\u53EF\u9009\uFF1Adocument,pdf,text\u3002\u5982 "pdf,document"'
+        },
+        scope: {
+          type: "string",
+          enum: ["workspace", "all"],
+          description: "\u641C\u7D22\u8303\u56F4\uFF1Aworkspace\uFF08\u4EC5\u5DE5\u4F5C\u7A7A\u95F4\uFF0C\u9ED8\u8BA4\uFF09\u3001all\uFF08\u5168\u90E8\u5DF2\u7D22\u5F15\u6587\u6863\uFF09"
+        }
+      },
+      required: ["query"]
+    },
+    execute: async (args, _context) => {
+      const query = args.query;
+      const limit = Math.min(args.limit || 10, 50);
+      const mode = args.mode || "hybrid";
+      const scope = args.scope || "workspace";
+      const options = { limit, mode };
+      if (args.file_types) {
+        const types = args.file_types.split(",").map((t) => t.trim());
+        options.fileTypes = types;
+      }
+      let results = await search.search(query, options);
+      if (scope === "workspace" && workspaceState.directory) {
+        results = results.filter((r) => r.id.startsWith(workspaceState.directory));
+      }
+      if (results.length === 0) {
+        const suggestion = workspaceState.directory && scope === "workspace" ? '\u53EF\u4EE5\u5C1D\u8BD5\u6362\u4E2A\u5173\u952E\u8BCD\uFF0C\u6216\u4F7F\u7528 scope="all" \u641C\u7D22\u5168\u90E8\u6587\u6863\uFF0C\u6216\u7528 set_search_workspace \u8BBE\u7F6E\u65B0\u7684\u5DE5\u4F5C\u7A7A\u95F4' : "\u53EF\u4EE5\u5C1D\u8BD5\u6362\u4E2A\u5173\u952E\u8BCD\uFF0C\u6216\u8005\u5148\u7528 set_search_workspace \u8BBE\u7F6E\u5DE5\u4F5C\u7A7A\u95F4";
+        return JSON.stringify({
+          message: "\u6CA1\u6709\u627E\u5230\u5339\u914D\u7684\u6587\u6863",
+          suggestion,
+          workspace: workspaceState.directory,
+          scope
+        });
+      }
+      const formattedResults = results.map((r, idx) => ({
+        rank: idx + 1,
+        path: r.id,
+        name: r.name,
+        type: r.type,
+        size: r.size,
+        modified: r.dateModified,
+        relevance: `${Math.round(r.score * 100)}%`,
+        matchType: r.matchType,
+        snippet: r.snippet
+      }));
+      return JSON.stringify({
+        query,
+        mode,
+        scope,
+        workspace: workspaceState.directory,
+        total: results.length,
+        results: formattedResults
+      });
+    }
+  };
+}
+function createIndexFileTool(search) {
+  return {
+    name: "index_document_file",
+    description: `\u5C06\u6307\u5B9A\u7684\u6587\u6863\u6587\u4EF6\u6DFB\u52A0\u5230\u641C\u7D22\u7D22\u5F15\u4E2D\u3002
+\u7D22\u5F15\u540E\uFF0C\u8BE5\u6587\u4EF6\u53EF\u4EE5\u901A\u8FC7 search_local_documents \u641C\u7D22\u5230\u3002
+\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B\uFF1A.docx, .doc, .pdf, .xlsx, .xls, .pptx, .ppt, .txt, .md`,
+    parameters: {
+      type: "object",
+      properties: {
+        file_path: {
+          type: "string",
+          description: "\u8981\u7D22\u5F15\u7684\u6587\u4EF6\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u5982 /Users/xxx/Documents/report.pdf"
+        }
+      },
+      required: ["file_path"]
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    // 声明会修改索引数据
+    execute: async (args, _context) => {
+      const filePath = args.file_path;
+      try {
+        await search.indexFile(filePath);
+        return JSON.stringify({
+          success: true,
+          message: `\u6587\u4EF6\u5DF2\u6210\u529F\u7D22\u5F15: ${filePath}`,
+          path: filePath
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          path: filePath
+        });
+      }
+    }
+  };
+}
+function createIndexDirectoryTool(search) {
+  return {
+    name: "index_document_directory",
+    description: `\u626B\u63CF\u5E76\u7D22\u5F15\u6307\u5B9A\u76EE\u5F55\u4E0B\u7684\u6240\u6709\u6587\u6863\u6587\u4EF6\uFF08\u5305\u62EC\u5B50\u76EE\u5F55\uFF09\u3002
+\u7D22\u5F15\u5B8C\u6210\u540E\uFF0C\u76EE\u5F55\u5185\u7684\u6240\u6709\u652F\u6301\u7684\u6587\u6863\u90FD\u53EF\u4EE5\u88AB\u641C\u7D22\u3002
+\u9996\u6B21\u7D22\u5F15\u53EF\u80FD\u9700\u8981\u4E00\u4E9B\u65F6\u95F4\uFF0C\u53D6\u51B3\u4E8E\u6587\u4EF6\u6570\u91CF\u3002
+
+\u4F7F\u7528\u573A\u666F\uFF1A
+- \u7528\u6237\u60F3\u641C\u7D22\u67D0\u4E2A\u76EE\u5F55\u4F46\u8FD8\u6CA1\u7D22\u5F15\u8FC7
+- \u7528\u6237\u7684\u6587\u6863\u76EE\u5F55\u6709\u66F4\u65B0\uFF0C\u9700\u8981\u91CD\u65B0\u7D22\u5F15`,
+    parameters: {
+      type: "object",
+      properties: {
+        directory: {
+          type: "string",
+          description: "\u8981\u7D22\u5F15\u7684\u76EE\u5F55\u7EDD\u5BF9\u8DEF\u5F84\uFF0C\u5982 /Users/xxx/Documents \u6216 ~/Documents"
+        }
+      },
+      required: ["directory"]
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (args, context) => {
+      let directory = args.directory;
+      if (directory.startsWith("~")) {
+        const os3 = await import("os");
+        directory = directory.replace("~", os3.homedir());
+      }
+      const path11 = await import("path");
+      const isAbsolute2 = path11.isAbsolute(directory);
+      if (!isAbsolute2) {
+        directory = path11.resolve(context.cwd, directory);
+      }
+      try {
+        let indexed = 0;
+        let total = 0;
+        await search.indexDirectory(directory, (progress) => {
+          indexed = progress.indexed;
+          total = progress.total;
+        });
+        return JSON.stringify({
+          success: true,
+          message: `\u76EE\u5F55\u7D22\u5F15\u5B8C\u6210`,
+          directory,
+          filesIndexed: indexed,
+          filesFound: total
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          directory
+        });
+      }
+    }
+  };
+}
+function createGetStatsTool(search, workspaceState) {
+  return {
+    name: "get_document_index_stats",
+    description: `\u83B7\u53D6\u6587\u6863\u641C\u7D22\u7D22\u5F15\u7684\u7EDF\u8BA1\u4FE1\u606F\u3002
+\u5305\u62EC\u5DF2\u7D22\u5F15\u6587\u6863\u6570\u91CF\u3001\u6587\u4EF6\u7C7B\u578B\u5206\u5E03\u3001\u7D22\u5F15\u76EE\u5F55\u3001\u5F53\u524D\u5DE5\u4F5C\u7A7A\u95F4\u7B49\u3002
+\u7528\u4E8E\u4E86\u89E3\u5F53\u524D\u7D22\u5F15\u72B6\u6001\uFF0C\u5E2E\u52A9\u51B3\u5B9A\u662F\u5426\u9700\u8981\u7D22\u5F15\u65B0\u76EE\u5F55\u3002`,
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    execute: async (_args, _context) => {
+      const stats = search.getStats();
+      return JSON.stringify({
+        totalDocuments: stats.totalDocuments,
+        byType: stats.byType,
+        indexedDirectories: stats.directories,
+        lastUpdated: stats.lastUpdated?.toISOString() || "N/A",
+        indexSize: stats.indexSize,
+        // 工作空间信息
+        workspace: {
+          directory: workspaceState.directory,
+          indexed: workspaceState.indexed,
+          filesIndexed: workspaceState.filesIndexed
+        }
+      });
+    }
+  };
+}
+function createClearIndexTool(search) {
+  return {
+    name: "clear_document_index",
+    description: `\u6E05\u9664\u6240\u6709\u6587\u6863\u7D22\u5F15\u6570\u636E\u3002
+\u8FD9\u662F\u4E00\u4E2A\u5371\u9669\u64CD\u4F5C\uFF0C\u4F1A\u5220\u9664\u6240\u6709\u5DF2\u7D22\u5F15\u7684\u6587\u6863\u4FE1\u606F\u3002
+\u6E05\u9664\u540E\u9700\u8981\u91CD\u65B0\u7D22\u5F15\u624D\u80FD\u641C\u7D22\u3002
+\u901A\u5E38\u53EA\u5728\u7D22\u5F15\u51FA\u95EE\u9898\u6216\u9700\u8981\u91CD\u5EFA\u65F6\u4F7F\u7528\u3002`,
+    parameters: {
+      type: "object",
+      properties: {
+        confirm: {
+          type: "string",
+          description: '\u786E\u8BA4\u6E05\u9664\uFF0C\u5FC5\u987B\u8F93\u5165 "YES" \u624D\u4F1A\u6267\u884C'
+        }
+      },
+      required: ["confirm"]
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (args, _context) => {
+      if (args.confirm !== "YES") {
+        return JSON.stringify({
+          success: false,
+          message: '\u64CD\u4F5C\u53D6\u6D88\uFF1A\u9700\u8981\u8F93\u5165 "YES" \u786E\u8BA4\u6E05\u9664'
+        });
+      }
+      try {
+        await search.clear();
+        return JSON.stringify({
+          success: true,
+          message: "\u7D22\u5F15\u5DF2\u6E05\u9664\uFF0C\u9700\u8981\u91CD\u65B0\u7D22\u5F15\u6587\u6863"
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createSetWorkspaceTool(search, workspaceState) {
+  return {
+    name: "set_search_workspace",
+    description: `\u8BBE\u7F6E\u6587\u6863\u641C\u7D22\u7684\u5DE5\u4F5C\u7A7A\u95F4\u76EE\u5F55\u3002
+
+\u8BBE\u7F6E\u540E\uFF1A
+- \u5DE5\u4F5C\u7A7A\u95F4\u5185\u7684\u6587\u6863\u4F1A\u88AB\u81EA\u52A8\u7D22\u5F15
+- search_local_documents \u9ED8\u8BA4\u53EA\u641C\u7D22\u5DE5\u4F5C\u7A7A\u95F4\u5185\u7684\u6587\u6863
+- \u53EF\u4EE5\u968F\u65F6\u66F4\u6362\u5DE5\u4F5C\u7A7A\u95F4
+
+\u4F7F\u7528\u573A\u666F\uFF1A
+- \u7528\u6237\u8BF4"\u5728\u8FD9\u4E2A\u9879\u76EE\u91CC\u627E\u6587\u6863"\u65F6\uFF0C\u8BBE\u7F6E\u5F53\u524D\u76EE\u5F55\u4E3A\u5DE5\u4F5C\u7A7A\u95F4
+- \u7528\u6237\u5207\u6362\u9879\u76EE\u65F6\uFF0C\u66F4\u65B0\u5DE5\u4F5C\u7A7A\u95F4
+- \u7528\u6237\u60F3\u641C\u7D22\u7279\u5B9A\u6587\u4EF6\u5939\u7684\u6587\u6863`,
+    parameters: {
+      type: "object",
+      properties: {
+        directory: {
+          type: "string",
+          description: "\u5DE5\u4F5C\u7A7A\u95F4\u76EE\u5F55\u8DEF\u5F84\uFF0C\u53EF\u4EE5\u662F\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D cwd\uFF09"
+        }
+      },
+      required: ["directory"]
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (args, context) => {
+      let directory = args.directory;
+      if (directory.startsWith("~")) {
+        const os3 = await import("os");
+        directory = directory.replace("~", os3.homedir());
+      }
+      const pathModule = await import("path");
+      if (!pathModule.isAbsolute(directory)) {
+        directory = pathModule.resolve(context.cwd, directory);
+      }
+      const fs8 = await import("fs/promises");
+      try {
+        const stat6 = await fs8.stat(directory);
+        if (!stat6.isDirectory()) {
+          return JSON.stringify({
+            success: false,
+            error: "\u6307\u5B9A\u8DEF\u5F84\u4E0D\u662F\u4E00\u4E2A\u76EE\u5F55",
+            path: directory
+          });
+        }
+      } catch {
+        return JSON.stringify({
+          success: false,
+          error: "\u76EE\u5F55\u4E0D\u5B58\u5728",
+          path: directory
+        });
+      }
+      workspaceState.directory = directory;
+      workspaceState.indexed = false;
+      workspaceState.filesIndexed = 0;
+      try {
+        await search.indexDirectory(directory, (progress) => {
+          workspaceState.filesIndexed = progress.indexed;
+        });
+        workspaceState.indexed = true;
+        return JSON.stringify({
+          success: true,
+          message: `\u5DE5\u4F5C\u7A7A\u95F4\u5DF2\u8BBE\u7F6E\u5E76\u7D22\u5F15\u5B8C\u6210`,
+          workspace: directory,
+          filesIndexed: workspaceState.filesIndexed
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          workspace: directory
+        });
+      }
+    }
+  };
+}
+function createIndexFilesTool(search) {
+  return {
+    name: "index_document_files",
+    description: `\u6279\u91CF\u7D22\u5F15\u591A\u4E2A\u6587\u6863\u6587\u4EF6\u3002
+\u76F8\u6BD4\u5355\u4E2A\u6587\u4EF6\u7D22\u5F15\uFF0C\u6279\u91CF\u7D22\u5F15\u6548\u7387\u66F4\u9AD8\uFF0C\u9002\u5408\u4E00\u6B21\u6027\u7D22\u5F15\u591A\u4E2A\u6587\u4EF6\u3002
+\u4F1A\u8FD4\u56DE\u6210\u529F\u548C\u5931\u8D25\u7684\u6570\u91CF\uFF0C\u4EE5\u53CA\u5931\u8D25\u7684\u6587\u4EF6\u5217\u8868\u3002`,
+    parameters: {
+      type: "object",
+      properties: {
+        file_paths: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "\u8981\u7D22\u5F15\u7684\u6587\u4EF6\u8DEF\u5F84\u6570\u7EC4\uFF08\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+        }
+      },
+      required: ["file_paths"]
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (args, _context) => {
+      const filePaths = args.file_paths;
+      if (!Array.isArray(filePaths) || filePaths.length === 0) {
+        return JSON.stringify({
+          success: false,
+          error: "file_paths \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4"
+        });
+      }
+      try {
+        const result = await search.indexFiles(filePaths);
+        return JSON.stringify({
+          success: true,
+          message: `\u6279\u91CF\u7D22\u5F15\u5B8C\u6210`,
+          successCount: result.success,
+          failedCount: result.failed,
+          errors: result.errors
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createRemoveFilesTool(search) {
+  return {
+    name: "remove_document_files",
+    description: `\u6279\u91CF\u5220\u9664\u591A\u4E2A\u6587\u4EF6\u7684\u7D22\u5F15\u3002
+\u7528\u4E8E\u6E05\u7406\u4E0D\u518D\u9700\u8981\u7684\u6587\u6863\u7D22\u5F15\uFF0C\u6BD4\u5982\u6587\u4EF6\u5DF2\u5220\u9664\u6216\u79FB\u52A8\u5230\u5176\u4ED6\u4F4D\u7F6E\u3002`,
+    parameters: {
+      type: "object",
+      properties: {
+        file_paths: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "\u8981\u5220\u9664\u7D22\u5F15\u7684\u6587\u4EF6\u8DEF\u5F84\u6570\u7EC4\uFF08\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+        }
+      },
+      required: ["file_paths"]
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (args, _context) => {
+      const filePaths = args.file_paths;
+      if (!Array.isArray(filePaths) || filePaths.length === 0) {
+        return JSON.stringify({
+          success: false,
+          error: "file_paths \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4"
+        });
+      }
+      try {
+        const result = await search.removeFiles(filePaths);
+        return JSON.stringify({
+          success: true,
+          message: `\u6279\u91CF\u5220\u9664\u5B8C\u6210`,
+          successCount: result.success,
+          failedCount: result.failed,
+          errors: result.errors
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createUpdateFilesTool(search) {
+  return {
+    name: "update_document_files",
+    description: `\u6279\u91CF\u66F4\u65B0\u591A\u4E2A\u6587\u4EF6\u7684\u7D22\u5F15\uFF08\u91CD\u65B0\u7D22\u5F15\uFF09\u3002
+\u7528\u4E8E\u6587\u4EF6\u5185\u5BB9\u5DF2\u4FEE\u6539\uFF0C\u9700\u8981\u66F4\u65B0\u7D22\u5F15\u7684\u573A\u666F\u3002
+\u4F1A\u5148\u5220\u9664\u65E7\u7D22\u5F15\uFF0C\u518D\u91CD\u65B0\u7D22\u5F15\u6587\u4EF6\u3002`,
+    parameters: {
+      type: "object",
+      properties: {
+        file_paths: {
+          type: "array",
+          items: {
+            type: "string"
+          },
+          description: "\u8981\u66F4\u65B0\u7D22\u5F15\u7684\u6587\u4EF6\u8DEF\u5F84\u6570\u7EC4\uFF08\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+        }
+      },
+      required: ["file_paths"]
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (args, _context) => {
+      const filePaths = args.file_paths;
+      if (!Array.isArray(filePaths) || filePaths.length === 0) {
+        return JSON.stringify({
+          success: false,
+          error: "file_paths \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4"
+        });
+      }
+      try {
+        const result = await search.updateFiles(filePaths);
+        return JSON.stringify({
+          success: true,
+          message: `\u6279\u91CF\u66F4\u65B0\u5B8C\u6210`,
+          successCount: result.success,
+          failedCount: result.failed,
+          errors: result.errors
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createWatchDirectoryTool(search) {
+  return {
+    name: "watch_document_directory",
+    description: `\u5F00\u59CB\u76D1\u542C\u76EE\u5F55\u53D8\u5316\uFF0C\u81EA\u52A8\u66F4\u65B0\u7D22\u5F15\u3002
+\u76D1\u542C\u540E\uFF0C\u76EE\u5F55\u5185\u7684\u6587\u4EF6\u65B0\u589E\u3001\u4FEE\u6539\u3001\u5220\u9664\u90FD\u4F1A\u81EA\u52A8\u66F4\u65B0\u7D22\u5F15\uFF0C\u65E0\u9700\u624B\u52A8\u64CD\u4F5C\u3002
+\u9002\u5408\u9700\u8981\u5B9E\u65F6\u4FDD\u6301\u7D22\u5F15\u540C\u6B65\u7684\u573A\u666F\u3002
+
+\u6CE8\u610F\uFF1A\u76D1\u542C\u4F1A\u6301\u7EED\u8FD0\u884C\uFF0C\u76F4\u5230\u8C03\u7528 unwatch_document_directory \u505C\u6B62\u3002`,
+    parameters: {
+      type: "object",
+      properties: {
+        directory: {
+          type: "string",
+          description: "\u8981\u76D1\u542C\u7684\u76EE\u5F55\u7EDD\u5BF9\u8DEF\u5F84"
+        },
+        ignore_initial: {
+          type: "boolean",
+          description: "\u662F\u5426\u5FFD\u7565\u521D\u59CB\u626B\u63CF\uFF08\u53EA\u76D1\u542C\u540E\u7EED\u53D8\u5316\uFF09\uFF0C\u9ED8\u8BA4 true"
+        },
+        debounce: {
+          type: "number",
+          description: "\u9632\u6296\u5EF6\u8FDF\uFF08\u6BEB\u79D2\uFF09\uFF0C\u907F\u514D\u9891\u7E41\u89E6\u53D1\uFF0C\u9ED8\u8BA4 1000"
+        }
+      },
+      required: ["directory"]
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (args, context) => {
+      let directory = args.directory;
+      if (directory.startsWith("~")) {
+        const os3 = await import("os");
+        directory = directory.replace("~", os3.homedir());
+      }
+      const pathModule = await import("path");
+      if (!pathModule.isAbsolute(directory)) {
+        directory = pathModule.resolve(context.cwd, directory);
+      }
+      const fs8 = await import("fs/promises");
+      try {
+        const stat6 = await fs8.stat(directory);
+        if (!stat6.isDirectory()) {
+          return JSON.stringify({
+            success: false,
+            error: "\u6307\u5B9A\u8DEF\u5F84\u4E0D\u662F\u4E00\u4E2A\u76EE\u5F55",
+            path: directory
+          });
+        }
+      } catch {
+        return JSON.stringify({
+          success: false,
+          error: "\u76EE\u5F55\u4E0D\u5B58\u5728",
+          path: directory
+        });
+      }
+      try {
+        search.watchDirectory(directory, {
+          ignoreInitial: args.ignore_initial !== false,
+          debounce: typeof args.debounce === "number" ? args.debounce : 1e3
+        });
+        return JSON.stringify({
+          success: true,
+          message: `\u5F00\u59CB\u76D1\u542C\u76EE\u5F55`,
+          directory
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          directory
+        });
+      }
+    }
+  };
+}
+function createUnwatchDirectoryTool(search) {
+  return {
+    name: "unwatch_document_directory",
+    description: `\u505C\u6B62\u76D1\u542C\u6307\u5B9A\u76EE\u5F55\u7684\u53D8\u5316\u3002
+\u505C\u6B62\u540E\uFF0C\u8BE5\u76EE\u5F55\u7684\u6587\u4EF6\u53D8\u5316\u5C06\u4E0D\u518D\u81EA\u52A8\u66F4\u65B0\u7D22\u5F15\u3002`,
+    parameters: {
+      type: "object",
+      properties: {
+        directory: {
+          type: "string",
+          description: "\u8981\u505C\u6B62\u76D1\u542C\u7684\u76EE\u5F55\u7EDD\u5BF9\u8DEF\u5F84"
+        }
+      },
+      required: ["directory"]
+    },
+    execute: async (args, context) => {
+      let directory = args.directory;
+      if (directory.startsWith("~")) {
+        const os3 = await import("os");
+        directory = directory.replace("~", os3.homedir());
+      }
+      const pathModule = await import("path");
+      if (!pathModule.isAbsolute(directory)) {
+        directory = pathModule.resolve(context.cwd, directory);
+      }
+      try {
+        search.unwatchDirectory(directory);
+        return JSON.stringify({
+          success: true,
+          message: `\u5DF2\u505C\u6B62\u76D1\u542C\u76EE\u5F55`,
+          directory
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          directory
+        });
+      }
+    }
+  };
+}
+function createGetWatchedDirectoriesTool(search) {
+  return {
+    name: "get_watched_directories",
+    description: `\u83B7\u53D6\u5F53\u524D\u6B63\u5728\u76D1\u542C\u7684\u76EE\u5F55\u5217\u8868\u3002
+\u7528\u4E8E\u67E5\u770B\u54EA\u4E9B\u76EE\u5F55\u6B63\u5728\u88AB\u81EA\u52A8\u76D1\u542C\u548C\u66F4\u65B0\u3002`,
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    execute: async (_args, _context) => {
+      const directories = search.getWatchedDirectories();
+      return JSON.stringify({
+        success: true,
+        directories,
+        count: directories.length
+      });
+    }
+  };
+}
+function createCleanupIndexTool(search) {
+  return {
+    name: "cleanup_document_index",
+    description: `\u6E05\u7406\u65E0\u6548\u7684\u7D22\u5F15\uFF08\u6587\u4EF6\u5DF2\u5220\u9664\u4F46\u7D22\u5F15\u8FD8\u5728\uFF09\u3002
+\u4F1A\u68C0\u67E5\u6240\u6709\u5DF2\u7D22\u5F15\u7684\u6587\u4EF6\u662F\u5426\u8FD8\u5B58\u5728\uFF1A
+- \u5982\u679C\u6587\u4EF6\u4E0D\u5B58\u5728\uFF0C\u5220\u9664\u7D22\u5F15
+- \u5982\u679C\u6587\u4EF6\u5DF2\u4FEE\u6539\uFF0C\u91CD\u65B0\u7D22\u5F15
+
+\u7528\u4E8E\u7EF4\u62A4\u7D22\u5F15\u7684\u4E00\u81F4\u6027\uFF0C\u5EFA\u8BAE\u5B9A\u671F\u6267\u884C\u3002`,
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (_args, _context) => {
+      try {
+        const result = await search.cleanup();
+        return JSON.stringify({
+          success: true,
+          message: `\u6E05\u7406\u5B8C\u6210`,
+          removedCount: result.removed,
+          updatedCount: result.updated
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createExportIndexTool(search) {
+  return {
+    name: "export_document_index",
+    description: `\u5BFC\u51FA\u6587\u6863\u7D22\u5F15\u6570\u636E\u5230\u6307\u5B9A\u8DEF\u5F84\u3002
+\u5BFC\u51FA\u5185\u5BB9\u5305\u62EC\uFF1A
+- \u5143\u6570\u636E\uFF08SQLite \u6570\u636E\u5E93\uFF09
+- \u5411\u91CF\u6570\u636E\uFF08LanceDB\uFF09
+- \u5168\u6587\u7D22\u5F15\uFF08FlexSearch\uFF09
+
+\u5BFC\u51FA\u7684\u6570\u636E\u53EF\u4EE5\u7528\u4E8E\u5907\u4EFD\u3001\u8FC1\u79FB\u6216\u6062\u590D\u7D22\u5F15\u3002`,
+    parameters: {
+      type: "object",
+      properties: {
+        output_path: {
+          type: "string",
+          description: "\u5BFC\u51FA\u8DEF\u5F84\uFF08\u76EE\u5F55\u8DEF\u5F84\uFF0C\u4F1A\u5728\u8BE5\u76EE\u5F55\u4E0B\u521B\u5EFA\u5BFC\u51FA\u6587\u4EF6\u5939\uFF09"
+        }
+      },
+      required: ["output_path"]
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (args, context) => {
+      let outputPath = args.output_path;
+      if (outputPath.startsWith("~")) {
+        const os3 = await import("os");
+        outputPath = outputPath.replace("~", os3.homedir());
+      }
+      const pathModule = await import("path");
+      if (!pathModule.isAbsolute(outputPath)) {
+        outputPath = pathModule.resolve(context.cwd, outputPath);
+      }
+      try {
+        const exportInfo = await search.exportIndex(outputPath);
+        return JSON.stringify({
+          success: true,
+          message: "\u7D22\u5F15\u5BFC\u51FA\u5B8C\u6210",
+          exportPath: exportInfo.exportPath,
+          timestamp: exportInfo.timestamp.toISOString(),
+          components: exportInfo.components,
+          stats: {
+            totalDocuments: exportInfo.stats.totalDocuments,
+            byType: exportInfo.stats.byType
+          }
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createImportIndexTool(search) {
+  return {
+    name: "import_document_index",
+    description: `\u4ECE\u6307\u5B9A\u8DEF\u5F84\u5BFC\u5165\u6587\u6863\u7D22\u5F15\u6570\u636E\u3002
+\u5BFC\u5165\u524D\u4F1A\u68C0\u67E5\u5BFC\u51FA\u4FE1\u606F\uFF0C\u786E\u4FDD\u6570\u636E\u5B8C\u6574\u6027\u3002
+\u5BFC\u5165\u540E\u4F1A\u66FF\u6362\u5F53\u524D\u7D22\u5F15\u6570\u636E\uFF0C\u8BF7\u8C28\u614E\u4F7F\u7528\u3002`,
+    parameters: {
+      type: "object",
+      properties: {
+        input_path: {
+          type: "string",
+          description: "\u5BFC\u5165\u8DEF\u5F84\uFF08\u5BFC\u51FA\u65F6\u521B\u5EFA\u7684\u76EE\u5F55\u8DEF\u5F84\uFF09"
+        }
+      },
+      required: ["input_path"]
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (args, context) => {
+      let inputPath = args.input_path;
+      if (inputPath.startsWith("~")) {
+        const os3 = await import("os");
+        inputPath = inputPath.replace("~", os3.homedir());
+      }
+      const pathModule = await import("path");
+      if (!pathModule.isAbsolute(inputPath)) {
+        inputPath = pathModule.resolve(context.cwd, inputPath);
+      }
+      try {
+        await search.importIndex(inputPath);
+        return JSON.stringify({
+          success: true,
+          message: "\u7D22\u5F15\u5BFC\u5165\u5B8C\u6210",
+          inputPath
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createListBackupsTool(search) {
+  return {
+    name: "list_document_index_backups",
+    description: `\u5217\u51FA\u6307\u5B9A\u76EE\u5F55\u4E0B\u7684\u6240\u6709\u7D22\u5F15\u5907\u4EFD\u3002
+\u7528\u4E8E\u67E5\u770B\u53EF\u7528\u7684\u5907\u4EFD\uFF0C\u4EE5\u4FBF\u9009\u62E9\u6062\u590D\u3002`,
+    parameters: {
+      type: "object",
+      properties: {
+        backup_dir: {
+          type: "string",
+          description: "\u5907\u4EFD\u76EE\u5F55\u8DEF\u5F84"
+        }
+      },
+      required: ["backup_dir"]
+    },
+    execute: async (args, context) => {
+      let backupDir = args.backup_dir;
+      if (backupDir.startsWith("~")) {
+        const os3 = await import("os");
+        backupDir = backupDir.replace("~", os3.homedir());
+      }
+      const pathModule = await import("path");
+      if (!pathModule.isAbsolute(backupDir)) {
+        backupDir = pathModule.resolve(context.cwd, backupDir);
+      }
+      try {
+        const backups = await search.listBackups(backupDir);
+        return JSON.stringify({
+          success: true,
+          backups: backups.map((b) => ({
+            path: b.path,
+            timestamp: b.timestamp.toISOString(),
+            size: b.size,
+            sizeFormatted: formatBytes(b.size)
+          })),
+          count: backups.length
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}
+function createOptimizeIndexTool(search) {
+  return {
+    name: "optimize_document_index",
+    description: `\u4F18\u5316\u6587\u6863\u7D22\u5F15\uFF0C\u5305\u62EC\uFF1A
+- \u6E05\u7406\u65E0\u6548\u7D22\u5F15\uFF08\u6587\u4EF6\u5DF2\u5220\u9664\uFF09
+- \u66F4\u65B0\u8FC7\u671F\u7D22\u5F15\uFF08\u6587\u4EF6\u5DF2\u4FEE\u6539\uFF09
+- \u538B\u7F29\u7D22\u5F15\u6570\u636E
+- \u788E\u7247\u6574\u7406
+
+\u5EFA\u8BAE\u5B9A\u671F\u6267\u884C\u4EE5\u4FDD\u6301\u7D22\u5F15\u6027\u80FD\u548C\u4E00\u81F4\u6027\u3002`,
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (_args, _context) => {
+      try {
+        await search.optimize();
+        return JSON.stringify({
+          success: true,
+          message: "\u7D22\u5F15\u4F18\u5316\u5B8C\u6210"
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createHealthCheckTool(search) {
+  return {
+    name: "check_document_index_health",
+    description: `\u68C0\u67E5\u6587\u6863\u7D22\u5F15\u7684\u5065\u5EB7\u72B6\u6001\u3002
+\u5305\u62EC\uFF1A
+- \u7D22\u5F15\u5B8C\u6574\u6027\u68C0\u67E5\uFF08\u5143\u6570\u636E\u3001\u5411\u91CF\u3001\u5168\u6587\u7D22\u5F15\uFF09
+- \u65E0\u6548\u7D22\u5F15\u7EDF\u8BA1\uFF08\u6587\u4EF6\u5DF2\u5220\u9664\uFF09
+- \u8FC7\u671F\u7D22\u5F15\u7EDF\u8BA1\uFF08\u6587\u4EF6\u5DF2\u4FEE\u6539\uFF09
+- \u9519\u8BEF\u7EDF\u8BA1
+
+\u7528\u4E8E\u8BCA\u65AD\u7D22\u5F15\u95EE\u9898\uFF0C\u51B3\u5B9A\u662F\u5426\u9700\u8981\u4F18\u5316\u6216\u4FEE\u590D\u3002`,
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    execute: async (_args, _context) => {
+      try {
+        const health = await search.healthCheck();
+        return JSON.stringify({
+          success: true,
+          healthy: health.healthy,
+          totalDocuments: health.totalDocuments,
+          invalidIndexes: health.invalidIndexes,
+          staleIndexes: health.staleIndexes,
+          errorCount: health.errorCount,
+          integrity: health.integrity,
+          message: health.healthy ? "\u7D22\u5F15\u5065\u5EB7" : "\u7D22\u5F15\u5B58\u5728\u95EE\u9898\uFF0C\u5EFA\u8BAE\u6267\u884C optimize_document_index \u6216 cleanup_document_index"
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createGetIndexErrorsTool(search) {
+  return {
+    name: "get_document_index_errors",
+    description: `\u83B7\u53D6\u7D22\u5F15\u8FC7\u7A0B\u4E2D\u53D1\u751F\u7684\u9519\u8BEF\u5217\u8868\u3002
+\u5305\u62EC\u6587\u4EF6\u8DEF\u5F84\u3001\u9519\u8BEF\u4FE1\u606F\u3001\u91CD\u8BD5\u6B21\u6570\u548C\u65F6\u95F4\u6233\u3002
+\u7528\u4E8E\u6392\u67E5\u7D22\u5F15\u95EE\u9898\uFF0C\u4E86\u89E3\u54EA\u4E9B\u6587\u4EF6\u7D22\u5F15\u5931\u8D25\u3002`,
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    execute: async (_args, _context) => {
+      try {
+        const errors = search.getIndexErrors();
+        return JSON.stringify({
+          success: true,
+          errors: errors.map((e) => ({
+            filePath: e.filePath,
+            error: e.error,
+            retryCount: e.retryCount,
+            timestamp: e.timestamp.toISOString()
+          })),
+          count: errors.length
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createRetryFailedIndexesTool(search) {
+  return {
+    name: "retry_failed_document_indexes",
+    description: `\u91CD\u8BD5\u4E4B\u524D\u7D22\u5F15\u5931\u8D25\u7684\u6587\u4EF6\u3002
+\u4F1A\u6E05\u9664\u9519\u8BEF\u8BB0\u5F55\uFF0C\u7136\u540E\u91CD\u65B0\u5C1D\u8BD5\u7D22\u5F15\u6240\u6709\u5931\u8D25\u7684\u6587\u4EF6\u3002
+\u7528\u4E8E\u4FEE\u590D\u7D22\u5F15\u9519\u8BEF\uFF0C\u6062\u590D\u5B8C\u6574\u7684\u7D22\u5F15\u8986\u76D6\u3002`,
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    sideEffects: [{ type: "filesystem", success: true }],
+    execute: async (_args, _context) => {
+      try {
+        const result = await search.retryFailedIndexes();
+        return JSON.stringify({
+          success: true,
+          message: "\u91CD\u8BD5\u5B8C\u6210",
+          successCount: result.success,
+          failedCount: result.failed,
+          errors: result.errors
+        });
+      } catch (error) {
+        return JSON.stringify({
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+}
+function createGetWorkspaceTool(workspaceState) {
+  return {
+    name: "get_search_workspace",
+    description: `\u83B7\u53D6\u5F53\u524D\u6587\u6863\u641C\u7D22\u7684\u5DE5\u4F5C\u7A7A\u95F4\u72B6\u6001\u3002
+\u8FD4\u56DE\u5F53\u524D\u5DE5\u4F5C\u7A7A\u95F4\u76EE\u5F55\u3001\u662F\u5426\u5DF2\u7D22\u5F15\u3001\u7D22\u5F15\u6587\u4EF6\u6570\u91CF\u7B49\u4FE1\u606F\u3002`,
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    execute: async (_args, _context) => {
+      if (!workspaceState.directory) {
+        return JSON.stringify({
+          hasWorkspace: false,
+          message: "\u5C1A\u672A\u8BBE\u7F6E\u5DE5\u4F5C\u7A7A\u95F4\uFF0C\u4F7F\u7528 set_search_workspace \u8BBE\u7F6E"
+        });
+      }
+      return JSON.stringify({
+        hasWorkspace: true,
+        directory: workspaceState.directory,
+        indexed: workspaceState.indexed,
+        filesIndexed: workspaceState.filesIndexed
+      });
+    }
+  };
+}
+
+export {
+  FileType,
+  DEFAULT_CONFIG,
+  VectorStore,
+  FullTextIndex,
+  MetaStore,
+  parseDocument,
+  isSupportedDocument,
+  getDocumentType,
+  DEFAULT_INSTRUCTIONS,
+  initEmbedder,
+  embed,
+  embedDocument,
+  embedQuery,
+  embedBatch,
+  embedBatchConcurrent,
+  embedImage,
+  embedVideo,
+  embedMultimodal,
+  getEmbeddingDimension,
+  setEmbeddingDimension,
+  disposeEmbedder,
+  isEmbedderInitialized,
+  DEFAULT_EXTENSION_RULES,
+  DEFAULT_DIRECTORY_RULES,
+  DEFAULT_FILE_RULES,
+  DEFAULT_PATH_RULES,
+  DEFAULT_SCAN_RULES,
+  ScanRulesManager,
+  createRulesManager,
+  scanDirectories,
+  getDefaultDirectories,
+  formatSize,
+  formatDate,
+  getFileType,
+  extractSnippet,
+  addGlobalProgressListener,
+  removeGlobalProgressListener,
+  splitText,
+  getChunkStats,
+  IndexingPipeline,
+  createIndexingPipeline,
+  DocumentSearch,
+  searchPlugin,
+  getSearchPlugin
+};
+//# sourceMappingURL=chunk-YJIIX54F.js.map