@huyooo/ai-search 0.2.1

package/README.md

@@ -0,0 +1,431 @@
+# @huyooo/ai-search
+
+本地文档语义搜索引擎，支持 Word、PDF、Excel、TXT、MD 等文档格式。
+
+## 特性
+
+- 🔍 **语义搜索**：基于向量的语义理解，不仅仅是关键词匹配
+- 📄 **多格式支持**：Word (.docx/.doc)、PDF、Excel (.xlsx/.xls)、PPT (.pptx/.ppt)、TXT、MD
+- 🏠 **本地优先**：所有数据存储在本地，保护隐私
+- ⚡ **高性能**：LanceDB 向量搜索 + FlexSearch 全文检索
+- 🤖 **AI 集成**：可作为 AI Agent 工具使用
+- 🔗 **兼容 file-explorer**：搜索结果兼容 FileItem 数据结构
+
+## 安装
+
+```bash
+npm install @huyooo/ai-search
+```
+
+## 快速开始
+
+### 环境变量
+
+使用前需要设置豆包 API Key：
+
+```bash
+export ARK_API_KEY=your_api_key_here
+```
+
+### 基础使用
+
+```typescript
+import { DocumentSearch } from '@huyooo/ai-search'
+
+// 创建搜索引擎
+const search = new DocumentSearch({
+  dataDir: './search-data',  // 索引数据存储目录
+  // arkApiKey: 'your_key',  // 也可以直接传入，默认从环境变量读取
+  // embeddingDimension: 1024,  // 向量维度（可选，默认 1024）
+})
+
+// 初始化
+await search.init()
+
+// 索引目录
+await search.indexDirectory('~/Documents')
+
+// 搜索
+const results = await search.search('去年的采购合同')
+
+console.log(results)
+// [
+//   {
+//     id: '/Users/xxx/Documents/采购合同.docx',
+//     name: '采购合同.docx',
+//     type: 'document',
+//     size: '1.2 MB',
+//     dateModified: '2024-03-15',
+//     score: 0.92,
+//     snippet: '...甲方与乙方就采购事宜...',
+//   },
+//   ...
+// ]
+```
+
+### 作为 AI Agent 工具（推荐）
+
+```typescript
+import { searchPlugin } from '@huyooo/ai-search'
+
+// Vite 插件风格 API
+const plugin = await searchPlugin({
+  dataDir: './search-data',
+  workspace: '~/Documents', // 可选：初始工作空间
+})
+
+// 注册工具到 Agent
+agent.registerTools(plugin.tools)
+
+// Agent 现在可以使用所有工具，包括：
+// - search_local_documents: 搜索文档
+// - index_document_file: 索引单个文件
+// - index_document_directory: 索引目录
+// - index_document_files: 批量索引文件
+// - watch_document_directory: 监听目录变化
+// - export_document_index: 导出索引
+// - optimize_document_index: 优化索引
+// ... 等 20+ 个工具
+```
+
+### 搜索选项
+
+```typescript
+const results = await search.search('合同', {
+  limit: 20,                    // 返回数量
+  mode: 'hybrid',               // semantic | keyword | hybrid
+  fileTypes: ['document', 'pdf'], // 文件类型过滤
+  dateRange: {                  // 时间范围
+    start: new Date('2024-01-01'),
+    end: new Date('2024-12-31'),
+  },
+  directories: ['/path/to/docs'], // 目录过滤
+  sizeRange: {                  // 文件大小过滤
+    min: 1024,                  // 最小 1KB
+    max: 10 * 1024 * 1024,      // 最大 10MB
+  },
+  fileNamePattern: '*.pdf',     // 文件名模式（通配符）
+  titleContains: '合同',         // 标题包含
+  combineMode: 'AND',           // 组合条件模式
+})
+```
+
+### 文件监听和自动更新
+
+```typescript
+// 监听目录变化，自动更新索引
+search.watchDirectory('/path/to/documents', {
+  ignoreInitial: true,  // 忽略初始扫描
+  debounce: 1000,       // 防抖延迟（毫秒）
+  onEvent: (event) => {
+    console.log('文件变化:', event.type, event.path)
+  },
+})
+
+// 停止监听
+search.unwatchDirectory('/path/to/documents')
+
+// 获取正在监听的目录
+const watched = search.getWatchedDirectories()
+```
+
+### 批量操作
+
+```typescript
+// 批量索引文件
+const result = await search.indexFiles([
+  '/path/to/file1.pdf',
+  '/path/to/file2.docx',
+], (progress) => {
+  console.log(`进度: ${progress.indexed}/${progress.total}`)
+})
+
+// 批量删除索引
+await search.removeFiles(['/path/to/file1.pdf', '/path/to/file2.docx'])
+
+// 批量更新索引（重新索引）
+await search.updateFiles(['/path/to/file1.pdf'])
+```
+
+### 索引导出和导入
+
+```typescript
+// 导出索引（备份）
+const exportInfo = await search.exportIndex('./backup/search-index')
+
+// 导入索引（恢复）
+await search.importIndex('./backup/search-index')
+
+// 列出备份
+const backups = await search.listBackups('./backup')
+```
+
+### 索引优化和维护
+
+```typescript
+// 清理无效索引（文件已删除但索引还在）
+const result = await search.cleanup()
+console.log(`清理了 ${result.removed} 个无效索引`)
+
+// 优化索引（压缩、碎片整理）
+await search.optimize()
+
+// 健康检查
+const health = await search.healthCheck()
+if (!health.healthy) {
+  console.log('索引存在问题，建议执行 optimize')
+}
+
+// 获取索引错误
+const errors = search.getIndexErrors()
+
+// 重试失败的索引
+await search.retryFailedIndexes()
+```
+
+## API
+
+### DocumentSearch
+
+```typescript
+class DocumentSearch {
+  constructor(config: SearchConfig)
+  
+  // ========== 初始化 ==========
+  init(): Promise<void>
+  
+  // ========== 索引 ==========
+  // 单文件索引
+  indexFile(filePath: string, retryCount?: number): Promise<void>
+  
+  // 目录索引
+  indexDirectory(
+    dir: string, 
+    onProgress?: (p: IndexProgress) => void
+  ): Promise<void>
+  
+  // 索引默认目录
+  indexDefaultDirectories(
+    onProgress?: (p: IndexProgress) => void
+  ): Promise<void>
+  
+  // 批量索引
+  indexFiles(
+    filePaths: string[],
+    onProgress?: (p: IndexProgress) => void
+  ): Promise<BatchOperationResult>
+  
+  // ========== 搜索 ==========
+  search(query: string, options?: SearchOptions): Promise<SearchResult[]>
+  
+  // ========== 文件监听 ==========
+  watchDirectory(directory: string, options?: WatchOptions): void
+  unwatchDirectory(directory: string): void
+  unwatchAll(): void
+  getWatchedDirectories(): string[]
+  
+  // ========== 批量操作 ==========
+  removeFiles(filePaths: string[]): Promise<BatchOperationResult>
+  updateFiles(
+    filePaths: string[],
+    onProgress?: (p: IndexProgress) => void
+  ): Promise<BatchOperationResult>
+  
+  // ========== 索引管理 ==========
+  removeFile(filePath: string): Promise<void>
+  getStats(): IndexStats
+  clear(): Promise<void>
+  save(): Promise<void>
+  
+  // ========== 索引优化 ==========
+  cleanup(): Promise<{ removed: number; updated: number }>
+  optimize(): Promise<void>
+  healthCheck(): Promise<HealthCheckResult>
+  
+  // ========== 错误处理 ==========
+  getIndexErrors(): IndexError[]
+  retryFailedIndexes(): Promise<BatchOperationResult>
+  
+  // ========== 导出/导入 ==========
+  exportIndex(outputPath: string): Promise<ExportInfo>
+  importIndex(inputPath: string): Promise<void>
+  listBackups(backupDir: string): Promise<BackupInfo[]>
+  
+  // ========== 资源清理 ==========
+  destroy(): Promise<void>
+}
+```
+
+### SearchResult（兼容 FileItem）
+
+```typescript
+interface SearchResult {
+  // 与 file-explorer FileItem 兼容
+  id: string           // 文件路径
+  name: string         // 文件名
+  type: FileType       // 文件类型
+  size?: string        // 格式化大小
+  dateModified?: string// 格式化日期
+  url?: string         // file:// URL
+  
+  // 搜索特有字段
+  score: number        // 相关度分数 (0-1)
+  snippet?: string     // 匹配摘要
+  matchType: 'semantic' | 'keyword' | 'hybrid'
+}
+```
+
+### SearchOptions
+
+```typescript
+interface SearchOptions {
+  limit?: number                    // 返回数量限制
+  mode?: 'semantic' | 'keyword' | 'hybrid'  // 搜索模式
+  fileTypes?: FileType[]            // 文件类型过滤
+  dateRange?: {                     // 时间范围过滤
+    start?: Date
+    end?: Date
+  }
+  directories?: string[]            // 目录过滤
+  sizeRange?: {                     // 文件大小过滤
+    min?: number                    // 字节
+    max?: number                    // 字节
+  }
+  fileNamePattern?: string          // 文件名模式（通配符 * ?）
+  titleContains?: string            // 文档标题包含
+  combineMode?: 'AND' | 'OR'        // 组合条件模式
+}
+```
+
+### SearchConfig
+
+```typescript
+interface SearchConfig {
+  dataDir: string                   // 索引数据存储目录
+  indexDirectories?: string[]        // 索引目录列表
+  excludeDirs?: string[]            // 排除目录
+  extensions?: string[]             // 支持的扩展名
+  maxFileSize?: number              // 最大文件大小（字节）
+  embeddingModel?: string           // Embedding 模型（默认 doubao-embedding-vision-250615）
+  arkApiKey?: string                // 豆包 API Key（也可通过环境变量 ARK_API_KEY 设置）
+  embeddingDimension?: number       // 向量维度（默认 1024）
+}
+```
+
+### AI Agent 工具列表
+
+使用 `searchPlugin` 后，Agent 可以使用以下工具：
+
+#### 搜索相关
+- `search_local_documents` - 搜索文档
+
+#### 索引相关
+- `index_document_file` - 索引单个文件
+- `index_document_directory` - 索引目录
+- `index_document_files` - 批量索引文件
+- `update_document_files` - 批量更新索引
+
+#### 工作空间管理
+- `set_search_workspace` - 设置工作空间
+- `get_search_workspace` - 获取工作空间状态
+
+#### 文件监听
+- `watch_document_directory` - 监听目录变化
+- `unwatch_document_directory` - 停止监听
+- `get_watched_directories` - 获取监听列表
+
+#### 索引管理
+- `get_document_index_stats` - 获取统计信息
+- `clear_document_index` - 清空索引
+- `remove_document_files` - 批量删除索引
+
+#### 索引优化
+- `cleanup_document_index` - 清理无效索引
+- `optimize_document_index` - 优化索引
+- `check_document_index_health` - 健康检查
+
+#### 错误处理
+- `get_document_index_errors` - 获取索引错误
+- `retry_failed_document_indexes` - 重试失败索引
+
+#### 导出/导入
+- `export_document_index` - 导出索引
+- `import_document_index` - 导入索引
+- `list_document_index_backups` - 列出备份
+```
+
+## 特性详解
+
+### 🔄 增量索引
+- 自动检测文件变化（路径 + 修改时间 + 文件大小）
+- 文件未变化时跳过索引，提升性能
+- 支持内容哈希去重，相同内容复用索引
+
+### 📁 文件监听
+- 自动监听目录变化
+- 新增/修改文件自动索引
+- 删除文件自动清理索引
+- 支持防抖，避免频繁触发
+
+### 🚀 批量操作
+- 批量索引、删除、更新
+- 支持进度回调
+- 错误处理和重试机制
+
+### 💾 索引管理
+- 导出/导入索引（备份和恢复）
+- 索引优化和维护
+- 健康检查和错误恢复
+
+## 技术栈
+
+| 组件 | 技术 |
+|-----|-----|
+| 向量存储 | LanceDB |
+| 全文搜索 | FlexSearch |
+| 元数据存储 | SQLite (better-sqlite3) |
+| 文本向量化 | 豆包 doubao-embedding-vision-250615（多模态） |
+| 中文分词 | nodejieba |
+| 文档解析 | mammoth, pdf-parse, xlsx |
+| 文件扫描 | fdir |
+| 文件监听 | chokidar |
+
+## 向量化模型
+
+使用字节跳动的 **doubao-embedding-vision-250615** 多模态向量化模型：
+
+- 支持文本、图片、视频向量化
+- 支持多模态混合输入
+- 默认 1024 维向量（可配置）
+- 需要豆包 API Key（ARK_API_KEY）
+
+### 高级向量化 API
+
+```typescript
+import { 
+  embed,           // 文本向量化
+  embedImage,      // 图片向量化
+  embedVideo,      // 视频向量化
+  embedMultimodal, // 多模态混合
+} from '@huyooo/ai-search'
+
+// 文本向量化
+const textVector = await embed('天很蓝，海很深')
+
+// 图片向量化
+const imageVector = await embedImage('https://example.com/image.jpg')
+
+// 视频向量化
+const videoVector = await embedVideo('https://example.com/video.mp4')
+
+// 多模态混合
+const mixedVector = await embedMultimodal([
+  { type: 'text', text: '这是什么？' },
+  { type: 'image_url', image_url: { url: 'https://example.com/image.jpg' } },
+])
+```
+
+## 许可证
+
+MIT
+

package/dist/bridge/electron.d.ts

@@ -0,0 +1,51 @@
+import { IpcMain } from 'electron';
+
+/**
+ * Electron 桥接模块
+ *
+ * 使用全局进度监听器自动广播索引进度
+ * 无需包装方法，无需轮询，解决时序问题
+ */
+
+/** Electron 桥接选项 */
+interface SearchElectronBridgeOptions {
+    /** IPC channel 前缀 */
+    channelPrefix?: string;
+    /** IPC Main 实例 */
+    ipcMain: IpcMain;
+}
+/** 索引进度广播系统 */
+declare class SearchElectronBridge {
+    private channelPrefix;
+    private ipcMain;
+    private indexingListeners;
+    private lastProgress;
+    private isIndexing;
+    constructor(options: SearchElectronBridgeOptions);
+    /** 初始化桥接（注册 IPC handlers 和全局进度监听器） */
+    init(): void;
+    /** 注册全局进度监听器 */
+    private registerGlobalProgressListener;
+    /** 注册 IPC handlers */
+    private registerIpcHandlers;
+    /** 广播索引进度到所有前端监听器 */
+    private broadcastIndexProgress;
+}
+/**
+ * 创建搜索 Electron 桥接
+ *
+ * @example
+ * ```typescript
+ * import { createSearchElectronBridge } from '@huyooo/ai-search/bridge/electron';
+ * import { ipcMain } from 'electron';
+ *
+ * const bridge = createSearchElectronBridge({
+ *   ipcMain,
+ *   channelPrefix: 'ai-chat',
+ * });
+ * bridge.init();
+ * ```
+ */
+declare function createSearchElectronBridge(options: SearchElectronBridgeOptions): SearchElectronBridge;
+
+export { SearchElectronBridge, type SearchElectronBridgeOptions, createSearchElectronBridge };

package/dist/bridge/electron.js

@@ -0,0 +1,10 @@
+import {
+  SearchElectronBridge,
+  createSearchElectronBridge
+} from "../chunk-GAT4F5NK.js";
+import "../chunk-YJIIX54F.js";
+export {
+  SearchElectronBridge,
+  createSearchElectronBridge
+};
+//# sourceMappingURL=electron.js.map

package/dist/bridge/electron.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-GAT4F5NK.js

@@ -0,0 +1,176 @@
+import {
+  addGlobalProgressListener,
+  getSearchPlugin
+} from "./chunk-YJIIX54F.js";
+
+// src/bridge/electron.ts
+var SearchElectronBridge = class {
+  channelPrefix;
+  ipcMain;
+  indexingListeners = /* @__PURE__ */ new Set();
+  lastProgress = null;
+  isIndexing = false;
+  constructor(options) {
+    this.channelPrefix = options.channelPrefix || "ai-chat";
+    this.ipcMain = options.ipcMain;
+  }
+  /** 初始化桥接（注册 IPC handlers 和全局进度监听器） */
+  init() {
+    this.registerIpcHandlers();
+    this.registerGlobalProgressListener();
+    console.log("[AI-Search] Electron \u6865\u63A5\u5DF2\u521D\u59CB\u5316");
+  }
+  /** 注册全局进度监听器 */
+  registerGlobalProgressListener() {
+    addGlobalProgressListener((progress) => {
+      this.isIndexing = progress.stage !== "done";
+      this.lastProgress = progress;
+      this.broadcastIndexProgress(progress);
+    });
+  }
+  /** 注册 IPC handlers */
+  registerIpcHandlers() {
+    this.ipcMain.handle(`${this.channelPrefix}:index:registerListener`, (event) => {
+      const webContents = event.sender;
+      this.indexingListeners.add(webContents);
+      if (this.lastProgress && this.isIndexing) {
+        if (!webContents.isDestroyed()) {
+          webContents.send(`${this.channelPrefix}:index:progress`, {
+            indexed: this.lastProgress.indexed,
+            total: this.lastProgress.total,
+            currentFile: this.lastProgress.currentFile,
+            stage: this.lastProgress.stage
+          });
+        }
+      }
+      return { success: true };
+    });
+    this.ipcMain.handle(`${this.channelPrefix}:index:unregisterListener`, (event) => {
+      this.indexingListeners.delete(event.sender);
+      return { success: true };
+    });
+    this.ipcMain.handle(`${this.channelPrefix}:index:getStats`, async () => {
+      try {
+        const searchPlugin = getSearchPlugin();
+        if (!searchPlugin) {
+          return {
+            totalDocuments: 0,
+            indexSize: 0,
+            lastUpdated: null
+          };
+        }
+        const stats = searchPlugin.search.getStats();
+        return {
+          totalDocuments: stats.totalDocuments,
+          indexSize: stats.indexSize,
+          lastUpdated: stats.lastUpdated ? stats.lastUpdated.toISOString() : null
+        };
+      } catch (error) {
+        console.error("[AI-Search] \u83B7\u53D6\u7D22\u5F15\u7EDF\u8BA1\u5931\u8D25:", error);
+        return {
+          totalDocuments: 0,
+          indexSize: 0,
+          lastUpdated: null
+        };
+      }
+    });
+    this.ipcMain.handle(`${this.channelPrefix}:index:sync`, async () => {
+      try {
+        const searchPlugin = getSearchPlugin();
+        if (!searchPlugin) {
+          throw new Error("\u641C\u7D22\u63D2\u4EF6\u672A\u521D\u59CB\u5316");
+        }
+        const workspaceState = searchPlugin.getWorkspaceState();
+        if (!workspaceState.directory) {
+          throw new Error("\u5DE5\u4F5C\u7A7A\u95F4\u672A\u8BBE\u7F6E");
+        }
+        await searchPlugin.search.indexDirectory(workspaceState.directory);
+        return { success: true };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error("[AI-Search] \u540C\u6B65\u7D22\u5F15\u5931\u8D25:", errorMessage);
+        this.broadcastIndexProgress({
+          indexed: 0,
+          total: 0,
+          stage: "error",
+          error: errorMessage
+        });
+        throw error;
+      }
+    });
+    this.ipcMain.handle(`${this.channelPrefix}:index:status`, async () => {
+      return {
+        isIndexing: this.isIndexing,
+        lastProgress: this.lastProgress
+      };
+    });
+    this.ipcMain.handle(`${this.channelPrefix}:index:cancel`, async () => {
+      try {
+        const searchPlugin = getSearchPlugin();
+        if (!searchPlugin) {
+          return { success: false, message: "\u641C\u7D22\u63D2\u4EF6\u672A\u521D\u59CB\u5316" };
+        }
+        const cancelled = searchPlugin.search.cancelIndexing();
+        if (cancelled) {
+          this.broadcastIndexProgress({
+            indexed: this.lastProgress?.indexed || 0,
+            total: this.lastProgress?.total || 0,
+            stage: "cancelled"
+          });
+          this.isIndexing = false;
+          return { success: true };
+        } else {
+          return { success: false, message: "\u6CA1\u6709\u6B63\u5728\u8FD0\u884C\u7684\u7D22\u5F15\u4EFB\u52A1" };
+        }
+      } catch (error) {
+        console.error("[AI-Search] \u53D6\u6D88\u7D22\u5F15\u5931\u8D25:", error);
+        return { success: false, message: String(error) };
+      }
+    });
+    this.ipcMain.handle(`${this.channelPrefix}:index:delete`, async () => {
+      try {
+        const searchPlugin = getSearchPlugin();
+        if (!searchPlugin) {
+          throw new Error("\u641C\u7D22\u63D2\u4EF6\u672A\u521D\u59CB\u5316");
+        }
+        await searchPlugin.search.clear();
+        this.isIndexing = false;
+        this.lastProgress = null;
+        this.broadcastIndexProgress({
+          indexed: 0,
+          total: 0,
+          stage: "done"
+        });
+        return { success: true };
+      } catch (error) {
+        console.error("[AI-Search] \u5220\u9664\u7D22\u5F15\u5931\u8D25:", error);
+        throw error;
+      }
+    });
+  }
+  /** 广播索引进度到所有前端监听器 */
+  broadcastIndexProgress(progress) {
+    this.lastProgress = progress;
+    this.indexingListeners.forEach((webContents) => {
+      if (!webContents.isDestroyed()) {
+        webContents.send(`${this.channelPrefix}:index:progress`, {
+          indexed: progress.indexed,
+          total: progress.total,
+          currentFile: progress.currentFile,
+          stage: progress.stage
+        });
+      } else {
+        this.indexingListeners.delete(webContents);
+      }
+    });
+  }
+};
+function createSearchElectronBridge(options) {
+  return new SearchElectronBridge(options);
+}
+
+export {
+  SearchElectronBridge,
+  createSearchElectronBridge
+};
+//# sourceMappingURL=chunk-GAT4F5NK.js.map

package/dist/chunk-GAT4F5NK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bridge/electron.ts"],"sourcesContent":["/**\n * Electron 桥接模块\n * \n * 使用全局进度监听器自动广播索引进度\n * 无需包装方法，无需轮询，解决时序问题\n */\n\nimport type { IpcMain, WebContents } from 'electron';\nimport { getSearchPlugin } from '../tools';\nimport { addGlobalProgressListener } from '../core/progress';\nimport type { IndexProgress } from '../types';\n\n// 扩展的索引进度类型，支持取消和错误状态\ntype ExtendedIndexProgress = IndexProgress | {\n  indexed: number;\n  total: number;\n  currentFile?: string;\n  stage: 'cancelled' | 'error';\n  error?: string;\n};\n\n/** Electron 桥接选项 */\nexport interface SearchElectronBridgeOptions {\n  /** IPC channel 前缀 */\n  channelPrefix?: string;\n  /** IPC Main 实例 */\n  ipcMain: IpcMain;\n}\n\n/** 索引进度广播系统 */\nexport class SearchElectronBridge {\n  private channelPrefix: string;\n  private ipcMain: IpcMain;\n  private indexingListeners = new Set<WebContents>();\n  private lastProgress: ExtendedIndexProgress | null = null;\n  private isIndexing = false;\n\n  constructor(options: SearchElectronBridgeOptions) {\n    this.channelPrefix = options.channelPrefix || 'ai-chat';\n    this.ipcMain = options.ipcMain;\n  }\n\n  /** 初始化桥接（注册 IPC handlers 和全局进度监听器） */\n  init(): void {\n    this.registerIpcHandlers();\n    this.registerGlobalProgressListener();\n    console.log('[AI-Search] Electron 桥接已初始化');\n  }\n\n  /** 注册全局进度监听器 */\n  private registerGlobalProgressListener(): void {\n    // 注册全局进度监听器，所有 indexDirectory 调用都会触发\n    addGlobalProgressListener((progress: IndexProgress) => {\n      // 更新状态\n      this.isIndexing = progress.stage !== 'done';\n      this.lastProgress = progress;\n      \n      // 广播进度到所有前端监听器\n      this.broadcastIndexProgress(progress);\n    });\n  }\n\n  /** 注册 IPC handlers */\n  private registerIpcHandlers(): void {\n    // 注册索引进度监听器（前端调用）\n    this.ipcMain.handle(`${this.channelPrefix}:index:registerListener`, (event) => {\n      const webContents = event.sender;\n      this.indexingListeners.add(webContents);\n      \n      // 如果正在索引，立即发送最后进度\n      if (this.lastProgress && this.isIndexing) {\n        if (!webContents.isDestroyed()) {\n          webContents.send(`${this.channelPrefix}:index:progress`, {\n            indexed: this.lastProgress.indexed,\n            total: this.lastProgress.total,\n            currentFile: this.lastProgress.currentFile,\n            stage: this.lastProgress.stage,\n          });\n        }\n      }\n      \n      return { success: true };\n    });\n\n    // 注销索引进度监听器（前端调用）\n    this.ipcMain.handle(`${this.channelPrefix}:index:unregisterListener`, (event) => {\n      this.indexingListeners.delete(event.sender);\n      return { success: true };\n    });\n\n    // 获取索引统计信息\n    this.ipcMain.handle(`${this.channelPrefix}:index:getStats`, async () => {\n      try {\n        const searchPlugin = getSearchPlugin();\n        \n        if (!searchPlugin) {\n          return {\n            totalDocuments: 0,\n            indexSize: 0,\n            lastUpdated: null,\n          };\n        }\n        \n        const stats = searchPlugin.search.getStats();\n        return {\n          totalDocuments: stats.totalDocuments,\n          indexSize: stats.indexSize,\n          lastUpdated: stats.lastUpdated ? stats.lastUpdated.toISOString() : null,\n        };\n      } catch (error) {\n        console.error('[AI-Search] 获取索引统计失败:', error);\n        return {\n          totalDocuments: 0,\n          indexSize: 0,\n          lastUpdated: null,\n        };\n      }\n    });\n\n    // 同步索引（重新索引工作空间）\n    this.ipcMain.handle(`${this.channelPrefix}:index:sync`, async () => {\n      try {\n        const searchPlugin = getSearchPlugin();\n        \n        if (!searchPlugin) {\n          throw new Error('搜索插件未初始化');\n        }\n\n        const workspaceState = searchPlugin.getWorkspaceState();\n        if (!workspaceState.directory) {\n          throw new Error('工作空间未设置');\n        }\n\n        // 开始索引（进度会通过全局监听器自动广播）\n        await searchPlugin.search.indexDirectory(workspaceState.directory!);\n        \n        return { success: true };\n      } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : String(error);\n        console.error('[AI-Search] 同步索引失败:', errorMessage);\n        \n        // 广播错误状态\n        this.broadcastIndexProgress({\n          indexed: 0,\n          total: 0,\n          stage: 'error',\n          error: errorMessage,\n        });\n        \n        throw error;\n      }\n    });\n\n    // 检查索引状态\n    this.ipcMain.handle(`${this.channelPrefix}:index:status`, async () => {\n      return {\n        isIndexing: this.isIndexing,\n        lastProgress: this.lastProgress,\n      };\n    });\n\n    // 取消索引\n    this.ipcMain.handle(`${this.channelPrefix}:index:cancel`, async () => {\n      try {\n        const searchPlugin = getSearchPlugin();\n        \n        if (!searchPlugin) {\n          return { success: false, message: '搜索插件未初始化' };\n        }\n\n        const cancelled = searchPlugin.search.cancelIndexing();\n        \n        if (cancelled) {\n          // 广播取消状态\n          this.broadcastIndexProgress({\n            indexed: this.lastProgress?.indexed || 0,\n            total: this.lastProgress?.total || 0,\n            stage: 'cancelled',\n          });\n          this.isIndexing = false;\n          return { success: true };\n        } else {\n          return { success: false, message: '没有正在运行的索引任务' };\n        }\n      } catch (error) {\n        console.error('[AI-Search] 取消索引失败:', error);\n        return { success: false, message: String(error) };\n      }\n    });\n\n    // 删除索引\n    this.ipcMain.handle(`${this.channelPrefix}:index:delete`, async () => {\n      try {\n        const searchPlugin = getSearchPlugin();\n        \n        if (!searchPlugin) {\n          throw new Error('搜索插件未初始化');\n        }\n\n        await searchPlugin.search.clear();\n        \n        // 重置状态\n        this.isIndexing = false;\n        this.lastProgress = null;\n        \n        // 广播清空状态（使用 done 阶段，indexed=0 表示已清空）\n        this.broadcastIndexProgress({\n          indexed: 0,\n          total: 0,\n          stage: 'done',\n        });\n        \n        return { success: true };\n      } catch (error) {\n        console.error('[AI-Search] 删除索引失败:', error);\n        throw error;\n      }\n    });\n  }\n\n  /** 广播索引进度到所有前端监听器 */\n  private broadcastIndexProgress(progress: ExtendedIndexProgress): void {\n    // 更新最后进度\n    this.lastProgress = progress;\n    \n    // 向所有监听器广播\n    this.indexingListeners.forEach((webContents) => {\n      if (!webContents.isDestroyed()) {\n        webContents.send(`${this.channelPrefix}:index:progress`, {\n          indexed: progress.indexed,\n          total: progress.total,\n          currentFile: progress.currentFile,\n          stage: progress.stage,\n        });\n      } else {\n        // 清理已销毁的 webContents\n        this.indexingListeners.delete(webContents);\n      }\n    });\n  }\n}\n\n/**\n * 创建搜索 Electron 桥接\n * \n * @example\n * ```typescript\n * import { createSearchElectronBridge } from '@huyooo/ai-search/bridge/electron';\n * import { ipcMain } from 'electron';\n * \n * const bridge = createSearchElectronBridge({\n *   ipcMain,\n *   channelPrefix: 'ai-chat',\n * });\n * bridge.init();\n * ```\n */\nexport function createSearchElectronBridge(\n  options: SearchElectronBridgeOptions\n): SearchElectronBridge {\n  return new SearchElectronBridge(options);\n}\n"],"mappings":"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","names":[]}