@diegoaltoworks/chatter 0.45.0 → 0.48.0

package/dist/mcp-server.js

@@ -33,9 +33,7 @@ __export(mcp_server_exports, {
   createMCPServer: () => createMCPServer
 });
 module.exports = __toCommonJS(mcp_server_exports);
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_openai = __toESM(require("openai"));
-var import_zod = require("zod");
 
 // src/core/guardrails.ts
 function detectLeakage(text) {
@@ -81,8 +79,8 @@ async function completeOnce({
 
 // src/core/answer.ts
 var noUsage = () => ({ prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 });
-async function runAnswerFn(answerFn, { system, messages, mode, sender }) {
-  const result = await answerFn({ system, messages, mode, sender });
+async function runAnswerFn(answerFn, { system, messages, mode, sender, conversationId }) {
+  const result = await answerFn({ system, messages, mode, sender, conversationId });
   const raw = typeof result === "string" ? result : result?.content;
   const usage = typeof result === "string" ? void 0 : result?.usage;
   return {
@@ -97,11 +95,12 @@ async function answerOnce({
   messages,
   mode,
   sender,
+  conversationId,
   temperature,
   model
 }) {
   if (answerFn) {
-    return runAnswerFn(answerFn, { system, messages, mode, sender });
+    return runAnswerFn(answerFn, { system, messages, mode, sender, conversationId });
   }
   return completeOnce({ client, system, messages, temperature, model });
 }
@@ -137,6 +136,62 @@ async function resolveBuckets({
   return cleaned.filter((bucket) => ceiling.has(bucket));
 }
 
+// src/core/logger.ts
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+function createConsoleLogger(level = "info") {
+  const threshold = LEVEL_ORDER[level];
+  const write = (at) => (...args) => {
+    if (LEVEL_ORDER[at] < threshold) return;
+    console.error(`[${at}]`, ...args);
+  };
+  return {
+    debug: write("debug"),
+    info: write("info"),
+    warn: write("warn"),
+    error: write("error")
+  };
+}
+function resolveLogger(logger, level) {
+  return logger ?? createConsoleLogger(level);
+}
+
+// src/core/messages.ts
+function lastUserMessage(messages) {
+  return [...messages].reverse().find((m) => m.role === "user");
+}
+
+// src/core/pipeline.ts
+var MODE_SETTINGS = {
+  public: { topK: 6, label: "Context" },
+  private: { topK: 8, label: "Internal Context" }
+};
+async function prepareChat({
+  store,
+  prompts,
+  mode,
+  messages,
+  personaLayer,
+  channelHint,
+  buckets
+}) {
+  const lastUserMsg = lastUserMessage(messages);
+  if (!lastUserMsg) {
+    throw new Error("no user message found in conversation");
+  }
+  const { topK, label } = MODE_SETTINGS[mode];
+  const ctx = await store.query(lastUserMsg.content, topK, buckets ?? defaultBuckets(mode));
+  const persona = personaLayer?.trim() || (mode === "private" ? prompts.privatePersona : prompts.publicPersona);
+  const hint = channelHint?.trim();
+  const system = [
+    prompts.baseSystemRules,
+    persona,
+    ...hint ? [hint] : [],
+    `${label}:
+${ctx.join("\n\n")}`
+  ].join("\n\n");
+  return { system, messages, context: ctx };
+}
+
 // src/core/prompts.ts
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
@@ -229,6 +284,7 @@ var VectorStore = class _VectorStore {
       authToken: options.databaseAuthToken
     });
     this.knowledgeDir = options.knowledgeDir || "./config/knowledge";
+    this.logger = options.logger ?? createConsoleLogger();
   }
   client;
   /**
@@ -238,9 +294,10 @@ var VectorStore = class _VectorStore {
    */
   db;
   knowledgeDir;
+  logger;
   // On boot: ingest new chunks and embed only missing ones.
   async build() {
-    console.log("\u{1F504} Building knowledge base...");
+    this.logger.info("\u{1F504} Building knowledge base...");
     await this.db.execute(`
       CREATE TABLE IF NOT EXISTS chunks (id TEXT PRIMARY KEY, bucket TEXT NOT NULL, source TEXT NOT NULL, text TEXT NOT NULL);
     `);
@@ -249,7 +306,7 @@ var VectorStore = class _VectorStore {
     `);
     await this.db.execute("CREATE INDEX IF NOT EXISTS idx_chunks_bucket ON chunks(bucket);");
     const docs = loadKnowledge(this.knowledgeDir);
-    console.log(`\u{1F4DA} Loaded ${docs.length} knowledge documents`);
+    this.logger.info(`\u{1F4DA} Loaded ${docs.length} knowledge documents`);
     const rows = [];
     for (const d of docs) {
       for (const part of chunk(d.text)) {
@@ -257,21 +314,19 @@ var VectorStore = class _VectorStore {
         rows.push({ id, bucket: d.bucket, source: d.source, text: part });
       }
     }
-    console.log(`\u{1F4E6} Created ${rows.length} chunks from knowledge documents`);
+    this.logger.info(`\u{1F4E6} Created ${rows.length} chunks from knowledge documents`);
     await this.cleanupStaleChunks(rows.map((r) => r.id));
-    const tx = await this.db.transaction("write");
-    try {
-      for (const r of rows) {
-        await tx.execute({
+    const UPSERT_BATCH = 500;
+    for (let i = 0; i < rows.length; i += UPSERT_BATCH) {
+      const batch = rows.slice(i, i + UPSERT_BATCH);
+      await this.db.batch(
+        batch.map((r) => ({
           sql: `INSERT INTO chunks(id,bucket,source,text) VALUES(?,?,?,?)
                 ON CONFLICT(id) DO NOTHING`,
           args: [r.id, r.bucket, r.source, r.text]
-        });
-      }
-      await tx.commit();
-    } catch (e) {
-      await tx.rollback();
-      throw e;
+        })),
+        "write"
+      );
     }
     const ids = rows.map((r) => r.id);
     const missing = [];
@@ -286,32 +341,25 @@ var VectorStore = class _VectorStore {
       for (const row of res.rows) missing.push(String(row.id));
     }
     if (missing.length === 0) {
-      console.log("\u2705 No new chunks to embed - knowledge base is up to date");
+      this.logger.info("\u2705 No new chunks to embed - knowledge base is up to date");
       return;
     }
-    console.log(`\u{1F52E} Embedding ${missing.length} new/updated chunks with ${EMB_MODEL}...`);
+    this.logger.info(`\u{1F52E} Embedding ${missing.length} new/updated chunks with ${EMB_MODEL}...`);
     const textById = new Map(rows.map((r) => [r.id, r.text]));
     const BATCH = 96;
     for (let i = 0; i < missing.length; i += BATCH) {
       const batchIds = missing.slice(i, i + BATCH);
       const inputs = batchIds.map((id) => textById.get(id) || "");
       const emb = await this.client.embeddings.create({ model: EMB_MODEL, input: inputs });
-      const tx2 = await this.db.transaction("write");
-      try {
-        emb.data.forEach((d, idx) => {
-          const id = batchIds[idx];
-          tx2.execute({
-            sql: "INSERT INTO embeddings(id,model,embedding) VALUES(?,?,?)",
-            args: [id, EMB_MODEL, JSON.stringify(d.embedding)]
-          });
-        });
-        await tx2.commit();
-      } catch (e) {
-        await tx2.rollback();
-        throw e;
-      }
+      await this.db.batch(
+        emb.data.map((d, idx) => ({
+          sql: "INSERT INTO embeddings(id,model,embedding) VALUES(?,?,?)",
+          args: [batchIds[idx], EMB_MODEL, JSON.stringify(d.embedding)]
+        })),
+        "write"
+      );
     }
-    console.log(`\u2705 Successfully embedded ${missing.length} new chunks`);
+    this.logger.info(`\u2705 Successfully embedded ${missing.length} new chunks`);
   }
   // Remove chunks from database that no longer exist in markdown files
   async cleanupStaleChunks(currentIds) {
@@ -322,7 +370,7 @@ var VectorStore = class _VectorStore {
     if (staleIds.length === 0) {
       return;
     }
-    console.log(`\u{1F9F9} Cleaning up ${staleIds.length} stale chunks...`);
+    this.logger.info(`\u{1F9F9} Cleaning up ${staleIds.length} stale chunks...`);
     const BATCH_SIZE = 500;
     for (let i = 0; i < staleIds.length; i += BATCH_SIZE) {
       const batch = staleIds.slice(i, i + BATCH_SIZE);
@@ -332,7 +380,7 @@ var VectorStore = class _VectorStore {
         args: batch
       });
     }
-    console.log(`\u2713 Cleaned up ${staleIds.length} stale chunks and their embeddings`);
+    this.logger.info(`\u2713 Cleaned up ${staleIds.length} stale chunks and their embeddings`);
   }
   static cosine(a, b) {
     let dot = 0;
@@ -389,13 +437,11 @@ function getOrGenerateConversationId(providedId) {
 }
 
 // src/mcp-server/cost-tracker.ts
-function calculateCost(usage) {
+function calculateCost(usage, rates) {
   const promptTokens = usage.prompt_tokens || 0;
   const completionTokens = usage.completion_tokens || 0;
   const totalTokens = promptTokens + completionTokens;
-  const promptCost = promptTokens / 1e6 * 2.5;
-  const completionCost = completionTokens / 1e6 * 10;
-  const estimatedCost = promptCost + completionCost;
+  const estimatedCost = rates ? promptTokens / 1e6 * rates.promptPer1M + completionTokens / 1e6 * rates.completionPer1M : null;
   return {
     promptTokens,
     completionTokens,
@@ -408,15 +454,17 @@ function calculateCost(usage) {
 var MCPLogger = class {
   enableConsole;
   callback;
-  constructor(enableConsole = true, callback) {
+  logger;
+  constructor(enableConsole = true, callback, logger) {
     this.enableConsole = enableConsole;
     this.callback = callback;
+    this.logger = logger ?? createConsoleLogger();
   }
   /**
    * Log a chat interaction
    */
   async logChatInteraction(toolName, conversationId, conversationMessages, ragContext, response, duration, cost) {
-    const lastUserMsg = [...conversationMessages].reverse().find((m) => m.role === "user");
+    const lastUserMsg = lastUserMessage(conversationMessages);
     const logEvent = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       toolName,
@@ -429,7 +477,7 @@ var MCPLogger = class {
       cost
     };
     if (this.enableConsole) {
-      console.log(
+      this.logger.info(
         JSON.stringify({
           event: "mcp_chat",
           ...logEvent
@@ -440,13 +488,13 @@ var MCPLogger = class {
       try {
         await this.callback(logEvent);
       } catch (err) {
-        console.error("Logging callback error:", err);
+        this.logger.error("Logging callback error:", err);
       }
     }
   }
 };
-function createLogger(enableConsole = true, callback) {
-  return new MCPLogger(enableConsole, callback);
+function createLogger(enableConsole = true, callback, logger) {
+  return new MCPLogger(enableConsole, callback, logger);
 }
 
 // src/mcp-server/rate-limiter.ts
@@ -528,14 +576,57 @@ function createRateLimiter(limit, windowMs = 6e4) {
   return limit ? new RateLimiter(limit, windowMs) : null;
 }
 
+// src/mcp-server/sdk.ts
+function wrapMissingMcpPeerError(packageName, cause) {
+  return new Error(
+    `The MCP server ('@diegoaltoworks/chatter/mcp') requires the optional peer dependency '${packageName}', which is not installed. Install it with \`bun add ${packageName}\` (or npm/pnpm/yarn) to use this feature.`,
+    { cause }
+  );
+}
+var cachedSdk;
+function loadMcpSdk() {
+  if (!cachedSdk) {
+    cachedSdk = import("@modelcontextprotocol/sdk/server/mcp.js").then((mod) => {
+      if (!mod.McpServer) throw new Error("module has no McpServer export");
+      return mod.McpServer;
+    }).catch((error) => {
+      cachedSdk = void 0;
+      throw wrapMissingMcpPeerError("@modelcontextprotocol/sdk", error);
+    });
+  }
+  return cachedSdk;
+}
+var cachedZod;
+function loadZod() {
+  if (!cachedZod) {
+    cachedZod = import("zod").then((mod) => {
+      if (!mod.z) throw new Error("module has no z export");
+      return mod.z;
+    }).catch((error) => {
+      cachedZod = void 0;
+      throw wrapMissingMcpPeerError("zod", error);
+    });
+  }
+  return cachedZod;
+}
+
+// src/mcp-server/tool-input.ts
+function resolveConversationMessages(message, messages) {
+  if (messages) return messages;
+  if (message) return [{ role: "user", content: message }];
+  throw new Error("Either 'message' or 'messages' is required");
+}
+
 // src/mcp-server.ts
 async function createMCPServer(config) {
-  console.log(`\u{1F680} Starting ${config.bot.name} MCP Server...`);
+  const log = resolveLogger(config.logger, config.logLevel);
+  log.info(`\u{1F680} Starting ${config.bot.name} MCP Server...`);
+  const [McpServer, z] = await Promise.all([loadMcpSdk(), loadZod()]);
   const knowledgeDir = config.knowledgeDir || "./config/knowledge";
   const promptsDir = config.promptsDir || "./config/prompts";
   const transportMode = config.transport || "stdio";
   const rateLimiter = createRateLimiter(config.toolRateLimit);
-  const logger = createLogger(config.logging?.console !== false, config.logging?.onChat);
+  const logger = createLogger(config.logging?.console !== false, config.logging?.onChat, log);
   const publicToolConfig = {
     enabled: config.tools?.public?.enabled !== false,
     name: config.tools?.public?.name || "chat_public",
@@ -549,29 +640,31 @@ async function createMCPServer(config) {
   const client = new import_openai.default({
     apiKey: config.openai.apiKey
   });
+  const model = config.openai.model || DEFAULT_MODEL;
   const store = new VectorStore(client, {
     databaseUrl: config.database.url,
     databaseAuthToken: config.database.authToken,
-    knowledgeDir
+    knowledgeDir,
+    logger: log
   });
   await store.build();
-  console.log("\u2705 Knowledge base ready");
+  log.info("\u2705 Knowledge base ready");
   const prompts = new PromptLoader(promptsDir, config.bot);
-  const server = new import_mcp.McpServer({
+  const server = new McpServer({
     name: config.bot.name,
     version: "1.0.0"
   });
-  console.log("\u2705 MCP server initialized");
+  log.info("\u2705 MCP server initialized");
   if (publicToolConfig.enabled) {
     const publicShape = {
-      message: import_zod.z.string().optional().describe("A single message to send (for simple queries)"),
-      messages: import_zod.z.array(
-        import_zod.z.object({
-          role: import_zod.z.enum(["user", "assistant"]),
-          content: import_zod.z.string()
+      message: z.string().optional().describe("A single message to send (for simple queries)"),
+      messages: z.array(
+        z.object({
+          role: z.enum(["user", "assistant"]),
+          content: z.string()
         })
       ).optional().describe("Conversation history with alternating user/assistant messages"),
-      conversationId: import_zod.z.string().optional().describe(
+      conversationId: z.string().optional().describe(
         "Optional conversation ID to track sessions. If not provided, a new ID will be generated."
       )
     };
@@ -590,34 +683,28 @@ async function createMCPServer(config) {
             `Rate limit exceeded for ${publicToolConfig.name}. Maximum ${config.toolRateLimit} requests per minute.`
           );
         }
-        let conversationMessages;
-        if (messages && Array.isArray(messages)) {
-          conversationMessages = messages;
-        } else if (message) {
-          conversationMessages = [{ role: "user", content: String(message) }];
-        } else {
-          throw new Error("Either 'message' or 'messages' is required");
-        }
-        const lastUserMsg = [...conversationMessages].reverse().find((m) => m.role === "user");
-        if (!lastUserMsg) {
+        const conversationMessages = resolveConversationMessages(message, messages);
+        if (!lastUserMessage(conversationMessages)) {
           throw new Error("No user message found in conversation");
         }
-        const buckets = await resolveBuckets({ mode: "public", bucketsFor: config.bucketsFor }) ?? defaultBuckets("public");
-        const ctx = await store.query(lastUserMsg.content, 6, buckets);
-        const system = [
-          prompts.baseSystemRules,
-          prompts.publicPersona,
-          `Context:
-${ctx.join("\n\n")}`
-        ].join("\n\n");
+        const buckets = await resolveBuckets({ mode: "public", bucketsFor: config.bucketsFor });
+        const { system, context: ctx } = await prepareChat({
+          store,
+          prompts,
+          mode: "public",
+          messages: conversationMessages,
+          buckets
+        });
         const result = await answerOnce({
           answerFn: config.answerFn,
           client,
           system,
           messages: conversationMessages,
-          mode: "public"
+          mode: "public",
+          conversationId: convId,
+          model
         });
-        const cost = calculateCost(result.usage);
+        const cost = calculateCost(result.usage, config.openai.pricing);
         const duration = Date.now() - startTime;
         await logger.logChatInteraction(
           publicToolConfig.name,
@@ -627,7 +714,7 @@ ${ctx.join("\n\n")}`
           result.content,
           duration,
           cost
-        ).catch((err) => console.error("Logging error:", err));
+        ).catch((err) => log.error("Logging error:", err));
         return {
           content: [
             {
@@ -647,18 +734,18 @@ ${ctx.join("\n\n")}`
         };
       }
     );
-    console.log(`\u2705 Registered tool: ${publicToolConfig.name}`);
+    log.info(`\u2705 Registered tool: ${publicToolConfig.name}`);
   }
   if (privateToolConfig.enabled) {
     const privateShape = {
-      message: import_zod.z.string().optional().describe("A single message to send (for simple queries)"),
-      messages: import_zod.z.array(
-        import_zod.z.object({
-          role: import_zod.z.enum(["user", "assistant"]),
-          content: import_zod.z.string()
+      message: z.string().optional().describe("A single message to send (for simple queries)"),
+      messages: z.array(
+        z.object({
+          role: z.enum(["user", "assistant"]),
+          content: z.string()
         })
       ).optional().describe("Conversation history with alternating user/assistant messages"),
-      conversationId: import_zod.z.string().optional().describe(
+      conversationId: z.string().optional().describe(
         "Optional conversation ID to track sessions. If not provided, a new ID will be generated."
       )
     };
@@ -677,34 +764,28 @@ ${ctx.join("\n\n")}`
             `Rate limit exceeded for ${privateToolConfig.name}. Maximum ${config.toolRateLimit} requests per minute.`
           );
         }
-        let conversationMessages;
-        if (messages && Array.isArray(messages)) {
-          conversationMessages = messages;
-        } else if (message) {
-          conversationMessages = [{ role: "user", content: String(message) }];
-        } else {
-          throw new Error("Either 'message' or 'messages' is required");
-        }
-        const lastUserMsg = [...conversationMessages].reverse().find((m) => m.role === "user");
-        if (!lastUserMsg) {
+        const conversationMessages = resolveConversationMessages(message, messages);
+        if (!lastUserMessage(conversationMessages)) {
           throw new Error("No user message found in conversation");
         }
-        const buckets = await resolveBuckets({ mode: "private", bucketsFor: config.bucketsFor }) ?? defaultBuckets("private");
-        const ctx = await store.query(lastUserMsg.content, 8, buckets);
-        const system = [
-          prompts.baseSystemRules,
-          prompts.privatePersona,
-          `Internal Context:
-${ctx.join("\n\n")}`
-        ].join("\n\n");
+        const buckets = await resolveBuckets({ mode: "private", bucketsFor: config.bucketsFor });
+        const { system, context: ctx } = await prepareChat({
+          store,
+          prompts,
+          mode: "private",
+          messages: conversationMessages,
+          buckets
+        });
         const result = await answerOnce({
           answerFn: config.answerFn,
           client,
           system,
           messages: conversationMessages,
-          mode: "private"
+          mode: "private",
+          conversationId: convId,
+          model
         });
-        const cost = calculateCost(result.usage);
+        const cost = calculateCost(result.usage, config.openai.pricing);
         const duration = Date.now() - startTime;
         await logger.logChatInteraction(
           privateToolConfig.name,
@@ -714,7 +795,7 @@ ${ctx.join("\n\n")}`
           result.content,
           duration,
           cost
-        ).catch((err) => console.error("Logging error:", err));
+        ).catch((err) => log.error("Logging error:", err));
         return {
           content: [
             {
@@ -734,16 +815,16 @@ ${ctx.join("\n\n")}`
         };
       }
     );
-    console.log(`\u2705 Registered tool: ${privateToolConfig.name}`);
+    log.info(`\u2705 Registered tool: ${privateToolConfig.name}`);
   }
   const enabledTools = [
     publicToolConfig.enabled ? publicToolConfig.name : null,
     privateToolConfig.enabled ? privateToolConfig.name : null
   ].filter(Boolean);
   if (enabledTools.length === 0) {
-    console.warn("\u26A0\uFE0F  Warning: No MCP tools enabled");
+    log.warn("\u26A0\uFE0F  Warning: No MCP tools enabled");
   }
-  console.log(
+  log.info(
     `\u2705 ${config.bot.name} MCP Server ready (transport: ${transportMode}, tools: ${enabledTools.join(", ") || "none"})`
   );
   return server;