opensentinel 3.1.1 → 3.7.0

package/dist/chunk-6W6PTJFT.js

@@ -0,0 +1,181 @@
+// src/integrations/documents/docx-parser.ts
+import mammoth from "mammoth";
+import * as fs from "fs/promises";
+import * as path from "path";
+async function parseDOCX(input, options = {}) {
+  let buffer;
+  if (typeof input === "string") {
+    const absolutePath = path.isAbsolute(input) ? input : path.resolve(input);
+    buffer = await fs.readFile(absolutePath);
+  } else {
+    buffer = input;
+  }
+  const mammothOptions = {};
+  if (options.styleMap && options.styleMap.length > 0) {
+    mammothOptions.styleMap = options.styleMap;
+  }
+  if (options.includeImages) {
+    mammothOptions.convertImage = mammoth.images.imgElement((image) => {
+      return image.read("base64").then((imageBuffer) => {
+        return {
+          src: `data:${image.contentType};base64,${imageBuffer}`
+        };
+      });
+    });
+  }
+  const htmlResult = await mammoth.convertToHtml(
+    { buffer },
+    mammothOptions
+  );
+  const textResult = await mammoth.extractRawText({ buffer });
+  let markdown = "";
+  if (options.outputMarkdown) {
+    markdown = htmlToMarkdown(htmlResult.value);
+  }
+  const text = textResult.value;
+  const wordCount = text.split(/\s+/).filter((word) => word.length > 0).length;
+  const characterCount = text.length;
+  const paragraphCount = text.split(/\n\n+/).filter((p) => p.trim().length > 0).length;
+  const messages = htmlResult.messages.map((msg) => ({
+    type: msg.type,
+    message: msg.message,
+    paragraphIndex: msg.paragraphIndex
+  }));
+  return {
+    text: textResult.value,
+    html: htmlResult.value,
+    markdown: markdown || htmlToMarkdown(htmlResult.value),
+    messages,
+    metadata: {
+      wordCount,
+      characterCount,
+      paragraphCount
+    }
+  };
+}
+function htmlToMarkdown(html) {
+  let markdown = html;
+  markdown = markdown.replace(/<h1[^>]*>(.*?)<\/h1>/gi, "# $1\n\n");
+  markdown = markdown.replace(/<h2[^>]*>(.*?)<\/h2>/gi, "## $1\n\n");
+  markdown = markdown.replace(/<h3[^>]*>(.*?)<\/h3>/gi, "### $1\n\n");
+  markdown = markdown.replace(/<h4[^>]*>(.*?)<\/h4>/gi, "#### $1\n\n");
+  markdown = markdown.replace(/<h5[^>]*>(.*?)<\/h5>/gi, "##### $1\n\n");
+  markdown = markdown.replace(/<h6[^>]*>(.*?)<\/h6>/gi, "###### $1\n\n");
+  markdown = markdown.replace(/<strong[^>]*>(.*?)<\/strong>/gi, "**$1**");
+  markdown = markdown.replace(/<b[^>]*>(.*?)<\/b>/gi, "**$1**");
+  markdown = markdown.replace(/<em[^>]*>(.*?)<\/em>/gi, "*$1*");
+  markdown = markdown.replace(/<i[^>]*>(.*?)<\/i>/gi, "*$1*");
+  markdown = markdown.replace(
+    /<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi,
+    "[$2]($1)"
+  );
+  markdown = markdown.replace(
+    /<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi,
+    "![$2]($1)"
+  );
+  markdown = markdown.replace(
+    /<img[^>]*src="([^"]*)"[^>]*\/?>/gi,
+    "![]($1)"
+  );
+  markdown = markdown.replace(/<ul[^>]*>/gi, "\n");
+  markdown = markdown.replace(/<\/ul>/gi, "\n");
+  markdown = markdown.replace(/<ol[^>]*>/gi, "\n");
+  markdown = markdown.replace(/<\/ol>/gi, "\n");
+  markdown = markdown.replace(/<li[^>]*>(.*?)<\/li>/gi, "- $1\n");
+  markdown = markdown.replace(/<p[^>]*>(.*?)<\/p>/gi, "$1\n\n");
+  markdown = markdown.replace(/<br[^>]*\/?>/gi, "\n");
+  markdown = markdown.replace(/<code[^>]*>(.*?)<\/code>/gi, "`$1`");
+  markdown = markdown.replace(/<pre[^>]*>(.*?)<\/pre>/gis, "```\n$1\n```\n");
+  markdown = markdown.replace(
+    /<blockquote[^>]*>(.*?)<\/blockquote>/gis,
+    (match, content) => {
+      return content.split("\n").map((line) => `> ${line}`).join("\n");
+    }
+  );
+  markdown = markdown.replace(/<table[^>]*>/gi, "\n");
+  markdown = markdown.replace(/<\/table>/gi, "\n");
+  markdown = markdown.replace(/<tr[^>]*>/gi, "");
+  markdown = markdown.replace(/<\/tr>/gi, "|\n");
+  markdown = markdown.replace(/<th[^>]*>(.*?)<\/th>/gi, "| **$1** ");
+  markdown = markdown.replace(/<td[^>]*>(.*?)<\/td>/gi, "| $1 ");
+  markdown = markdown.replace(/<hr[^>]*\/?>/gi, "\n---\n");
+  markdown = markdown.replace(/<[^>]+>/g, "");
+  markdown = decodeHtmlEntities(markdown);
+  markdown = markdown.replace(/\n{3,}/g, "\n\n");
+  markdown = markdown.trim();
+  return markdown;
+}
+function decodeHtmlEntities(text) {
+  const entities = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&apos;": "'",
+    "&nbsp;": " ",
+    "&ndash;": "-",
+    "&mdash;": "--",
+    "&lsquo;": "'",
+    "&rsquo;": "'",
+    "&ldquo;": '"',
+    "&rdquo;": '"',
+    "&hellip;": "...",
+    "&copy;": "(c)",
+    "&reg;": "(R)",
+    "&trade;": "(TM)"
+  };
+  let result = text;
+  for (const [entity, char] of Object.entries(entities)) {
+    result = result.replace(new RegExp(entity, "g"), char);
+  }
+  result = result.replace(
+    /&#(\d+);/g,
+    (match, dec) => String.fromCharCode(parseInt(dec, 10))
+  );
+  result = result.replace(
+    /&#x([0-9a-fA-F]+);/g,
+    (match, hex) => String.fromCharCode(parseInt(hex, 16))
+  );
+  return result;
+}
+async function extractDOCXText(input) {
+  const result = await parseDOCX(input);
+  return result.text;
+}
+async function extractDOCXMarkdown(input) {
+  const result = await parseDOCX(input, { outputMarkdown: true });
+  return result.markdown;
+}
+async function isValidDOCX(input) {
+  try {
+    let buffer;
+    if (typeof input === "string") {
+      const absolutePath = path.isAbsolute(input) ? input : path.resolve(input);
+      buffer = await fs.readFile(absolutePath);
+    } else {
+      buffer = input;
+    }
+    const header = buffer.slice(0, 4);
+    if (header[0] !== 80 || header[1] !== 75) {
+      return false;
+    }
+    await mammoth.extractRawText({ buffer });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDOCXStats(input) {
+  const result = await parseDOCX(input);
+  return result.metadata;
+}
+
+export {
+  parseDOCX,
+  extractDOCXText,
+  extractDOCXMarkdown,
+  isValidDOCX,
+  getDOCXStats
+};
+//# sourceMappingURL=chunk-6W6PTJFT.js.map

package/dist/chunk-6W6PTJFT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/integrations/documents/docx-parser.ts"],"sourcesContent":["/**\r\n * DOCX Parser for OpenSentinel Document Ingestion\r\n *\r\n * Extracts text content from Word documents using mammoth.\r\n */\r\n\r\nimport mammoth from \"mammoth\";\r\nimport * as fs from \"fs/promises\";\r\nimport * as path from \"path\";\r\n\r\nexport interface DOCXParseResult {\r\n  text: string;\r\n  html: string;\r\n  markdown: string;\r\n  messages: DOCXMessage[];\r\n  metadata: DOCXMetadata;\r\n}\r\n\r\nexport interface DOCXMessage {\r\n  type: \"warning\" | \"error\";\r\n  message: string;\r\n  paragraphIndex?: number;\r\n}\r\n\r\nexport interface DOCXMetadata {\r\n  /** Estimated word count */\r\n  wordCount: number;\r\n  /** Estimated character count */\r\n  characterCount: number;\r\n  /** Number of paragraphs */\r\n  paragraphCount: number;\r\n}\r\n\r\nexport interface DOCXParseOptions {\r\n  /** Include images as base64 data URIs */\r\n  includeImages?: boolean;\r\n  /** Custom style mappings for mammoth */\r\n  styleMap?: string[];\r\n  /** Convert to markdown instead of plain text */\r\n  outputMarkdown?: boolean;\r\n}\r\n\r\n/**\r\n * Parse a DOCX file and extract its content\r\n */\r\nexport async function parseDOCX(\r\n  input: string | Buffer,\r\n  options: DOCXParseOptions = {}\r\n): Promise<DOCXParseResult> {\r\n  let buffer: Buffer;\r\n\r\n  if (typeof input === \"string\") {\r\n    const absolutePath = path.isAbsolute(input) ? input : path.resolve(input);\r\n    buffer = await fs.readFile(absolutePath);\r\n  } else {\r\n    buffer = input;\r\n  }\r\n\r\n  const mammothOptions: any = {};\r\n\r\n  // Apply custom style mappings\r\n  if (options.styleMap && options.styleMap.length > 0) {\r\n    mammothOptions.styleMap = options.styleMap;\r\n  }\r\n\r\n  // Handle images\r\n  if (options.includeImages) {\r\n    mammothOptions.convertImage = mammoth.images.imgElement((image) => {\r\n      return image.read(\"base64\").then((imageBuffer) => {\r\n        return {\r\n          src: `data:${image.contentType};base64,${imageBuffer}`,\r\n        };\r\n      });\r\n    });\r\n  }\r\n\r\n  // Extract HTML\r\n  const htmlResult = await mammoth.convertToHtml(\r\n    { buffer },\r\n    mammothOptions\r\n  );\r\n\r\n  // Extract plain text\r\n  const textResult = await mammoth.extractRawText({ buffer });\r\n\r\n  // Convert to markdown if requested\r\n  let markdown = \"\";\r\n  if (options.outputMarkdown) {\r\n    markdown = htmlToMarkdown(htmlResult.value);\r\n  }\r\n\r\n  // Calculate metadata\r\n  const text = textResult.value;\r\n  const wordCount = text\r\n    .split(/\\s+/)\r\n    .filter((word) => word.length > 0).length;\r\n  const characterCount = text.length;\r\n  const paragraphCount = text.split(/\\n\\n+/).filter((p) => p.trim().length > 0)\r\n    .length;\r\n\r\n  // Map messages\r\n  const messages: DOCXMessage[] = htmlResult.messages.map((msg) => ({\r\n    type: msg.type as \"warning\" | \"error\",\r\n    message: msg.message,\r\n    paragraphIndex: (msg as any).paragraphIndex,\r\n  }));\r\n\r\n  return {\r\n    text: textResult.value,\r\n    html: htmlResult.value,\r\n    markdown: markdown || htmlToMarkdown(htmlResult.value),\r\n    messages,\r\n    metadata: {\r\n      wordCount,\r\n      characterCount,\r\n      paragraphCount,\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * Convert HTML to basic markdown\r\n */\r\nfunction htmlToMarkdown(html: string): string {\r\n  let markdown = html;\r\n\r\n  // Headers\r\n  markdown = markdown.replace(/<h1[^>]*>(.*?)<\\/h1>/gi, \"# $1\\n\\n\");\r\n  markdown = markdown.replace(/<h2[^>]*>(.*?)<\\/h2>/gi, \"## $1\\n\\n\");\r\n  markdown = markdown.replace(/<h3[^>]*>(.*?)<\\/h3>/gi, \"### $1\\n\\n\");\r\n  markdown = markdown.replace(/<h4[^>]*>(.*?)<\\/h4>/gi, \"#### $1\\n\\n\");\r\n  markdown = markdown.replace(/<h5[^>]*>(.*?)<\\/h5>/gi, \"##### $1\\n\\n\");\r\n  markdown = markdown.replace(/<h6[^>]*>(.*?)<\\/h6>/gi, \"###### $1\\n\\n\");\r\n\r\n  // Bold and italic\r\n  markdown = markdown.replace(/<strong[^>]*>(.*?)<\\/strong>/gi, \"**$1**\");\r\n  markdown = markdown.replace(/<b[^>]*>(.*?)<\\/b>/gi, \"**$1**\");\r\n  markdown = markdown.replace(/<em[^>]*>(.*?)<\\/em>/gi, \"*$1*\");\r\n  markdown = markdown.replace(/<i[^>]*>(.*?)<\\/i>/gi, \"*$1*\");\r\n\r\n  // Links\r\n  markdown = markdown.replace(\r\n    /<a[^>]*href=\"([^\"]*)\"[^>]*>(.*?)<\\/a>/gi,\r\n    \"[$2]($1)\"\r\n  );\r\n\r\n  // Images\r\n  markdown = markdown.replace(\r\n    /<img[^>]*src=\"([^\"]*)\"[^>]*alt=\"([^\"]*)\"[^>]*\\/?>/gi,\r\n    \"![$2]($1)\"\r\n  );\r\n  markdown = markdown.replace(\r\n    /<img[^>]*src=\"([^\"]*)\"[^>]*\\/?>/gi,\r\n    \"![]($1)\"\r\n  );\r\n\r\n  // Lists\r\n  markdown = markdown.replace(/<ul[^>]*>/gi, \"\\n\");\r\n  markdown = markdown.replace(/<\\/ul>/gi, \"\\n\");\r\n  markdown = markdown.replace(/<ol[^>]*>/gi, \"\\n\");\r\n  markdown = markdown.replace(/<\\/ol>/gi, \"\\n\");\r\n  markdown = markdown.replace(/<li[^>]*>(.*?)<\\/li>/gi, \"- $1\\n\");\r\n\r\n  // Paragraphs and line breaks\r\n  markdown = markdown.replace(/<p[^>]*>(.*?)<\\/p>/gi, \"$1\\n\\n\");\r\n  markdown = markdown.replace(/<br[^>]*\\/?>/gi, \"\\n\");\r\n\r\n  // Code\r\n  markdown = markdown.replace(/<code[^>]*>(.*?)<\\/code>/gi, \"`$1`\");\r\n  markdown = markdown.replace(/<pre[^>]*>(.*?)<\\/pre>/gis, \"```\\n$1\\n```\\n\");\r\n\r\n  // Blockquotes\r\n  markdown = markdown.replace(\r\n    /<blockquote[^>]*>(.*?)<\\/blockquote>/gis,\r\n    (match, content) => {\r\n      return content\r\n        .split(\"\\n\")\r\n        .map((line: string) => `> ${line}`)\r\n        .join(\"\\n\");\r\n    }\r\n  );\r\n\r\n  // Tables (basic support)\r\n  markdown = markdown.replace(/<table[^>]*>/gi, \"\\n\");\r\n  markdown = markdown.replace(/<\\/table>/gi, \"\\n\");\r\n  markdown = markdown.replace(/<tr[^>]*>/gi, \"\");\r\n  markdown = markdown.replace(/<\\/tr>/gi, \"|\\n\");\r\n  markdown = markdown.replace(/<th[^>]*>(.*?)<\\/th>/gi, \"| **$1** \");\r\n  markdown = markdown.replace(/<td[^>]*>(.*?)<\\/td>/gi, \"| $1 \");\r\n\r\n  // Horizontal rule\r\n  markdown = markdown.replace(/<hr[^>]*\\/?>/gi, \"\\n---\\n\");\r\n\r\n  // Remove remaining HTML tags\r\n  markdown = markdown.replace(/<[^>]+>/g, \"\");\r\n\r\n  // Decode HTML entities\r\n  markdown = decodeHtmlEntities(markdown);\r\n\r\n  // Clean up whitespace\r\n  markdown = markdown.replace(/\\n{3,}/g, \"\\n\\n\");\r\n  markdown = markdown.trim();\r\n\r\n  return markdown;\r\n}\r\n\r\n/**\r\n * Decode common HTML entities\r\n */\r\nfunction decodeHtmlEntities(text: string): string {\r\n  const entities: Record<string, string> = {\r\n    \"&amp;\": \"&\",\r\n    \"&lt;\": \"<\",\r\n    \"&gt;\": \">\",\r\n    \"&quot;\": '\"',\r\n    \"&#39;\": \"'\",\r\n    \"&apos;\": \"'\",\r\n    \"&nbsp;\": \" \",\r\n    \"&ndash;\": \"-\",\r\n    \"&mdash;\": \"--\",\r\n    \"&lsquo;\": \"'\",\r\n    \"&rsquo;\": \"'\",\r\n    \"&ldquo;\": '\"',\r\n    \"&rdquo;\": '\"',\r\n    \"&hellip;\": \"...\",\r\n    \"&copy;\": \"(c)\",\r\n    \"&reg;\": \"(R)\",\r\n    \"&trade;\": \"(TM)\",\r\n  };\r\n\r\n  let result = text;\r\n  for (const [entity, char] of Object.entries(entities)) {\r\n    result = result.replace(new RegExp(entity, \"g\"), char);\r\n  }\r\n\r\n  // Handle numeric entities\r\n  result = result.replace(/&#(\\d+);/g, (match, dec) =>\r\n    String.fromCharCode(parseInt(dec, 10))\r\n  );\r\n  result = result.replace(/&#x([0-9a-fA-F]+);/g, (match, hex) =>\r\n    String.fromCharCode(parseInt(hex, 16))\r\n  );\r\n\r\n  return result;\r\n}\r\n\r\n/**\r\n * Extract plain text from DOCX\r\n */\r\nexport async function extractDOCXText(input: string | Buffer): Promise<string> {\r\n  const result = await parseDOCX(input);\r\n  return result.text;\r\n}\r\n\r\n/**\r\n * Extract markdown from DOCX\r\n */\r\nexport async function extractDOCXMarkdown(\r\n  input: string | Buffer\r\n): Promise<string> {\r\n  const result = await parseDOCX(input, { outputMarkdown: true });\r\n  return result.markdown;\r\n}\r\n\r\n/**\r\n * Check if a file is a valid DOCX\r\n */\r\nexport async function isValidDOCX(input: string | Buffer): Promise<boolean> {\r\n  try {\r\n    let buffer: Buffer;\r\n\r\n    if (typeof input === \"string\") {\r\n      const absolutePath = path.isAbsolute(input) ? input : path.resolve(input);\r\n      buffer = await fs.readFile(absolutePath);\r\n    } else {\r\n      buffer = input;\r\n    }\r\n\r\n    // DOCX is a ZIP file, check for ZIP magic number\r\n    const header = buffer.slice(0, 4);\r\n    if (header[0] !== 0x50 || header[1] !== 0x4b) {\r\n      return false;\r\n    }\r\n\r\n    // Try parsing to verify it's a valid DOCX\r\n    await mammoth.extractRawText({ buffer });\r\n    return true;\r\n  } catch {\r\n    return false;\r\n  }\r\n}\r\n\r\n/**\r\n * Get document statistics without full parsing\r\n */\r\nexport async function getDOCXStats(\r\n  input: string | Buffer\r\n): Promise<DOCXMetadata> {\r\n  const result = await parseDOCX(input);\r\n  return result.metadata;\r\n}\r\n"],"mappings":";AAMA,OAAO,aAAa;AACpB,YAAY,QAAQ;AACpB,YAAY,UAAU;AAqCtB,eAAsB,UACpB,OACA,UAA4B,CAAC,GACH;AAC1B,MAAI;AAEJ,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAM,eAAoB,gBAAW,KAAK,IAAI,QAAa,aAAQ,KAAK;AACxE,aAAS,MAAS,YAAS,YAAY;AAAA,EACzC,OAAO;AACL,aAAS;AAAA,EACX;AAEA,QAAM,iBAAsB,CAAC;AAG7B,MAAI,QAAQ,YAAY,QAAQ,SAAS,SAAS,GAAG;AACnD,mBAAe,WAAW,QAAQ;AAAA,EACpC;AAGA,MAAI,QAAQ,eAAe;AACzB,mBAAe,eAAe,QAAQ,OAAO,WAAW,CAAC,UAAU;AACjE,aAAO,MAAM,KAAK,QAAQ,EAAE,KAAK,CAAC,gBAAgB;AAChD,eAAO;AAAA,UACL,KAAK,QAAQ,MAAM,WAAW,WAAW,WAAW;AAAA,QACtD;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAGA,QAAM,aAAa,MAAM,QAAQ;AAAA,IAC/B,EAAE,OAAO;AAAA,IACT;AAAA,EACF;AAGA,QAAM,aAAa,MAAM,QAAQ,eAAe,EAAE,OAAO,CAAC;AAG1D,MAAI,WAAW;AACf,MAAI,QAAQ,gBAAgB;AAC1B,eAAW,eAAe,WAAW,KAAK;AAAA,EAC5C;AAGA,QAAM,OAAO,WAAW;AACxB,QAAM,YAAY,KACf,MAAM,KAAK,EACX,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC,EAAE;AACrC,QAAM,iBAAiB,KAAK;AAC5B,QAAM,iBAAiB,KAAK,MAAM,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EACzE;AAGH,QAAM,WAA0B,WAAW,SAAS,IAAI,CAAC,SAAS;AAAA,IAChE,MAAM,IAAI;AAAA,IACV,SAAS,IAAI;AAAA,IACb,gBAAiB,IAAY;AAAA,EAC/B,EAAE;AAEF,SAAO;AAAA,IACL,MAAM,WAAW;AAAA,IACjB,MAAM,WAAW;AAAA,IACjB,UAAU,YAAY,eAAe,WAAW,KAAK;AAAA,IACrD;AAAA,IACA,UAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;AAKA,SAAS,eAAe,MAAsB;AAC5C,MAAI,WAAW;AAGf,aAAW,SAAS,QAAQ,0BAA0B,UAAU;AAChE,aAAW,SAAS,QAAQ,0BAA0B,WAAW;AACjE,aAAW,SAAS,QAAQ,0BAA0B,YAAY;AAClE,aAAW,SAAS,QAAQ,0BAA0B,aAAa;AACnE,aAAW,SAAS,QAAQ,0BAA0B,cAAc;AACpE,aAAW,SAAS,QAAQ,0BAA0B,eAAe;AAGrE,aAAW,SAAS,QAAQ,kCAAkC,QAAQ;AACtE,aAAW,SAAS,QAAQ,wBAAwB,QAAQ;AAC5D,aAAW,SAAS,QAAQ,0BAA0B,MAAM;AAC5D,aAAW,SAAS,QAAQ,wBAAwB,MAAM;AAG1D,aAAW,SAAS;AAAA,IAClB;AAAA,IACA;AAAA,EACF;AAGA,aAAW,SAAS;AAAA,IAClB;AAAA,IACA;AAAA,EACF;AACA,aAAW,SAAS;AAAA,IAClB;AAAA,IACA;AAAA,EACF;AAGA,aAAW,SAAS,QAAQ,eAAe,IAAI;AAC/C,aAAW,SAAS,QAAQ,YAAY,IAAI;AAC5C,aAAW,SAAS,QAAQ,eAAe,IAAI;AAC/C,aAAW,SAAS,QAAQ,YAAY,IAAI;AAC5C,aAAW,SAAS,QAAQ,0BAA0B,QAAQ;AAG9D,aAAW,SAAS,QAAQ,wBAAwB,QAAQ;AAC5D,aAAW,SAAS,QAAQ,kBAAkB,IAAI;AAGlD,aAAW,SAAS,QAAQ,8BAA8B,MAAM;AAChE,aAAW,SAAS,QAAQ,6BAA6B,gBAAgB;AAGzE,aAAW,SAAS;AAAA,IAClB;AAAA,IACA,CAAC,OAAO,YAAY;AAClB,aAAO,QACJ,MAAM,IAAI,EACV,IAAI,CAAC,SAAiB,KAAK,IAAI,EAAE,EACjC,KAAK,IAAI;AAAA,IACd;AAAA,EACF;AAGA,aAAW,SAAS,QAAQ,kBAAkB,IAAI;AAClD,aAAW,SAAS,QAAQ,eAAe,IAAI;AAC/C,aAAW,SAAS,QAAQ,eAAe,EAAE;AAC7C,aAAW,SAAS,QAAQ,YAAY,KAAK;AAC7C,aAAW,SAAS,QAAQ,0BAA0B,WAAW;AACjE,aAAW,SAAS,QAAQ,0BAA0B,OAAO;AAG7D,aAAW,SAAS,QAAQ,kBAAkB,SAAS;AAGvD,aAAW,SAAS,QAAQ,YAAY,EAAE;AAG1C,aAAW,mBAAmB,QAAQ;AAGtC,aAAW,SAAS,QAAQ,WAAW,MAAM;AAC7C,aAAW,SAAS,KAAK;AAEzB,SAAO;AACT;AAKA,SAAS,mBAAmB,MAAsB;AAChD,QAAM,WAAmC;AAAA,IACvC,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,SAAS;AAAA,IACT,UAAU;AAAA,IACV,UAAU;AAAA,IACV,WAAW;AAAA,IACX,WAAW;AAAA,IACX,WAAW;AAAA,IACX,WAAW;AAAA,IACX,WAAW;AAAA,IACX,WAAW;AAAA,IACX,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,SAAS;AAAA,IACT,WAAW;AAAA,EACb;AAEA,MAAI,SAAS;AACb,aAAW,CAAC,QAAQ,IAAI,KAAK,OAAO,QAAQ,QAAQ,GAAG;AACrD,aAAS,OAAO,QAAQ,IAAI,OAAO,QAAQ,GAAG,GAAG,IAAI;AAAA,EACvD;AAGA,WAAS,OAAO;AAAA,IAAQ;AAAA,IAAa,CAAC,OAAO,QAC3C,OAAO,aAAa,SAAS,KAAK,EAAE,CAAC;AAAA,EACvC;AACA,WAAS,OAAO;AAAA,IAAQ;AAAA,IAAuB,CAAC,OAAO,QACrD,OAAO,aAAa,SAAS,KAAK,EAAE,CAAC;AAAA,EACvC;AAEA,SAAO;AACT;AAKA,eAAsB,gBAAgB,OAAyC;AAC7E,QAAM,SAAS,MAAM,UAAU,KAAK;AACpC,SAAO,OAAO;AAChB;AAKA,eAAsB,oBACpB,OACiB;AACjB,QAAM,SAAS,MAAM,UAAU,OAAO,EAAE,gBAAgB,KAAK,CAAC;AAC9D,SAAO,OAAO;AAChB;AAKA,eAAsB,YAAY,OAA0C;AAC1E,MAAI;AACF,QAAI;AAEJ,QAAI,OAAO,UAAU,UAAU;AAC7B,YAAM,eAAoB,gBAAW,KAAK,IAAI,QAAa,aAAQ,KAAK;AACxE,eAAS,MAAS,YAAS,YAAY;AAAA,IACzC,OAAO;AACL,eAAS;AAAA,IACX;AAGA,UAAM,SAAS,OAAO,MAAM,GAAG,CAAC;AAChC,QAAI,OAAO,CAAC,MAAM,MAAQ,OAAO,CAAC,MAAM,IAAM;AAC5C,aAAO;AAAA,IACT;AAGA,UAAM,QAAQ,eAAe,EAAE,OAAO,CAAC;AACvC,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAKA,eAAsB,aACpB,OACuB;AACvB,QAAM,SAAS,MAAM,UAAU,KAAK;AACpC,SAAO,OAAO;AAChB;","names":[]}

