@c3-oss/prosa 0.2.0 → 0.3.0

package/dist/bin/prosa.js

@@ -1120,8 +1120,6 @@ var PROSA_PARSER_VERSION = "0.1.0";
 var PROSA_SCHEMA_VERSION = 2;
 
 // src/cli/commands/compile.ts
-import os2 from "os";
-import path14 from "path";
 import { Command } from "commander";
 
 // src/core/bundle.ts
@@ -1627,6 +1625,10 @@ function closeBundle(bundle) {
   closeDb(bundle.db);
 }
 
+// src/services/compile.ts
+import os2 from "os";
+import path14 from "path";
+
 // src/importers/claude/index.ts
 init_cas();
 init_db();
@@ -5628,35 +5630,9 @@ function isMissingParquetError(error) {
   return /No files found|does not exist|not found/i.test(message) && /\.parquet/i.test(message);
 }
 
-// src/cli/commands/compile.ts
+// src/services/compile.ts
 init_indexing();
-
-// src/cli/logger.ts
-import pino from "pino";
-import pretty from "pino-pretty";
-function createCliLogger(options) {
-  const loggerOptions = {
-    base: void 0,
-    level: options.verbose === true ? "debug" : "info"
-  };
-  if (options.jsonLogs === true) {
-    return pino(loggerOptions, pino.destination({ dest: 2, sync: true }));
-  }
-  return pino(
-    loggerOptions,
-    pretty({
-      colorize: process.stderr.isTTY,
-      destination: 2,
-      ignore: "pid,hostname",
-      singleLine: true,
-      sync: true,
-      translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l"
-    })
-  );
-}
-
-// src/cli/commands/compile.ts
-var PROVIDERS = [
+var COMPILE_PROVIDERS = [
   {
     name: "codex",
     description: "Import Codex CLI session histories into the bundle.",
@@ -5686,13 +5662,129 @@ var PROVIDERS = [
     compile: compileCursor
   }
 ];
+function getCompileProvider(source) {
+  const provider = COMPILE_PROVIDERS.find((p) => p.name === source);
+  if (!provider) {
+    throw new Error(`unknown compile source: ${source}`);
+  }
+  return provider;
+}
+function resolveCompilePath(p) {
+  if (p === "~") return os2.homedir();
+  if (p.startsWith("~/")) return path14.join(os2.homedir(), p.slice(2));
+  return path14.resolve(p);
+}
+async function runCompileImports(options) {
+  const { bundle, providers, deferIndex, logger } = options;
+  let importedAny = false;
+  const summaries = [];
+  let tantivy = null;
+  let tantivyError = null;
+  try {
+    if (deferIndex) {
+      logger?.info("disabling FTS5 triggers for deferred indexing");
+      disableFts5Triggers(bundle);
+    }
+    for (const provider of providers) {
+      const sourcePath = resolveCompilePath(options.sessionsPath ?? provider.defaultSessionsPath());
+      const providerLogger = logger?.child({
+        source_tool: provider.name,
+        source_path: sourcePath
+      });
+      providerLogger?.info("starting compile");
+      const r = await provider.compile(bundle, sourcePath, { logger: providerLogger });
+      importedAny ||= r.counts.source_files_imported > 0;
+      providerLogger?.info(
+        {
+          batch_id: r.batch.batch_id,
+          counts: r.counts
+        },
+        "compile finished"
+      );
+      const summary = {
+        source: provider.name,
+        sourcePath,
+        batchId: r.batch.batch_id,
+        batch: r.batch,
+        counts: r.counts
+      };
+      summaries.push(summary);
+      options.onProviderComplete?.(summary);
+    }
+    logger?.info({ changed: importedAny, fts5_deferred: deferIndex }, "marking indexes");
+    markIndexesAfterImport(bundle, {
+      changed: importedAny,
+      fts5Deferred: deferIndex
+    });
+    if (importedAny) {
+      try {
+        logger?.info("rebuilding tantivy index");
+        const status = await rebuildTantivyIndex(bundle);
+        tantivy = { indexedDocCount: status.indexed_doc_count };
+        options.onTantivyComplete?.(tantivy);
+      } catch (error) {
+        tantivyError = error instanceof Error ? error.message : String(error);
+        logger?.error({ err: error }, "tantivy rebuild failed; SQLite data is intact");
+      }
+    }
+  } finally {
+    if (deferIndex) {
+      logger?.info("re-enabling FTS5 triggers");
+      enableFts5Triggers(bundle);
+    }
+  }
+  return {
+    providers: summaries,
+    importedAny,
+    tantivy,
+    tantivyError
+  };
+}
+async function exportCompileParquet(options) {
+  const storePath = resolveCompilePath(options.storePath);
+  options.logger?.info({ store_path: storePath }, "exporting parquet");
+  const result = await exportBundleParquet({ bundlePath: storePath });
+  return {
+    outDir: result.outDir,
+    manifestPath: result.manifestPath,
+    tableCount: Object.keys(result.files).length,
+    files: result.files,
+    counts: result.counts
+  };
+}
+
+// src/cli/logger.ts
+import pino from "pino";
+import pretty from "pino-pretty";
+function createCliLogger(options) {
+  const loggerOptions = {
+    base: void 0,
+    level: options.verbose === true ? "debug" : "info"
+  };
+  if (options.jsonLogs === true) {
+    return pino(loggerOptions, pino.destination({ dest: 2, sync: true }));
+  }
+  return pino(
+    loggerOptions,
+    pretty({
+      colorize: process.stderr.isTTY,
+      destination: 2,
+      ignore: "pid,hostname",
+      singleLine: true,
+      sync: true,
+      translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l"
+    })
+  );
+}
+
+// src/cli/commands/compile.ts
 function compileCommand() {
   const command = addCompileLogOptions(
     new Command("compile").description(
       "Import session histories from one agent CLI into the bundle."
     )
   );
-  for (const provider of PROVIDERS) {
+  for (const provider of COMPILE_PROVIDERS) {
     command.addCommand(providerCompileCommand(provider));
   }
   command.action(() => {
@@ -5703,7 +5795,7 @@ function compileCommand() {
 function compileAllCommand() {
   return addCompileLogOptions(new Command("compile-all")).description("Import all agent CLI session histories using default source paths.").option("--defer-index", "skip immediate FTS5 updates; run `prosa index fts5` later").action(async (options) => {
     await runCompiles({
-      providers: PROVIDERS,
+      providers: COMPILE_PROVIDERS,
       storePath: defaultBundlePath(),
       deferIndex: options.deferIndex === true,
       logOptions: options
@@ -5732,76 +5824,42 @@ function addCompileLogOptions(command) {
 }
 async function runCompiles(options) {
   const logger = createCliLogger(options.logOptions);
-  const storePath = resolvePath(options.storePath);
+  const storePath = resolveCompilePath(options.storePath);
   logger.info({ store_path: storePath }, "opening bundle");
   const bundle = await openBundle(storePath);
   let importedAny = false;
   try {
-    if (options.deferIndex) {
-      logger.info("disabling FTS5 triggers for deferred indexing");
-      disableFts5Triggers(bundle);
-    }
-    for (const provider of options.providers) {
-      const sourcePath = resolvePath(options.sessionsPath ?? provider.defaultSessionsPath());
-      const providerLogger = logger.child({
-        source_tool: provider.name,
-        source_path: sourcePath
-      });
-      providerLogger.info("starting compile");
-      const r = await provider.compile(bundle, sourcePath, { logger: providerLogger });
-      importedAny ||= r.counts.source_files_imported > 0;
-      providerLogger.info(
-        {
-          batch_id: r.batch.batch_id,
-          counts: r.counts
-        },
-        "compile finished"
-      );
-      printCounts(provider.name, r.batch.batch_id, r.counts);
-    }
-    logger.info({ changed: importedAny, fts5_deferred: options.deferIndex }, "marking indexes");
-    markIndexesAfterImport(bundle, {
-      changed: importedAny,
-      fts5Deferred: options.deferIndex
-    });
-    if (importedAny) {
-      try {
-        logger.info("rebuilding tantivy index");
-        const status = await rebuildTantivyIndex(bundle);
-        process.stdout.write(`tantivy: indexed ${status.indexed_doc_count} docs
+    const result = await runCompileImports({
+      bundle,
+      providers: options.providers,
+      deferIndex: options.deferIndex,
+      sessionsPath: options.sessionsPath,
+      logger,
+      onProviderComplete: printCounts,
+      onTantivyComplete: (status) => {
+        process.stdout.write(`tantivy: indexed ${status.indexedDocCount} docs
 `);
-      } catch (error) {
-        logger.error({ err: error }, "tantivy rebuild failed; SQLite data is intact");
       }
-    }
+    });
+    importedAny = result.importedAny;
   } finally {
-    if (options.deferIndex) {
-      logger.info("re-enabling FTS5 triggers");
-      enableFts5Triggers(bundle);
-    }
     closeBundle(bundle);
     logger.info({ store_path: storePath }, "bundle closed");
   }
   if (importedAny) {
     try {
-      logger.info({ store_path: storePath }, "exporting parquet");
-      const result = await exportBundleParquet({ bundlePath: storePath });
-      const tableCount = Object.keys(result.files).length;
-      process.stdout.write(`parquet: wrote ${tableCount} tables to ${result.outDir}
+      const result = await exportCompileParquet({ storePath, logger });
+      process.stdout.write(`parquet: wrote ${result.tableCount} tables to ${result.outDir}
 `);
     } catch (error) {
       logger.error({ err: error }, "parquet export failed; SQLite data is intact");
     }
   }
 }
-function resolvePath(p) {
-  if (p === "~") return os2.homedir();
-  if (p.startsWith("~/")) return path14.join(os2.homedir(), p.slice(2));
-  return path14.resolve(p);
-}
-function printCounts(label, batchId, c) {
+function printCounts(summary) {
+  const c = summary.counts;
   process.stdout.write(
-    `${label} import: batch=${batchId}
+    `${summary.source} import: batch=${summary.batchId}
   source_files seen=${c.source_files_seen} imported=${c.source_files_imported} skipped=${c.source_files_skipped}
   sessions=${c.sessions} turns=${c.turns} messages=${c.messages} blocks=${c.content_blocks}
   events=${c.events} tool_calls=${c.tool_calls} tool_results=${c.tool_results}
@@ -6128,10 +6186,13 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 
 // src/mcp/guidance.ts
 var PROSA_MCP_INSTRUCTIONS = `
-prosa is a read-only memory over local agent session histories. Use it to find prior work,
-commands, decisions, file touches, and full transcripts before answering from memory.
+prosa is a local memory over local agent session histories. Use it to import recent sessions,
+find prior work, commands, decisions, file touches, and full transcripts before answering from
+memory.
 
 Recommended workflow:
+- Use compile to refresh the bundle when recent local sessions may not be indexed yet. With no
+  input it imports all supported providers from default paths.
 - For open-ended questions, start with search_sessions using 2-5 concrete terms.
 - For questions about a file or path, start with find_touched_files, then inspect the returned sessions.
 - After search results, call get_session for the most relevant session_ids before drawing conclusions.
@@ -6181,7 +6242,76 @@ init_search();
 init_sessions();
 function registerProsaTools(server, bundle, options = {}) {
   const searchEngine = options.searchEngine ?? "fts5";
+  const storePath = options.storePath ?? bundle.path;
   registerProsaPrompts(server);
+  server.registerTool(
+    "compile",
+    {
+      title: "Compile sessions",
+      description: "Import local agent session histories into the active prosa bundle. With no input, compiles all providers from default paths. With source, compiles that provider; sessions_path may override that provider path.",
+      inputSchema: {
+        source: z.enum(["cursor", "codex", "claude", "gemini"]).optional(),
+        sessions_path: z.string().min(1).optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+    },
+    async ({ source, sessions_path }) => {
+      if (sessions_path && !source) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "sessions_path requires source because providers use incompatible source layouts"
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const result = await runCompileImports({
+          bundle,
+          providers: source ? [getCompileProvider(source)] : COMPILE_PROVIDERS,
+          deferIndex: false,
+          sessionsPath: sessions_path
+        });
+        const parquet = result.importedAny ? await exportCompileParquet({ storePath }) : null;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  providers: result.providers.map((provider) => ({
+                    source: provider.source,
+                    source_path: provider.sourcePath,
+                    batch_id: provider.batchId,
+                    counts: provider.counts
+                  })),
+                  imported_any: result.importedAny,
+                  tantivy: result.tantivy ? { indexed_doc_count: result.tantivy.indexedDocCount } : null,
+                  tantivy_error: result.tantivyError,
+                  parquet: parquet ? {
+                    out_dir: parquet.outDir,
+                    manifest_path: parquet.manifestPath,
+                    table_count: parquet.tableCount,
+                    files: parquet.files,
+                    counts: parquet.counts
+                  } : null
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+          isError: true
+        };
+      }
+    }
+  );
   server.registerTool(
     "list_sessions",
     {
@@ -6494,7 +6624,7 @@ function registerProsaPrompts(server) {
 
 // src/mcp/server.ts
 async function listenMcpStdioServer(bundle, options = {}) {
-  const server = createMcpServer(bundle, options.searchEngine ?? "fts5");
+  const server = createMcpServer(bundle, options.searchEngine ?? "fts5", options.storePath);
   const transport = new StdioServerTransport();
   await server.connect(transport);
   return {
@@ -6508,10 +6638,13 @@ async function listenMcpServer(bundle, options) {
   const mcpPath = options.path ?? "/mcp";
   const sessions = /* @__PURE__ */ new Map();
   const searchEngine = options.searchEngine ?? "fts5";
+  const storePath = options.storePath ?? bundle.path;
   const httpServer = http.createServer((req, res) => {
-    handleRequest(req, res, mcpPath, sessions, bundle, searchEngine).catch((error) => {
-      writeError(res, error);
-    });
+    handleRequest(req, res, mcpPath, sessions, bundle, searchEngine, storePath).catch(
+      (error) => {
+        writeError(res, error);
+      }
+    );
   });
   await new Promise((resolve, reject) => {
     httpServer.once("error", reject);
@@ -6534,7 +6667,7 @@ async function listenMcpServer(bundle, options) {
     }
   };
 }
-async function handleRequest(req, res, mcpPath, sessions, bundle, searchEngine) {
+async function handleRequest(req, res, mcpPath, sessions, bundle, searchEngine, storePath) {
   if (!req.url || !req.url.startsWith(mcpPath)) {
     res.writeHead(404).end();
     return;
@@ -6556,14 +6689,14 @@ async function handleRequest(req, res, mcpPath, sessions, bundle, searchEngine)
       res.writeHead(404).end();
       return;
     }
-    entry = await openSession(bundle, sessions, searchEngine);
+    entry = await openSession(bundle, sessions, searchEngine, storePath);
   }
   const bodyText = await readBody(req);
   const body = bodyText.length > 0 ? safeJsonParse(bodyText) : void 0;
   await entry.transport.handleRequest(req, res, body);
 }
-async function openSession(bundle, store, searchEngine) {
-  const server = createMcpServer(bundle, searchEngine);
+async function openSession(bundle, store, searchEngine, storePath) {
+  const server = createMcpServer(bundle, searchEngine, storePath);
   const transport = new StreamableHTTPServerTransport({
     sessionIdGenerator: () => randomUUID(),
     onsessioninitialized: (id) => {
@@ -6581,7 +6714,7 @@ async function openSession(bundle, store, searchEngine) {
   await server.connect(transport);
   return { server, transport };
 }
-function createMcpServer(bundle, searchEngine) {
+function createMcpServer(bundle, searchEngine, storePath) {
   const server = new McpServer(
     {
       name: "prosa",
@@ -6589,7 +6722,7 @@ function createMcpServer(bundle, searchEngine) {
     },
     { instructions: PROSA_MCP_INSTRUCTIONS }
   );
-  registerProsaTools(server, bundle, { searchEngine });
+  registerProsaTools(server, bundle, { searchEngine, storePath });
   return server;
 }
 async function readBody(req) {
@@ -6630,7 +6763,8 @@ function writeError(res, error) {
 function mcpCommand() {
   const serve = new Command5("serve").description("Start a local MCP server over the prosa bundle.").option("--store <path>", "bundle directory", defaultBundlePath()).option("--transport <transport>", "MCP transport: stdio|http", "stdio").option("--host <host>", "bind host", "127.0.0.1").option("--port <port>", "bind port", "7331").option("--path <path>", "HTTP path", "/mcp").option("--search-engine <engine>", "search engine: fts5|tantivy", "fts5").action(
     async (options) => {
-      const bundle = await openBundle(path18.resolve(options.store));
+      const storePath = path18.resolve(options.store);
+      const bundle = await openBundle(storePath);
       try {
         const transport = parseMcpTransport(options.transport);
         const searchEngine = parseSearchEngine(options.searchEngine);
@@ -6643,7 +6777,8 @@ function mcpCommand() {
             host: options.host,
             port,
             path: options.path,
-            searchEngine
+            searchEngine,
+            storePath
           });
           process.stdout.write(`prosa mcp server listening at ${server2.url}
 `);
@@ -6651,7 +6786,7 @@ function mcpCommand() {
           registerShutdown(server2.close, bundle);
           return;
         }
-        const server = await listenMcpStdioServer(bundle, { searchEngine });
+        const server = await listenMcpStdioServer(bundle, { searchEngine, storePath });
         registerShutdown(server.close, bundle);
       } catch (error) {
         closeBundle(bundle);