@diegoaltoworks/chatter 0.1.8 → 0.8.0

package/dist/mcp-server.js

@@ -0,0 +1,671 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mcp-server.ts
+var mcp_server_exports = {};
+__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) {
+  const flags = [
+    /system prompt/i,
+    /hidden instruction/i,
+    /here (are|is) (my|the) rules/i,
+    /BEGIN SYSTEM PROMPT/i,
+    /tool instructions/i
+  ];
+  return flags.some((rx) => rx.test(text));
+}
+function scrubOutput(text) {
+  return text.replace(/sk-[A-Za-z0-9]{15,}/g, "[REDACTED]").replace(/AIza[0-9A-Za-z_-]{30,}/g, "[REDACTED]");
+}
+
+// src/core/llm.ts
+async function completeOnce({
+  client,
+  system,
+  messages,
+  temperature = 0.2
+}) {
+  const res = await client.chat.completions.create({
+    model: "gpt-4o",
+    temperature,
+    messages: [{ role: "system", content: system }, ...messages]
+  });
+  let text = res.choices[0]?.message?.content ?? "";
+  if (detectLeakage(text))
+    text = "Sorry, I can't share internal instructions. How else can I help?";
+  return {
+    content: scrubOutput(text),
+    usage: res.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+  };
+}
+
+// src/core/prompts.ts
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var PromptLoader = class {
+  constructor(promptsDir, bot) {
+    this.promptsDir = promptsDir;
+    this.bot = bot;
+  }
+  /**
+   * Load a prompt template and interpolate variables
+   */
+  load(filename) {
+    const path = (0, import_node_path.join)(this.promptsDir, filename);
+    const template = (0, import_node_fs.readFileSync)(path, "utf-8");
+    const personFirstName = this.bot.personName.split(" ")[0];
+    return template.replace(/\{\{botName\}\}/g, this.bot.name).replace(/\{\{personName\}\}/g, this.bot.personName).replace(/\{\{personFirstName\}\}/g, personFirstName);
+  }
+  /** Base system rules prompt */
+  get baseSystemRules() {
+    return this.load("base.txt");
+  }
+  /** Public persona prompt */
+  get publicPersona() {
+    return this.load("public.txt");
+  }
+  /** Private persona prompt */
+  get privatePersona() {
+    return this.load("private.txt");
+  }
+};
+
+// src/core/retrieval.ts
+var import_client = require("@libsql/client");
+
+// src/core/loaders.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
+function walk(dir) {
+  const items = [];
+  try {
+    for (const e of (0, import_node_fs2.readdirSync)(dir)) {
+      const p = (0, import_node_path2.join)(dir, e);
+      const st = (0, import_node_fs2.statSync)(p);
+      if (st.isDirectory()) items.push(...walk(p));
+      else if (p.endsWith(".md")) items.push(p);
+    }
+  } catch {
+  }
+  return items;
+}
+function loadKnowledge(root = "config/knowledge") {
+  const docs = [];
+  for (const bucket of ["base", "public", "private"]) {
+    const dir = (0, import_node_path2.join)(root, bucket);
+    for (const f of walk(dir)) {
+      docs.push({ id: f, text: (0, import_node_fs2.readFileSync)(f, "utf8"), source: f, bucket });
+    }
+  }
+  return docs;
+}
+
+// src/core/retrieval.ts
+var EMB_MODEL = "text-embedding-3-large";
+function chunk(text, max = 900) {
+  const out = [];
+  let buf = "";
+  for (const line of text.replace(/\r/g, "").split("\n")) {
+    if (`${buf}
+${line}`.length > max) {
+      out.push(buf.trim());
+      buf = line;
+    } else buf += `
+${line}`;
+  }
+  if (buf.trim()) out.push(buf.trim());
+  return out;
+}
+async function sha256(input) {
+  const data = new TextEncoder().encode(input);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hash)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var VectorStore = class _VectorStore {
+  constructor(client, options) {
+    this.client = client;
+    this.db = (0, import_client.createClient)({
+      url: options.databaseUrl,
+      authToken: options.databaseAuthToken
+    });
+    this.knowledgeDir = options.knowledgeDir || "./config/knowledge";
+  }
+  db;
+  knowledgeDir;
+  // On boot: ingest new chunks and embed only missing ones.
+  async build() {
+    console.log("\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);
+    `);
+    await this.db.execute(`
+      CREATE TABLE IF NOT EXISTS embeddings (id TEXT PRIMARY KEY, model TEXT NOT NULL, embedding BLOB NOT NULL);
+    `);
+    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`);
+    const rows = [];
+    for (const d of docs) {
+      for (const part of chunk(d.text)) {
+        const id = await sha256(`${d.bucket}|${d.source}|${part}`);
+        rows.push({ id, bucket: d.bucket, source: d.source, text: part });
+      }
+    }
+    console.log(`\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({
+          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;
+    }
+    const ids = rows.map((r) => r.id);
+    const missing = [];
+    for (let i = 0; i < ids.length; i += 500) {
+      const batch = ids.slice(i, i + 500);
+      const placeholders = batch.map(() => "?").join(",");
+      const res = await this.db.execute({
+        sql: `SELECT id FROM chunks WHERE id IN (${placeholders})
+              EXCEPT SELECT id FROM embeddings`,
+        args: batch
+      });
+      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");
+      return;
+    }
+    console.log(`\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;
+      }
+    }
+    console.log(`\u2705 Successfully embedded ${missing.length} new chunks`);
+  }
+  // Remove chunks from database that no longer exist in markdown files
+  async cleanupStaleChunks(currentIds) {
+    const result = await this.db.execute("SELECT id FROM chunks");
+    const dbIds = result.rows.map((row) => String(row.id));
+    const currentIdSet = new Set(currentIds);
+    const staleIds = dbIds.filter((id) => !currentIdSet.has(id));
+    if (staleIds.length === 0) {
+      return;
+    }
+    console.log(`\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);
+      const placeholders = batch.map(() => "?").join(",");
+      await this.db.execute({
+        sql: `DELETE FROM chunks WHERE id IN (${placeholders})`,
+        args: batch
+      });
+    }
+    console.log(`\u2713 Cleaned up ${staleIds.length} stale chunks and their embeddings`);
+  }
+  static cosine(a, b) {
+    let dot = 0;
+    let na = 0;
+    let nb = 0;
+    for (let i = 0; i < a.length; i++) {
+      dot += a[i] * b[i];
+      na += a[i] * a[i];
+      nb += b[i] * b[i];
+    }
+    return dot / (Math.sqrt(na) * Math.sqrt(nb));
+  }
+  // Retrieve top-k across allowed buckets; compute similarity in app (simple & portable).
+  async query(q, k = 6, allowed = ["base"]) {
+    const qv = (await this.client.embeddings.create({ model: EMB_MODEL, input: [q] })).data[0].embedding;
+    const placeholders = allowed.map(() => "?").join(",");
+    const res = await this.db.execute({
+      sql: `SELECT c.id, c.text, e.embedding
+            FROM chunks c
+            JOIN embeddings e ON e.id = c.id
+            WHERE c.bucket IN (${placeholders})`,
+      args: allowed
+    });
+    const scored = [];
+    for (const row of res.rows) {
+      const emb = JSON.parse(String(row.embedding));
+      const s = _VectorStore.cosine(qv, emb);
+      scored.push({ s, text: String(row.text) });
+    }
+    scored.sort((a, b) => b.s - a.s);
+    return scored.slice(0, k).map((r) => r.text);
+  }
+};
+
+// src/mcp-server/conversation-id.ts
+function generateConversationId() {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).slice(2, 11);
+  return `conv_${timestamp}_${random}`;
+}
+function getOrGenerateConversationId(providedId) {
+  return providedId || generateConversationId();
+}
+
+// src/mcp-server/cost-tracker.ts
+function calculateCost(usage) {
+  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;
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    estimatedCost
+  };
+}
+
+// src/mcp-server/logger.ts
+var MCPLogger = class {
+  enableConsole;
+  callback;
+  constructor(enableConsole = true, callback) {
+    this.enableConsole = enableConsole;
+    this.callback = callback;
+  }
+  /**
+   * Log a chat interaction
+   */
+  async logChatInteraction(toolName, conversationId, conversationMessages, ragContext, response, duration, cost) {
+    const lastUserMsg = [...conversationMessages].reverse().find((m) => m.role === "user");
+    const logEvent = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      toolName,
+      conversationId,
+      userMessage: lastUserMsg?.content || "",
+      conversationHistory: conversationMessages,
+      ragContext,
+      response,
+      duration,
+      cost
+    };
+    if (this.enableConsole) {
+      console.log(
+        JSON.stringify({
+          event: "mcp_chat",
+          ...logEvent
+        })
+      );
+    }
+    if (this.callback) {
+      try {
+        await this.callback(logEvent);
+      } catch (err) {
+        console.error("Logging callback error:", err);
+      }
+    }
+  }
+};
+function createLogger(enableConsole = true, callback) {
+  return new MCPLogger(enableConsole, callback);
+}
+
+// src/mcp-server/rate-limiter.ts
+var RateLimiter = class {
+  requestMap;
+  limit;
+  windowMs;
+  /**
+   * Create a new rate limiter
+   *
+   * @param limit - Maximum requests allowed in the time window
+   * @param windowMs - Time window in milliseconds (default: 60000 = 1 minute)
+   */
+  constructor(limit, windowMs = 6e4) {
+    this.requestMap = /* @__PURE__ */ new Map();
+    this.limit = limit;
+    this.windowMs = windowMs;
+  }
+  /**
+   * Check if a request should be allowed
+   *
+   * @param key - Unique identifier for the rate limit (e.g., tool name)
+   * @returns true if request is allowed, false if rate limit exceeded
+   */
+  check(key) {
+    const now = Date.now();
+    const windowStart = now - this.windowMs;
+    const timestamps = this.requestMap.get(key) || [];
+    const recentTimestamps = timestamps.filter((ts) => ts > windowStart);
+    if (recentTimestamps.length >= this.limit) {
+      return false;
+    }
+    recentTimestamps.push(now);
+    this.requestMap.set(key, recentTimestamps);
+    return true;
+  }
+  /**
+   * Get current request count for a key
+   *
+   * @param key - Unique identifier
+   * @returns Current number of requests in the window
+   */
+  getCount(key) {
+    const now = Date.now();
+    const windowStart = now - this.windowMs;
+    const timestamps = this.requestMap.get(key) || [];
+    return timestamps.filter((ts) => ts > windowStart).length;
+  }
+  /**
+   * Reset rate limit for a specific key
+   *
+   * @param key - Unique identifier to reset
+   */
+  reset(key) {
+    this.requestMap.delete(key);
+  }
+  /**
+   * Reset all rate limits
+   */
+  resetAll() {
+    this.requestMap.clear();
+  }
+  /**
+   * Get time until rate limit resets (in ms)
+   *
+   * @param key - Unique identifier
+   * @returns Milliseconds until the oldest request falls out of the window
+   */
+  getTimeUntilReset(key) {
+    const timestamps = this.requestMap.get(key) || [];
+    if (timestamps.length === 0) return 0;
+    const now = Date.now();
+    const oldestTimestamp = Math.min(...timestamps);
+    const timeUntilReset = this.windowMs - (now - oldestTimestamp);
+    return Math.max(0, timeUntilReset);
+  }
+};
+function createRateLimiter(limit, windowMs = 6e4) {
+  return limit ? new RateLimiter(limit, windowMs) : null;
+}
+
+// src/mcp-server.ts
+async function createMCPServer(config) {
+  console.log(`\u{1F680} Starting ${config.bot.name} MCP Server...`);
+  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 publicToolConfig = {
+    enabled: config.tools?.public?.enabled !== false,
+    name: config.tools?.public?.name || "chat_public",
+    description: config.tools?.public?.description || `Chat with ${config.bot.name} using public knowledge base. Supports both single messages and conversation history.`
+  };
+  const privateToolConfig = {
+    enabled: config.tools?.private?.enabled !== false,
+    name: config.tools?.private?.name || "chat_private",
+    description: config.tools?.private?.description || `Chat with ${config.bot.name} using private/internal knowledge base. Supports both single messages and conversation history.`
+  };
+  const client = new import_openai.default({
+    apiKey: config.openai.apiKey
+  });
+  const store = new VectorStore(client, {
+    databaseUrl: config.database.url,
+    databaseAuthToken: config.database.authToken,
+    knowledgeDir
+  });
+  await store.build();
+  console.log("\u2705 Knowledge base ready");
+  const prompts = new PromptLoader(promptsDir, config.bot);
+  const server = new import_mcp.McpServer({
+    name: config.bot.name,
+    version: "1.0.0"
+  });
+  console.log("\u2705 MCP server initialized");
+  if (publicToolConfig.enabled) {
+    const publicSchema = import_zod.z.object({
+      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()
+        })
+      ).optional().describe("Conversation history with alternating user/assistant messages"),
+      conversationId: import_zod.z.string().optional().describe(
+        "Optional conversation ID to track sessions. If not provided, a new ID will be generated."
+      )
+    }).refine(
+      (data) => data.message !== void 0 || data.messages !== void 0,
+      "Either 'message' or 'messages' must be provided"
+    );
+    server.registerTool(
+      publicToolConfig.name,
+      {
+        description: publicToolConfig.description,
+        inputSchema: publicSchema
+      },
+      async (args) => {
+        const { message, messages, conversationId } = args;
+        const startTime = Date.now();
+        const convId = getOrGenerateConversationId(conversationId);
+        if (rateLimiter && !rateLimiter.check(publicToolConfig.name)) {
+          throw new Error(
+            `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) {
+          throw new Error("No user message found in conversation");
+        }
+        const ctx = await store.query(lastUserMsg.content, 6, ["base", "public"]);
+        const system = [
+          prompts.baseSystemRules,
+          prompts.publicPersona,
+          `Context:
+${ctx.join("\n\n")}`
+        ].join("\n\n");
+        const result = await completeOnce({
+          client,
+          system,
+          messages: conversationMessages
+        });
+        const cost = calculateCost(result.usage);
+        const duration = Date.now() - startTime;
+        await logger.logChatInteraction(
+          publicToolConfig.name,
+          convId,
+          conversationMessages,
+          ctx,
+          result.content,
+          duration,
+          cost
+        ).catch((err) => console.error("Logging error:", err));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.content
+            }
+          ],
+          _meta: {
+            conversationId: convId,
+            cost: {
+              promptTokens: cost.promptTokens,
+              completionTokens: cost.completionTokens,
+              totalTokens: cost.totalTokens,
+              estimatedCostUSD: cost.estimatedCost
+            }
+          }
+        };
+      }
+    );
+    console.log(`\u2705 Registered tool: ${publicToolConfig.name}`);
+  }
+  if (privateToolConfig.enabled) {
+    const privateSchema = import_zod.z.object({
+      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()
+        })
+      ).optional().describe("Conversation history with alternating user/assistant messages"),
+      conversationId: import_zod.z.string().optional().describe(
+        "Optional conversation ID to track sessions. If not provided, a new ID will be generated."
+      )
+    }).refine(
+      (data) => data.message !== void 0 || data.messages !== void 0,
+      "Either 'message' or 'messages' must be provided"
+    );
+    server.registerTool(
+      privateToolConfig.name,
+      {
+        description: privateToolConfig.description,
+        inputSchema: privateSchema
+      },
+      async (args) => {
+        const { message, messages, conversationId } = args;
+        const startTime = Date.now();
+        const convId = getOrGenerateConversationId(conversationId);
+        if (rateLimiter && !rateLimiter.check(privateToolConfig.name)) {
+          throw new Error(
+            `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) {
+          throw new Error("No user message found in conversation");
+        }
+        const ctx = await store.query(lastUserMsg.content, 8, ["base", "private"]);
+        const system = [
+          prompts.baseSystemRules,
+          prompts.privatePersona,
+          `Internal Context:
+${ctx.join("\n\n")}`
+        ].join("\n\n");
+        const result = await completeOnce({
+          client,
+          system,
+          messages: conversationMessages
+        });
+        const cost = calculateCost(result.usage);
+        const duration = Date.now() - startTime;
+        await logger.logChatInteraction(
+          privateToolConfig.name,
+          convId,
+          conversationMessages,
+          ctx,
+          result.content,
+          duration,
+          cost
+        ).catch((err) => console.error("Logging error:", err));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.content
+            }
+          ],
+          _meta: {
+            conversationId: convId,
+            cost: {
+              promptTokens: cost.promptTokens,
+              completionTokens: cost.completionTokens,
+              totalTokens: cost.totalTokens,
+              estimatedCostUSD: cost.estimatedCost
+            }
+          }
+        };
+      }
+    );
+    console.log(`\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");
+  }
+  console.log(
+    `\u2705 ${config.bot.name} MCP Server ready (transport: ${transportMode}, tools: ${enabledTools.join(", ") || "none"})`
+  );
+  return server;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMCPServer
+});