package/dist/chunk-6ZNCY2GI.js

@@ -0,0 +1,418 @@
+import {
+  LinearRegression
+} from "./chunk-WZAH34TG.js";
+
+// src/core/brain/router.ts
+var MODEL_TIERS = {
+  fast: {
+    tier: "fast",
+    model: "claude-haiku-4-5-20251001",
+    provider: "anthropic",
+    label: "Haiku 4.5",
+    maxTokens: 2048,
+    costPerMInputToken: 0.8,
+    costPerMOutputToken: 4
+  },
+  balanced: {
+    tier: "balanced",
+    model: "claude-sonnet-4-20250514",
+    provider: "anthropic",
+    label: "Sonnet 4",
+    maxTokens: 4096,
+    costPerMInputToken: 3,
+    costPerMOutputToken: 15
+  },
+  powerful: {
+    tier: "powerful",
+    model: "claude-opus-4-20250514",
+    provider: "anthropic",
+    label: "Opus 4",
+    maxTokens: 8192,
+    costPerMInputToken: 15,
+    costPerMOutputToken: 75
+  }
+};
+var FAST_PATTERNS = [
+  // Greetings and acknowledgments
+  /^(hi|hello|hey|thanks|thank you|ok|okay|yes|no|sure|got it|np|ty|thx|gm|gn)\b/i,
+  // Simple questions
+  /^(what time|what date|what day|how are you|who are you)\b/i,
+  // Short commands
+  /^(remind me|set timer|play|pause|stop|next|skip|mute|unmute)\b/i,
+  // Status checks
+  /^(status|check|ping|health|uptime)\b/i,
+  // Single-word queries
+  /^\w+[?!.]?$/i
+];
+var POWERFUL_PATTERNS = [
+  // Mathematical/formal reasoning
+  /\b(prove|theorem|derive|lemma|formal proof|mathematical induction)\b/i,
+  // Deep analysis
+  /\b(comprehensive analysis|in-depth|systematic review|research paper)\b/i,
+  // Complex coding tasks
+  /\b(architect|design pattern|refactor.{0,20}entire|rewrite.{0,20}from|full implementation)\b/i,
+  // Multi-step planning
+  /\b(step.by.step plan|detailed strategy|long.term plan|roadmap|proposal)\b/i,
+  // Compare/contrast
+  /\b(compare and contrast|pros and cons|trade.?offs|evaluate.{0,20}options)\b/i,
+  // Long-form writing
+  /\b(write.{0,15}essay|write.{0,15}report|write.{0,15}article|draft.{0,15}document)\b/i,
+  // Legal/medical/financial analysis
+  /\b(legal analysis|medical review|financial analysis|risk assessment)\b/i
+];
+var COMPLEX_TOOLS = /* @__PURE__ */ new Set([
+  "execute_command",
+  "write_file",
+  "generate_document",
+  "generate_spreadsheet",
+  "generate_chart",
+  "code_review",
+  "spawn_agent",
+  "create_workflow",
+  "analyze_image"
+]);
+var SIMPLE_TOOLS = /* @__PURE__ */ new Set([
+  "get_time",
+  "get_weather",
+  "search_web",
+  "read_file",
+  "list_files",
+  "get_system_info",
+  "get_calendar_events"
+]);
+var ModelRouter = class {
+  enabled;
+  defaultTier;
+  opusEnabled;
+  // Routing statistics
+  stats = { fast: 0, balanced: 0, powerful: 0 };
+  constructor(options) {
+    this.enabled = options?.enabled ?? true;
+    this.defaultTier = options?.defaultTier ?? "balanced";
+    this.opusEnabled = options?.opusEnabled ?? false;
+  }
+  /**
+   * Analyze message complexity and return recommended model config
+   */
+  routeMessage(message, context) {
+    if (!this.enabled) {
+      this.stats[this.defaultTier]++;
+      return MODEL_TIERS[this.defaultTier];
+    }
+    const tier = this.classifyComplexity(message, context);
+    this.stats[tier]++;
+    return MODEL_TIERS[tier];
+  }
+  /**
+   * Classify message complexity into a model tier
+   */
+  classifyComplexity(message, context) {
+    if (context?.thinkingLevel === "extended" && this.opusEnabled) {
+      return "powerful";
+    }
+    const trimmed = message.trim();
+    if (trimmed.length < 15) {
+      return "fast";
+    }
+    for (const pattern of FAST_PATTERNS) {
+      if (pattern.test(trimmed)) {
+        return "fast";
+      }
+    }
+    if (this.opusEnabled) {
+      for (const pattern of POWERFUL_PATTERNS) {
+        if (pattern.test(trimmed)) {
+          return "powerful";
+        }
+      }
+    }
+    if (context?.toolsRequested) {
+      const hasComplexTools = context.toolsRequested.some((t) => COMPLEX_TOOLS.has(t));
+      const hasOnlySimpleTools = context.toolsRequested.every((t) => SIMPLE_TOOLS.has(t));
+      if (hasComplexTools && this.opusEnabled) {
+        return "powerful";
+      }
+      if (hasOnlySimpleTools && context.toolsRequested.length <= 2) {
+        return "fast";
+      }
+    }
+    const wordCount = trimmed.split(/\s+/).length;
+    if (wordCount < 8) {
+      return "fast";
+    }
+    if (trimmed.length > 500 && this.opusEnabled) {
+      return "powerful";
+    }
+    const result = this.defaultTier;
+    if (context?.appTypeTier) {
+      const tierOrder = { fast: 0, balanced: 1, powerful: 2 };
+      if (tierOrder[context.appTypeTier] > tierOrder[result]) {
+        return context.appTypeTier;
+      }
+    }
+    return result;
+  }
+  /**
+   * Estimate cost for a given tier and token counts
+   */
+  estimateCost(tier, inputTokens, outputTokens) {
+    const config = MODEL_TIERS[tier];
+    return inputTokens / 1e6 * config.costPerMInputToken + outputTokens / 1e6 * config.costPerMOutputToken;
+  }
+  /**
+   * Get info about a model tier
+   */
+  getTierInfo(tier) {
+    return MODEL_TIERS[tier];
+  }
+  /**
+   * Get routing statistics
+   */
+  getStats() {
+    const total = this.stats.fast + this.stats.balanced + this.stats.powerful;
+    return { ...this.stats, total };
+  }
+  /**
+   * Reset routing statistics
+   */
+  resetStats() {
+    this.stats = { fast: 0, balanced: 0, powerful: 0 };
+  }
+  /**
+   * Get estimated cost savings vs always using balanced
+   */
+  getEstimatedSavings(avgInputTokens = 1e3, avgOutputTokens = 500) {
+    const stats = this.getStats();
+    if (stats.total === 0) return { withRouting: 0, withoutRouting: 0, savings: 0, savingsPercent: 0 };
+    const withRouting = this.estimateCost("fast", avgInputTokens * stats.fast, avgOutputTokens * stats.fast) + this.estimateCost("balanced", avgInputTokens * stats.balanced, avgOutputTokens * stats.balanced) + this.estimateCost("powerful", avgInputTokens * stats.powerful, avgOutputTokens * stats.powerful);
+    const withoutRouting = this.estimateCost("balanced", avgInputTokens * stats.total, avgOutputTokens * stats.total);
+    const savings = withoutRouting - withRouting;
+    const savingsPercent = withoutRouting > 0 ? savings / withoutRouting * 100 : 0;
+    return { withRouting, withoutRouting, savings, savingsPercent };
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  isOpusEnabled() {
+    return this.opusEnabled;
+  }
+  setOpusEnabled(enabled) {
+    this.opusEnabled = enabled;
+  }
+};
+var modelRouter = new ModelRouter();
+
+// src/core/observability/cost-tracker.ts
+var CostTracker = class {
+  records = [];
+  maxRecords = 1e4;
+  // Keep last 10K records in memory
+  dbLoaded = false;
+  /**
+   * Load historical cost records from the database on startup
+   */
+  async loadFromDb() {
+    if (this.dbLoaded) return;
+    try {
+      const { db } = await import("./db-I7MNG6CL.js");
+      const { metrics } = await import("./schema-ETY7L2VA.js");
+      const { eq, desc } = await import("drizzle-orm");
+      const rows = await db.select().from(metrics).where(eq(metrics.name, "token_cost")).orderBy(desc(metrics.timestamp)).limit(this.maxRecords);
+      for (const row of rows.reverse()) {
+        const tags = row.tags || {};
+        this.records.push({
+          tier: tags.tier || "balanced",
+          inputTokens: parseInt(tags.inputTokens || "0"),
+          outputTokens: parseInt(tags.outputTokens || "0"),
+          cost: (row.value || 0) / 1e6,
+          // stored as micro-dollars
+          timestamp: new Date(row.timestamp).getTime()
+        });
+      }
+      this.dbLoaded = true;
+      if (this.records.length > 0) {
+        console.log(`[CostTracker] Loaded ${this.records.length} historical records from DB`);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Record token usage for a request
+   */
+  recordUsage(tier, inputTokens, outputTokens) {
+    const tierConfig = MODEL_TIERS[tier] || MODEL_TIERS.balanced;
+    const inputCost = inputTokens / 1e6 * tierConfig.costPerMInputToken;
+    const outputCost = outputTokens / 1e6 * tierConfig.costPerMOutputToken;
+    const totalCost = inputCost + outputCost;
+    const record = {
+      tier,
+      inputTokens,
+      outputTokens,
+      cost: totalCost,
+      timestamp: Date.now()
+    };
+    this.records.push(record);
+    if (this.records.length > this.maxRecords) {
+      this.records = this.records.slice(-this.maxRecords);
+    }
+    this.persistRecord(record).catch(() => {
+    });
+    return record;
+  }
+  async persistRecord(record) {
+    try {
+      const { db } = await import("./db-I7MNG6CL.js");
+      const { metrics } = await import("./schema-ETY7L2VA.js");
+      await db.insert(metrics).values({
+        name: "token_cost",
+        value: Math.round(record.cost * 1e6),
+        // store as micro-dollars for integer precision
+        unit: "microdollars",
+        tags: {
+          tier: record.tier,
+          inputTokens: String(record.inputTokens),
+          outputTokens: String(record.outputTokens)
+        }
+      });
+    } catch {
+    }
+  }
+  /**
+   * Get cost summary for a time range
+   */
+  getCostSummary(since, until) {
+    const start = since || 0;
+    const end = until || Date.now();
+    const filtered = this.records.filter(
+      (r) => r.timestamp >= start && r.timestamp <= end
+    );
+    const costByTier = {};
+    let totalCost = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    for (const record of filtered) {
+      totalCost += record.cost;
+      totalInputTokens += record.inputTokens;
+      totalOutputTokens += record.outputTokens;
+      costByTier[record.tier] = (costByTier[record.tier] || 0) + record.cost;
+    }
+    return {
+      totalCost,
+      costByTier,
+      totalInputTokens,
+      totalOutputTokens,
+      requestCount: filtered.length,
+      timeRange: { start, end }
+    };
+  }
+  /**
+   * Get average cost per interaction
+   */
+  getCostPerInteraction() {
+    if (this.records.length === 0) return 0;
+    const total = this.records.reduce((sum, r) => sum + r.cost, 0);
+    return total / this.records.length;
+  }
+  /**
+   * Get estimated monthly cost using Linear Regression forecasting.
+   * Fits a regression on daily cost totals from the last 14 days, then projects 30 days.
+   */
+  getEstimatedMonthlyCost() {
+    if (this.records.length < 2) return 0;
+    const now = Date.now();
+    const dailyCosts = this.getDailyCostHistory(14);
+    if (dailyCosts.length < 2) {
+      const oneDayAgo = now - 864e5;
+      const recentRecords = this.records.filter((r) => r.timestamp >= oneDayAgo);
+      if (recentRecords.length === 0) return 0;
+      const dailyCost = recentRecords.reduce((sum, r) => sum + r.cost, 0);
+      return dailyCost * 30;
+    }
+    const predictions = LinearRegression.forecast(dailyCosts, 30);
+    return predictions.reduce((sum, p) => sum + Math.max(0, p.value), 0);
+  }
+  /**
+   * Detect spending trend: up, down, or flat.
+   */
+  getCostTrend() {
+    const dailyCosts = this.getDailyCostHistory(14);
+    if (dailyCosts.length < 3) {
+      return { direction: "flat", strength: 0, dailyChange: 0 };
+    }
+    const trend = LinearRegression.detectTrend(dailyCosts);
+    return {
+      direction: trend.direction,
+      strength: trend.strength,
+      dailyChange: trend.slopePerUnit
+    };
+  }
+  /**
+   * Get forecast with confidence intervals for the next N days.
+   */
+  getForecast(daysAhead = 7) {
+    const dailyCosts = this.getDailyCostHistory(14);
+    if (dailyCosts.length < 2) return [];
+    const predictions = LinearRegression.forecast(dailyCosts, daysAhead);
+    return predictions.map((p, i) => ({
+      day: i + 1,
+      predicted: Math.max(0, p.value),
+      lower: Math.max(0, p.lower95),
+      upper: Math.max(0, p.upper95)
+    }));
+  }
+  /**
+   * Get daily cost totals for the last N days.
+   */
+  getDailyCostHistory(days) {
+    const now = Date.now();
+    const msPerDay = 864e5;
+    const dailyCosts = [];
+    for (let d = days - 1; d >= 0; d--) {
+      const dayStart = now - (d + 1) * msPerDay;
+      const dayEnd = now - d * msPerDay;
+      const dayCost = this.records.filter((r) => r.timestamp >= dayStart && r.timestamp < dayEnd).reduce((sum, r) => sum + r.cost, 0);
+      dailyCosts.push(dayCost);
+    }
+    return dailyCosts;
+  }
+  /**
+   * Get cost per million tokens for a tier
+   */
+  getCostPerMillionTokens(tier) {
+    const config = MODEL_TIERS[tier] || MODEL_TIERS.balanced;
+    return {
+      input: config.costPerMInputToken,
+      output: config.costPerMOutputToken
+    };
+  }
+  /**
+   * Get all records (for debugging/export)
+   */
+  getRecords() {
+    return [...this.records];
+  }
+  /**
+   * Get record count
+   */
+  getRecordCount() {
+    return this.records.length;
+  }
+  /**
+   * Clear all records
+   */
+  reset() {
+    this.records = [];
+  }
+};
+var costTracker = new CostTracker();
+
+export {
+  MODEL_TIERS,
+  modelRouter,
+  CostTracker,
+  costTracker
+};
+//# sourceMappingURL=chunk-6ZNCY2GI.js.map