chatlab-cli 0.26.3 → 0.27.0

package/README.md

@@ -14,7 +14,7 @@ English | [简体中文](./README.zh-CN.md)
 
 ChatLab is an open-source desktop app for understanding your social conversations. It combines a flexible SQL engine with AI agents so you can explore patterns, ask better questions, and extract insights from chat data, all on your own machine.
 
-Currently supported: **WhatsApp, LINE, WeChat, QQ, Discord, Instagram, and Telegram**. Coming next: **iMessage, Messenger, and KakaoTalk**.
+Currently supported: **WhatsApp, LINE, QQ, Discord, Instagram, Telegram, and iMessage**. Coming next: **Messenger and KakaoTalk**.
 
 > New install? Start here: [Getting started](https://docs.chatlab.fun/usage/quick-start)
 
@@ -105,11 +105,17 @@ For complete contributor instructions, see the [Development Guide](https://docs.
 # Install dependencies
 pnpm install
 
-# Run desktop app in dev mode
+# Start dev mode — prompts you to choose which app to launch
 pnpm dev
+```
+
+Or launch a specific target directly:
 
-# Run CLI in dev mode (apps/cli)
-cd apps/cli && pnpm dev
+```bash
+pnpm dev:desktop   # Electron desktop app
+pnpm dev:web       # Web frontend + local server
+pnpm dev:serve     # CLI server only
+pnpm docs:dev      # Docs site
 ```
 
 If Electron encounters exceptions during startup, you can try using `electron-fix`:

package/dist/{chat-command-D37MMEJ7.mjs → chat-command-SKGPS3PG.mjs}

@@ -6,10 +6,10 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import {
   createCliRunAgentStream
-} from "./chunk-GNGZHBKM.mjs";
-import "./chunk-RMITK4IC.mjs";
-import "./chunk-YPTJVTVJ.mjs";
-import "./chunk-VSOWNKPA.mjs";
+} from "./chunk-7LPVQR77.mjs";
+import "./chunk-M6ABWESL.mjs";
+import "./chunk-KCFVHVO4.mjs";
+import "./chunk-GFHSSCCR.mjs";
 
 // src/ai/chat-command.ts
 import { createInterface } from "readline/promises";
@@ -301,4 +301,4 @@ export {
   runChatCommand,
   runChatTurn
 };
-//# sourceMappingURL=chat-command-D37MMEJ7.mjs.map
+//# sourceMappingURL=chat-command-SKGPS3PG.mjs.map

package/dist/{chunk-QMXNJRTT.mjs → chunk-3HOTLLFC.mjs}

@@ -4,34 +4,34 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 const require = __createRequire(import.meta.url);
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
+import {
+  closeServerAiLogger,
+  createCliRunAgentStream,
+  initServerAiLogger
+} from "./chunk-7LPVQR77.mjs";
 import {
   importData,
   parseFile
-} from "./chunk-D5MWER7N.mjs";
+} from "./chunk-UBJHT3BU.mjs";
 import {
   analyzeIncrementalImport,
   analyzeNewImport,
   incrementalImport,
   streamImport
-} from "./chunk-VCN64OD6.mjs";
+} from "./chunk-6FXGC6HE.mjs";
+import {
+  AGENT_TOOL_REGISTRY,
+  CoreDataProvider
+} from "./chunk-M6ABWESL.mjs";
 import {
   assertCliDataDirCompatible
-} from "./chunk-742TAKEP.mjs";
+} from "./chunk-FHLPXRDL.mjs";
 import {
   getVersion
 } from "./chunk-5ADKYYNA.mjs";
 import {
   resolveCliPath
 } from "./chunk-FJ35V3TE.mjs";
-import {
-  closeServerAiLogger,
-  createCliRunAgentStream,
-  initServerAiLogger
-} from "./chunk-GNGZHBKM.mjs";
-import {
-  AGENT_TOOL_REGISTRY,
-  CoreDataProvider
-} from "./chunk-RMITK4IC.mjs";
 import {
   AIChatManager,
   ALL_MIGRATIONS,
@@ -60,6 +60,7 @@ import {
   createDatabaseManagerAdapter,
   createJiebaNlpProvider,
   createNodeDataDirSwitch,
+  createSemanticIndexService,
   deleteDict,
   detectAllFormats,
   detectFormat,
@@ -135,7 +136,7 @@ import {
   verifyCliDataPath,
   writeAuthProfile,
   writeConfigField
-} from "./chunk-YPTJVTVJ.mjs";
+} from "./chunk-KCFVHVO4.mjs";
 
 // src/http/index.ts
 import * as fs11 from "fs";
@@ -1401,17 +1402,21 @@ function registerAiToolRoutes(server2, ctx) {
     if (!entry) {
       return reply.code(404).send({ success: false, error: `Tool not found: ${toolName}` });
     }
-    const db = ctx.dbManager.open(sessionId);
-    if (!db) {
-      return reply.code(404).send({ success: false, error: `Session not found: ${sessionId}` });
-    }
     const abortController = new AbortController();
     activeToolTests.set(testId, abortController);
     try {
+      if (ctx.executeAiTool) {
+        return await ctx.executeAiTool({ testId, toolName, params, sessionId, abortSignal: abortController.signal });
+      }
+      const db = ctx.dbManager.open(sessionId);
+      if (!db) {
+        return reply.code(404).send({ success: false, error: `Session not found: ${sessionId}` });
+      }
       const execCtx = {
         sessionId,
         db,
-        dataProvider: new CoreDataProvider(db)
+        dataProvider: new CoreDataProvider(db),
+        abortSignal: abortController.signal
       };
       const startTime = Date.now();
       const result = await entry.handler(params, execCtx);
@@ -1612,6 +1617,60 @@ function registerAiSummaryRoutes(server2, ctx) {
   });
 }
 
+// ../../packages/http-routes/src/routes/web/ai-semantic-index.ts
+function registerSemanticIndexRoutes(server2, ctx) {
+  const service = ctx.semanticIndexService;
+  if (!service) return;
+  server2.get("/_web/ai/semantic-index/config", async () => {
+    return { config: service.getConfig(), apiKeySet: service.hasApiKey(), configured: service.isConfigured() };
+  });
+  server2.put(
+    "/_web/ai/semantic-index/config",
+    async (request) => {
+      const config = service.setConfig(request.body.config, { apiKey: request.body.apiKey });
+      return { config, apiKeySet: service.hasApiKey(), configured: service.isConfigured() };
+    }
+  );
+  server2.get("/_web/ai/semantic-index/enabled", async () => {
+    return { sessions: service.listEnabledStatuses() };
+  });
+  server2.get("/_web/ai/semantic-index/status", async (request) => {
+    return { status: service.status(request.query.sessionId) };
+  });
+  server2.post("/_web/ai/semantic-index/status", async (request) => {
+    return { sessions: service.statusForSessions(request.body.sessionIds ?? []) };
+  });
+  const sessionAction = (path12, action) => {
+    server2.post(path12, async (request, reply) => {
+      const { sessionId } = request.body;
+      if (!sessionId) return reply.code(400).send({ error: "sessionId is required" });
+      await action(sessionId);
+      return { status: service.status(sessionId) };
+    });
+  };
+  sessionAction("/_web/ai/semantic-index/enable", (id) => service.enable(id));
+  sessionAction("/_web/ai/semantic-index/disable", (id) => service.disable(id));
+  sessionAction("/_web/ai/semantic-index/build", (id) => service.build(id));
+  sessionAction("/_web/ai/semantic-index/pause", (id) => service.pause(id));
+  sessionAction("/_web/ai/semantic-index/cancel", (id) => service.cancel(id));
+  sessionAction("/_web/ai/semantic-index/rebuild", (id) => service.rebuild(id));
+  server2.post("/_web/ai/semantic-index/build-pending", async () => {
+    service.buildAllPending();
+    return { sessions: service.listEnabledStatuses() };
+  });
+  server2.post("/_web/ai/semantic-index/cleanup", async () => {
+    return service.cleanupUnused();
+  });
+  server2.post(
+    "/_web/ai/semantic-index/search",
+    async (request, reply) => {
+      const { sessionId, query, finalTopK } = request.body;
+      if (!sessionId || !query) return reply.code(400).send({ error: "sessionId and query are required" });
+      return service.search(sessionId, query, { finalTopK });
+    }
+  );
+}
+
 // ../../packages/http-routes/src/routes/web/merge.ts
 import * as fs3 from "fs";
 import * as os from "os";
@@ -2068,6 +2127,7 @@ function registerSharedRoutes(server2, ctx, options) {
   registerAiToolRoutes(server2, resolvedCtx);
   registerAiChatRoutes(server2, resolvedCtx);
   registerAiSummaryRoutes(server2, resolvedCtx);
+  registerSemanticIndexRoutes(server2, resolvedCtx);
   registerMergeRoutes(server2, resolvedCtx);
   registerCacheRoutes(server2, resolvedCtx);
 }
@@ -2532,6 +2592,7 @@ function registerWebRoutes(server2, dbManager2, options) {
     getSystemDir: () => path8.join(os3.homedir(), ".chatlab"),
     getUserDataDir: () => path8.join(os3.homedir(), ".chatlab", "data"),
     getDatabaseDir: () => path8.join(os3.homedir(), ".chatlab", "data", "databases"),
+    getVectorDir: () => path8.join(os3.homedir(), ".chatlab", "data", "vector"),
     getAiDataDir: () => path8.join(os3.homedir(), ".chatlab", "ai"),
     getSettingsDir: () => path8.join(os3.homedir(), ".chatlab", "settings"),
     getCacheDir: () => path8.join(os3.homedir(), ".chatlab", "cache"),
@@ -2542,13 +2603,28 @@ function registerWebRoutes(server2, dbManager2, options) {
   const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
   const ai = options?.aiContext;
   const cliStreamImport = async (dm, filePath) => {
-    const { streamImport: streamImport2 } = await import("./stream-import-KZFC3XT2.mjs");
+    const { streamImport: streamImport2 } = await import("./stream-import-4VDJZHMY.mjs");
     const result = await streamImport2(dm, filePath);
     if (!result.sessionId) throw new Error("Import succeeded but no sessionId returned");
     return { sessionId: result.sessionId };
   };
   const defaultUserDataDir = getDefaultNodeUserDataDir();
   const isCustom = path8.resolve(resolvedPathProvider.getUserDataDir()) !== path8.resolve(defaultUserDataDir);
+  let semanticIndexService = options?.semanticIndexService;
+  if (!semanticIndexService) {
+    try {
+      semanticIndexService = createSemanticIndexService({
+        pathProvider: resolvedPathProvider,
+        sessionAdapter: adapter,
+        nativeBinding: options?.nativeBinding
+      });
+      semanticIndexService.recover();
+      server2.addHook("onClose", async () => semanticIndexService?.close());
+    } catch (err) {
+      console.warn("[semantic-index] service unavailable:", err instanceof Error ? err.message : String(err));
+      semanticIndexService = void 0;
+    }
+  }
   registerSharedRoutes(
     server2,
     {
@@ -2557,6 +2633,7 @@ function registerWebRoutes(server2, dbManager2, options) {
       pathProvider: resolvedPathProvider,
       getVersion,
       nativeBinding: options?.nativeBinding,
+      semanticIndexService,
       openDirectory: openDirectoryPath,
       showInFolder: showPathInFolder,
       downloadsDir: resolvedPathProvider.getDownloadsDir(),
@@ -3666,9 +3743,23 @@ async function startHttpServer(options) {
     limits: { fileSize: 1024 * 1024 * 1024 }
     // 1GB
   });
+  let semanticIndexService;
+  try {
+    semanticIndexService = createSemanticIndexService({
+      pathProvider,
+      sessionAdapter: createDatabaseManagerAdapter(dbManager),
+      nativeBinding
+    });
+    semanticIndexService.recover();
+    server.addHook("onClose", async () => semanticIndexService?.close());
+  } catch (err) {
+    console.warn("[semantic-index] service unavailable:", err instanceof Error ? err.message : String(err));
+    semanticIndexService = void 0;
+  }
   registerWebRoutes(server, dbManager, {
     pathProvider,
     nativeBinding,
+    semanticIndexService,
     aiContext: {
       aiDataDir,
       aiChatManager,
@@ -3677,7 +3768,7 @@ async function startHttpServer(options) {
       llmConfigStore,
       customProviderStore: new CustomProviderStore(createFileConfigStorage(aiDataDir)),
       customModelStore: new CustomModelStore(createFileConfigStorage(aiDataDir)),
-      runAgentStream: createCliRunAgentStream(dbManager, aiChatManager)
+      runAgentStream: createCliRunAgentStream(dbManager, aiChatManager, semanticIndexService)
     }
   });
   initSync(server, dbManager, pathProvider, { port, host, token });
@@ -3722,4 +3813,4 @@ export {
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-QMXNJRTT.mjs.map
+//# sourceMappingURL=chunk-3HOTLLFC.mjs.map