opensentinel 3.1.1 → 3.6.1

package/dist/chunk-ZIYTHUM5.js

@@ -0,0 +1,457 @@
+// src/integrations/documents/chunker.ts
+var DEFAULT_OPTIONS = {
+  chunkSize: 1e3,
+  chunkOverlap: 200,
+  minChunkSize: 100,
+  maxChunkSize: 2e3,
+  respectSentences: true,
+  respectParagraphs: true,
+  preserveSections: true,
+  strategy: "semantic"
+};
+function chunkText(text, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  if (!text || text.trim().length === 0) {
+    return [];
+  }
+  switch (opts.strategy) {
+    case "fixed":
+      return fixedSizeChunking(text, opts);
+    case "sentence":
+      return sentenceChunking(text, opts);
+    case "paragraph":
+      return paragraphChunking(text, opts);
+    case "recursive":
+      return recursiveChunking(text, opts);
+    case "semantic":
+    default:
+      return semanticChunking(text, opts);
+  }
+}
+function fixedSizeChunking(text, opts) {
+  const chunks = [];
+  let startOffset = 0;
+  let index = 0;
+  while (startOffset < text.length) {
+    let endOffset = Math.min(startOffset + opts.chunkSize, text.length);
+    if (endOffset - startOffset > opts.maxChunkSize) {
+      endOffset = startOffset + opts.maxChunkSize;
+    }
+    const content = text.slice(startOffset, endOffset);
+    const hasOverlapFromPrevious = index > 0;
+    chunks.push(createChunk(index, content, startOffset, endOffset, {
+      startsAtSentence: false,
+      endsAtSentence: false,
+      hasOverlapFromPrevious,
+      hasOverlapToNext: endOffset < text.length
+    }));
+    const nextStart = endOffset - opts.chunkOverlap;
+    startOffset = Math.max(nextStart, startOffset + opts.minChunkSize);
+    index++;
+  }
+  return chunks;
+}
+function sentenceChunking(text, opts) {
+  const sentences = splitIntoSentences(text);
+  const chunks = [];
+  let currentChunk = "";
+  let currentStart = 0;
+  let index = 0;
+  let textOffset = 0;
+  for (let i = 0; i < sentences.length; i++) {
+    const sentence = sentences[i];
+    const potentialChunk = currentChunk + sentence;
+    if (potentialChunk.length > opts.maxChunkSize && currentChunk.length > 0) {
+      const endOffset = textOffset;
+      chunks.push(createChunk(index, currentChunk.trim(), currentStart, endOffset, {
+        startsAtSentence: true,
+        endsAtSentence: true,
+        hasOverlapFromPrevious: index > 0,
+        hasOverlapToNext: true
+      }));
+      const overlapSentences = getOverlapSentences(
+        sentences.slice(0, i),
+        opts.chunkOverlap
+      );
+      currentChunk = overlapSentences + sentence;
+      currentStart = endOffset - overlapSentences.length;
+      index++;
+    } else if (potentialChunk.length >= opts.chunkSize && currentChunk.length >= opts.minChunkSize) {
+      currentChunk = potentialChunk;
+      textOffset += sentence.length;
+      const endOffset = textOffset;
+      chunks.push(createChunk(index, currentChunk.trim(), currentStart, endOffset, {
+        startsAtSentence: true,
+        endsAtSentence: true,
+        hasOverlapFromPrevious: index > 0,
+        hasOverlapToNext: i < sentences.length - 1
+      }));
+      const overlapSentences = getOverlapSentences(
+        sentences.slice(0, i + 1),
+        opts.chunkOverlap
+      );
+      currentChunk = overlapSentences;
+      currentStart = endOffset - overlapSentences.length;
+      index++;
+    } else {
+      currentChunk = potentialChunk;
+      textOffset += sentence.length;
+    }
+  }
+  if (currentChunk.trim().length > 0) {
+    chunks.push(createChunk(index, currentChunk.trim(), currentStart, text.length, {
+      startsAtSentence: true,
+      endsAtSentence: true,
+      hasOverlapFromPrevious: index > 0,
+      hasOverlapToNext: false
+    }));
+  }
+  return chunks;
+}
+function paragraphChunking(text, opts) {
+  const paragraphs = text.split(/\n\s*\n/).filter((p) => p.trim().length > 0);
+  const chunks = [];
+  let currentChunk = "";
+  let currentStart = 0;
+  let index = 0;
+  let textOffset = 0;
+  let paragraphNumber = 0;
+  for (let i = 0; i < paragraphs.length; i++) {
+    const paragraph = paragraphs[i].trim() + "\n\n";
+    paragraphNumber++;
+    const potentialChunk = currentChunk + paragraph;
+    if (potentialChunk.length > opts.maxChunkSize && currentChunk.length > 0) {
+      const endOffset = textOffset;
+      chunks.push(createChunk(index, currentChunk.trim(), currentStart, endOffset, {
+        paragraphNumber: paragraphNumber - 1,
+        startsAtSentence: true,
+        endsAtSentence: true,
+        hasOverlapFromPrevious: index > 0,
+        hasOverlapToNext: true
+      }));
+      currentChunk = paragraph;
+      currentStart = endOffset;
+      index++;
+    } else if (potentialChunk.length >= opts.chunkSize) {
+      currentChunk = potentialChunk;
+      textOffset = text.indexOf(paragraph, textOffset) + paragraph.length;
+      chunks.push(createChunk(index, currentChunk.trim(), currentStart, textOffset, {
+        paragraphNumber,
+        startsAtSentence: true,
+        endsAtSentence: true,
+        hasOverlapFromPrevious: index > 0,
+        hasOverlapToNext: i < paragraphs.length - 1
+      }));
+      currentChunk = "";
+      currentStart = textOffset;
+      index++;
+    } else {
+      currentChunk = potentialChunk;
+      const idx = text.indexOf(paragraph.trim(), textOffset);
+      if (idx >= 0) {
+        textOffset = idx + paragraph.trim().length;
+      }
+    }
+  }
+  if (currentChunk.trim().length > 0) {
+    chunks.push(createChunk(index, currentChunk.trim(), currentStart, text.length, {
+      paragraphNumber,
+      startsAtSentence: true,
+      endsAtSentence: true,
+      hasOverlapFromPrevious: index > 0,
+      hasOverlapToNext: false
+    }));
+  }
+  return chunks;
+}
+function recursiveChunking(text, opts) {
+  const separators = [
+    "\n\n\n",
+    // Multiple blank lines
+    "\n\n",
+    // Paragraph break
+    "\n",
+    // Line break
+    ". ",
+    // Sentence break
+    ", ",
+    // Clause break
+    " ",
+    // Word break
+    ""
+    // Character break (fallback)
+  ];
+  return recursiveChunkingSplit(text, separators, opts, 0);
+}
+function recursiveChunkingSplit(text, separators, opts, startOffset) {
+  if (text.length <= opts.chunkSize) {
+    return [
+      createChunk(0, text, startOffset, startOffset + text.length, {
+        startsAtSentence: true,
+        endsAtSentence: true,
+        hasOverlapFromPrevious: false,
+        hasOverlapToNext: false
+      })
+    ];
+  }
+  const separator = separators[0];
+  const nextSeparators = separators.slice(1);
+  if (separator === "") {
+    return fixedSizeChunking(text, opts);
+  }
+  const splits = text.split(separator);
+  const chunks = [];
+  let currentChunk = "";
+  let currentOffset = startOffset;
+  let chunkIndex = 0;
+  for (let i = 0; i < splits.length; i++) {
+    const split = splits[i];
+    const withSeparator = i < splits.length - 1 ? split + separator : split;
+    const potential = currentChunk + withSeparator;
+    if (potential.length > opts.chunkSize && currentChunk.length > 0) {
+      if (currentChunk.length > opts.maxChunkSize) {
+        const subChunks = recursiveChunkingSplit(
+          currentChunk,
+          nextSeparators,
+          opts,
+          currentOffset
+        );
+        subChunks.forEach((c, idx) => {
+          c.index = chunkIndex + idx;
+        });
+        chunks.push(...subChunks);
+        chunkIndex += subChunks.length;
+      } else {
+        chunks.push(
+          createChunk(chunkIndex, currentChunk.trim(), currentOffset, currentOffset + currentChunk.length, {
+            startsAtSentence: separator.includes("."),
+            endsAtSentence: separator.includes("."),
+            hasOverlapFromPrevious: chunkIndex > 0,
+            hasOverlapToNext: true
+          })
+        );
+        chunkIndex++;
+      }
+      currentOffset += currentChunk.length;
+      currentChunk = withSeparator;
+    } else {
+      currentChunk = potential;
+    }
+  }
+  if (currentChunk.trim().length > 0) {
+    if (currentChunk.length > opts.maxChunkSize) {
+      const subChunks = recursiveChunkingSplit(
+        currentChunk,
+        nextSeparators,
+        opts,
+        currentOffset
+      );
+      subChunks.forEach((c, idx) => {
+        c.index = chunkIndex + idx;
+      });
+      chunks.push(...subChunks);
+    } else {
+      chunks.push(
+        createChunk(chunkIndex, currentChunk.trim(), currentOffset, currentOffset + currentChunk.length, {
+          startsAtSentence: true,
+          endsAtSentence: true,
+          hasOverlapFromPrevious: chunkIndex > 0,
+          hasOverlapToNext: false
+        })
+      );
+    }
+  }
+  return chunks;
+}
+function semanticChunking(text, opts) {
+  const sections = opts.preserveSections ? splitIntoSections(text) : [{ header: void 0, content: text }];
+  const allChunks = [];
+  let globalIndex = 0;
+  let globalOffset = 0;
+  for (const section of sections) {
+    const sectionText = section.content;
+    const paragraphs = sectionText.split(/\n\s*\n/).filter((p) => p.trim().length > 0);
+    let currentChunk = "";
+    let chunkStart = globalOffset;
+    for (let i = 0; i < paragraphs.length; i++) {
+      const paragraph = paragraphs[i].trim();
+      if (currentChunk.length + paragraph.length + 2 > opts.maxChunkSize && currentChunk.length > 0) {
+        allChunks.push(
+          createChunk(globalIndex, currentChunk.trim(), chunkStart, chunkStart + currentChunk.length, {
+            sectionHeader: section.header,
+            startsAtSentence: true,
+            endsAtSentence: true,
+            hasOverlapFromPrevious: globalIndex > 0,
+            hasOverlapToNext: true
+          })
+        );
+        globalIndex++;
+        const overlap = getOverlapText(currentChunk, opts.chunkOverlap);
+        chunkStart = chunkStart + currentChunk.length - overlap.length;
+        currentChunk = overlap + "\n\n" + paragraph;
+      } else if (currentChunk.length + paragraph.length >= opts.chunkSize && currentChunk.length >= opts.minChunkSize) {
+        currentChunk += (currentChunk ? "\n\n" : "") + paragraph;
+        allChunks.push(
+          createChunk(globalIndex, currentChunk.trim(), chunkStart, chunkStart + currentChunk.length, {
+            sectionHeader: section.header,
+            startsAtSentence: true,
+            endsAtSentence: true,
+            hasOverlapFromPrevious: globalIndex > 0,
+            hasOverlapToNext: i < paragraphs.length - 1
+          })
+        );
+        globalIndex++;
+        const overlap = getOverlapText(currentChunk, opts.chunkOverlap);
+        chunkStart = chunkStart + currentChunk.length - overlap.length;
+        currentChunk = overlap;
+      } else {
+        currentChunk += (currentChunk ? "\n\n" : "") + paragraph;
+      }
+    }
+    if (currentChunk.trim().length > 0) {
+      allChunks.push(
+        createChunk(globalIndex, currentChunk.trim(), chunkStart, chunkStart + currentChunk.length, {
+          sectionHeader: section.header,
+          startsAtSentence: true,
+          endsAtSentence: true,
+          hasOverlapFromPrevious: globalIndex > 0,
+          hasOverlapToNext: false
+        })
+      );
+      globalIndex++;
+    }
+    globalOffset += section.content.length;
+  }
+  return allChunks.map((chunk, idx) => ({
+    ...chunk,
+    index: idx
+  }));
+}
+function splitIntoSections(text) {
+  const headerPattern = /^(#{1,6}\s+.+|[A-Z][A-Za-z\s]+:\s*$|[A-Z][A-Z\s]{3,}$)/gm;
+  const sections = [];
+  let lastIndex = 0;
+  let lastHeader;
+  let match;
+  while ((match = headerPattern.exec(text)) !== null) {
+    if (lastIndex < match.index) {
+      const content = text.slice(lastIndex, match.index);
+      if (content.trim().length > 0) {
+        sections.push({ header: lastHeader, content });
+      }
+    }
+    lastHeader = match[1].replace(/^#+\s*/, "").trim();
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text.length) {
+    const content = text.slice(lastIndex);
+    if (content.trim().length > 0) {
+      sections.push({ header: lastHeader, content });
+    }
+  }
+  if (sections.length === 0) {
+    return [{ header: void 0, content: text }];
+  }
+  return sections;
+}
+function splitIntoSentences(text) {
+  const sentenceEnders = /([.!?]+)\s+(?=[A-Z])/g;
+  const sentences = [];
+  let lastIndex = 0;
+  let match;
+  while ((match = sentenceEnders.exec(text)) !== null) {
+    const endIndex = match.index + match[1].length;
+    sentences.push(text.slice(lastIndex, endIndex + 1));
+    lastIndex = endIndex + 1;
+  }
+  if (lastIndex < text.length) {
+    const remaining = text.slice(lastIndex);
+    if (remaining.trim().length > 0) {
+      sentences.push(remaining);
+    }
+  }
+  return sentences;
+}
+function getOverlapSentences(sentences, targetChars) {
+  let overlap = "";
+  for (let i = sentences.length - 1; i >= 0 && overlap.length < targetChars; i--) {
+    overlap = sentences[i] + overlap;
+  }
+  return overlap;
+}
+function getOverlapText(text, targetChars) {
+  if (text.length <= targetChars) {
+    return text;
+  }
+  const lastPart = text.slice(-targetChars * 1.5);
+  const sentenceMatch = lastPart.match(/[.!?]\s+/);
+  if (sentenceMatch && sentenceMatch.index) {
+    return lastPart.slice(sentenceMatch.index + sentenceMatch[0].length);
+  }
+  const wordMatch = lastPart.match(/\s+/);
+  if (wordMatch && wordMatch.index) {
+    return lastPart.slice(wordMatch.index + wordMatch[0].length);
+  }
+  return text.slice(-targetChars);
+}
+function createChunk(index, content, startOffset, endOffset, metadata) {
+  const wordCount = content.split(/\s+/).filter((w) => w.length > 0).length;
+  return {
+    index,
+    content,
+    startOffset,
+    endOffset,
+    wordCount,
+    tokenEstimate: Math.ceil(content.length / 4),
+    metadata: {
+      startsAtSentence: metadata.startsAtSentence ?? false,
+      endsAtSentence: metadata.endsAtSentence ?? false,
+      hasOverlapFromPrevious: metadata.hasOverlapFromPrevious ?? false,
+      hasOverlapToNext: metadata.hasOverlapToNext ?? false,
+      sectionHeader: metadata.sectionHeader,
+      paragraphNumber: metadata.paragraphNumber
+    }
+  };
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function mergeSmallChunks(chunks, minSize = 100) {
+  if (chunks.length === 0) return [];
+  const merged = [];
+  let current = null;
+  for (const chunk of chunks) {
+    if (!current) {
+      current = { ...chunk };
+      continue;
+    }
+    if (current.content.length < minSize) {
+      current = {
+        ...current,
+        content: current.content + "\n\n" + chunk.content,
+        endOffset: chunk.endOffset,
+        wordCount: current.wordCount + chunk.wordCount,
+        tokenEstimate: current.tokenEstimate + chunk.tokenEstimate,
+        metadata: {
+          ...current.metadata,
+          endsAtSentence: chunk.metadata.endsAtSentence,
+          hasOverlapToNext: chunk.metadata.hasOverlapToNext
+        }
+      };
+    } else {
+      merged.push(current);
+      current = { ...chunk, index: merged.length };
+    }
+  }
+  if (current) {
+    merged.push(current);
+  }
+  return merged;
+}
+
+export {
+  chunkText,
+  estimateTokens,
+  mergeSmallChunks
+};
+//# sourceMappingURL=chunk-ZIYTHUM5.js.map

package/dist/chunk-ZIYTHUM5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/integrations/documents/chunker.ts"],"sourcesContent":["/**\n * Document Chunker for OpenSentinel Document Ingestion\n *\n * Splits documents into semantic chunks suitable for embedding and retrieval.\n */\n\nexport interface Chunk {\n  /** Chunk index within the document */\n  index: number;\n  /** The text content of the chunk */\n  content: string;\n  /** Character offset in original document */\n  startOffset: number;\n  /** Character end offset in original document */\n  endOffset: number;\n  /** Word count in this chunk */\n  wordCount: number;\n  /** Token count estimate (using ~4 chars per token heuristic) */\n  tokenEstimate: number;\n  /** Metadata about the chunk context */\n  metadata: ChunkMetadata;\n}\n\nexport interface ChunkMetadata {\n  /** Section header if detected */\n  sectionHeader?: string;\n  /** Paragraph number if applicable */\n  paragraphNumber?: number;\n  /** Whether chunk starts at a sentence boundary */\n  startsAtSentence: boolean;\n  /** Whether chunk ends at a sentence boundary */\n  endsAtSentence: boolean;\n  /** Whether this chunk has overlap from previous */\n  hasOverlapFromPrevious: boolean;\n  /** Whether this chunk has overlap to next */\n  hasOverlapToNext: boolean;\n}\n\nexport interface ChunkerOptions {\n  /** Target chunk size in characters (default: 1000) */\n  chunkSize?: number;\n  /** Overlap between chunks in characters (default: 200) */\n  chunkOverlap?: number;\n  /** Minimum chunk size in characters (default: 100) */\n  minChunkSize?: number;\n  /** Maximum chunk size in characters (default: 2000) */\n  maxChunkSize?: number;\n  /** Prefer splitting at sentence boundaries */\n  respectSentences?: boolean;\n  /** Prefer splitting at paragraph boundaries */\n  respectParagraphs?: boolean;\n  /** Keep section headers with their content */\n  preserveSections?: boolean;\n  /** Split strategy */\n  strategy?: ChunkStrategy;\n}\n\nexport type ChunkStrategy =\n  | \"fixed\" // Fixed size chunks\n  | \"sentence\" // Split on sentence boundaries\n  | \"paragraph\" // Split on paragraph boundaries\n  | \"semantic\" // Combine strategies for best semantic coherence\n  | \"recursive\"; // Recursively split using multiple separators\n\nconst DEFAULT_OPTIONS: Required<ChunkerOptions> = {\n  chunkSize: 1000,\n  chunkOverlap: 200,\n  minChunkSize: 100,\n  maxChunkSize: 2000,\n  respectSentences: true,\n  respectParagraphs: true,\n  preserveSections: true,\n  strategy: \"semantic\",\n};\n\n/**\n * Split text into semantic chunks\n */\nexport function chunkText(text: string, options: ChunkerOptions = {}): Chunk[] {\n  const opts = { ...DEFAULT_OPTIONS, ...options };\n\n  if (!text || text.trim().length === 0) {\n    return [];\n  }\n\n  switch (opts.strategy) {\n    case \"fixed\":\n      return fixedSizeChunking(text, opts);\n    case \"sentence\":\n      return sentenceChunking(text, opts);\n    case \"paragraph\":\n      return paragraphChunking(text, opts);\n    case \"recursive\":\n      return recursiveChunking(text, opts);\n    case \"semantic\":\n    default:\n      return semanticChunking(text, opts);\n  }\n}\n\n/**\n * Fixed-size chunking with overlap\n */\nfunction fixedSizeChunking(\n  text: string,\n  opts: Required<ChunkerOptions>\n): Chunk[] {\n  const chunks: Chunk[] = [];\n  let startOffset = 0;\n  let index = 0;\n\n  while (startOffset < text.length) {\n    let endOffset = Math.min(startOffset + opts.chunkSize, text.length);\n\n    // Adjust to respect max chunk size\n    if (endOffset - startOffset > opts.maxChunkSize) {\n      endOffset = startOffset + opts.maxChunkSize;\n    }\n\n    const content = text.slice(startOffset, endOffset);\n    const hasOverlapFromPrevious = index > 0;\n\n    chunks.push(createChunk(index, content, startOffset, endOffset, {\n      startsAtSentence: false,\n      endsAtSentence: false,\n      hasOverlapFromPrevious,\n      hasOverlapToNext: endOffset < text.length,\n    }));\n\n    // Move start position with overlap\n    const nextStart = endOffset - opts.chunkOverlap;\n    startOffset = Math.max(nextStart, startOffset + opts.minChunkSize);\n    index++;\n  }\n\n  return chunks;\n}\n\n/**\n * Sentence-based chunking\n */\nfunction sentenceChunking(\n  text: string,\n  opts: Required<ChunkerOptions>\n): Chunk[] {\n  const sentences = splitIntoSentences(text);\n  const chunks: Chunk[] = [];\n  let currentChunk = \"\";\n  let currentStart = 0;\n  let index = 0;\n  let textOffset = 0;\n\n  for (let i = 0; i < sentences.length; i++) {\n    const sentence = sentences[i];\n    const potentialChunk = currentChunk + sentence;\n\n    if (potentialChunk.length > opts.maxChunkSize && currentChunk.length > 0) {\n      // Current chunk is full, save it\n      const endOffset = textOffset;\n      chunks.push(createChunk(index, currentChunk.trim(), currentStart, endOffset, {\n        startsAtSentence: true,\n        endsAtSentence: true,\n        hasOverlapFromPrevious: index > 0,\n        hasOverlapToNext: true,\n      }));\n\n      // Start new chunk with overlap\n      const overlapSentences = getOverlapSentences(\n        sentences.slice(0, i),\n        opts.chunkOverlap\n      );\n      currentChunk = overlapSentences + sentence;\n      currentStart = endOffset - overlapSentences.length;\n      index++;\n    } else if (potentialChunk.length >= opts.chunkSize && currentChunk.length >= opts.minChunkSize) {\n      // Reached target size\n      currentChunk = potentialChunk;\n      textOffset += sentence.length;\n\n      const endOffset = textOffset;\n      chunks.push(createChunk(index, currentChunk.trim(), currentStart, endOffset, {\n        startsAtSentence: true,\n        endsAtSentence: true,\n        hasOverlapFromPrevious: index > 0,\n        hasOverlapToNext: i < sentences.length - 1,\n      }));\n\n      // Start new chunk with overlap\n      const overlapSentences = getOverlapSentences(\n        sentences.slice(0, i + 1),\n        opts.chunkOverlap\n      );\n      currentChunk = overlapSentences;\n      currentStart = endOffset - overlapSentences.length;\n      index++;\n    } else {\n      currentChunk = potentialChunk;\n      textOffset += sentence.length;\n    }\n  }\n\n  // Don't forget the last chunk\n  if (currentChunk.trim().length > 0) {\n    chunks.push(createChunk(index, currentChunk.trim(), currentStart, text.length, {\n      startsAtSentence: true,\n      endsAtSentence: true,\n      hasOverlapFromPrevious: index > 0,\n      hasOverlapToNext: false,\n    }));\n  }\n\n  return chunks;\n}\n\n/**\n * Paragraph-based chunking\n */\nfunction paragraphChunking(\n  text: string,\n  opts: Required<ChunkerOptions>\n): Chunk[] {\n  const paragraphs = text.split(/\\n\\s*\\n/).filter((p) => p.trim().length > 0);\n  const chunks: Chunk[] = [];\n  let currentChunk = \"\";\n  let currentStart = 0;\n  let index = 0;\n  let textOffset = 0;\n  let paragraphNumber = 0;\n\n  for (let i = 0; i < paragraphs.length; i++) {\n    const paragraph = paragraphs[i].trim() + \"\\n\\n\";\n    paragraphNumber++;\n    const potentialChunk = currentChunk + paragraph;\n\n    if (potentialChunk.length > opts.maxChunkSize && currentChunk.length > 0) {\n      // Save current chunk\n      const endOffset = textOffset;\n      chunks.push(createChunk(index, currentChunk.trim(), currentStart, endOffset, {\n        paragraphNumber: paragraphNumber - 1,\n        startsAtSentence: true,\n        endsAtSentence: true,\n        hasOverlapFromPrevious: index > 0,\n        hasOverlapToNext: true,\n      }));\n\n      currentChunk = paragraph;\n      currentStart = endOffset;\n      index++;\n    } else if (potentialChunk.length >= opts.chunkSize) {\n      currentChunk = potentialChunk;\n      textOffset = text.indexOf(paragraph, textOffset) + paragraph.length;\n\n      // Save chunk\n      chunks.push(createChunk(index, currentChunk.trim(), currentStart, textOffset, {\n        paragraphNumber,\n        startsAtSentence: true,\n        endsAtSentence: true,\n        hasOverlapFromPrevious: index > 0,\n        hasOverlapToNext: i < paragraphs.length - 1,\n      }));\n\n      currentChunk = \"\";\n      currentStart = textOffset;\n      index++;\n    } else {\n      currentChunk = potentialChunk;\n      const idx = text.indexOf(paragraph.trim(), textOffset);\n      if (idx >= 0) {\n        textOffset = idx + paragraph.trim().length;\n      }\n    }\n  }\n\n  // Handle last chunk\n  if (currentChunk.trim().length > 0) {\n    chunks.push(createChunk(index, currentChunk.trim(), currentStart, text.length, {\n      paragraphNumber,\n      startsAtSentence: true,\n      endsAtSentence: true,\n      hasOverlapFromPrevious: index > 0,\n      hasOverlapToNext: false,\n    }));\n  }\n\n  return chunks;\n}\n\n/**\n * Recursive chunking using multiple separators\n */\nfunction recursiveChunking(\n  text: string,\n  opts: Required<ChunkerOptions>\n): Chunk[] {\n  const separators = [\n    \"\\n\\n\\n\", // Multiple blank lines\n    \"\\n\\n\", // Paragraph break\n    \"\\n\", // Line break\n    \". \", // Sentence break\n    \", \", // Clause break\n    \" \", // Word break\n    \"\", // Character break (fallback)\n  ];\n\n  return recursiveChunkingSplit(text, separators, opts, 0);\n}\n\nfunction recursiveChunkingSplit(\n  text: string,\n  separators: string[],\n  opts: Required<ChunkerOptions>,\n  startOffset: number\n): Chunk[] {\n  if (text.length <= opts.chunkSize) {\n    return [\n      createChunk(0, text, startOffset, startOffset + text.length, {\n        startsAtSentence: true,\n        endsAtSentence: true,\n        hasOverlapFromPrevious: false,\n        hasOverlapToNext: false,\n      }),\n    ];\n  }\n\n  const separator = separators[0];\n  const nextSeparators = separators.slice(1);\n\n  if (separator === \"\") {\n    // Fallback to fixed size\n    return fixedSizeChunking(text, opts);\n  }\n\n  const splits = text.split(separator);\n  const chunks: Chunk[] = [];\n  let currentChunk = \"\";\n  let currentOffset = startOffset;\n  let chunkIndex = 0;\n\n  for (let i = 0; i < splits.length; i++) {\n    const split = splits[i];\n    const withSeparator = i < splits.length - 1 ? split + separator : split;\n    const potential = currentChunk + withSeparator;\n\n    if (potential.length > opts.chunkSize && currentChunk.length > 0) {\n      // Current chunk is ready\n      if (currentChunk.length > opts.maxChunkSize) {\n        // Too big, recursively split\n        const subChunks = recursiveChunkingSplit(\n          currentChunk,\n          nextSeparators,\n          opts,\n          currentOffset\n        );\n        subChunks.forEach((c, idx) => {\n          c.index = chunkIndex + idx;\n        });\n        chunks.push(...subChunks);\n        chunkIndex += subChunks.length;\n      } else {\n        chunks.push(\n          createChunk(chunkIndex, currentChunk.trim(), currentOffset, currentOffset + currentChunk.length, {\n            startsAtSentence: separator.includes(\".\"),\n            endsAtSentence: separator.includes(\".\"),\n            hasOverlapFromPrevious: chunkIndex > 0,\n            hasOverlapToNext: true,\n          })\n        );\n        chunkIndex++;\n      }\n\n      currentOffset += currentChunk.length;\n      currentChunk = withSeparator;\n    } else {\n      currentChunk = potential;\n    }\n  }\n\n  // Handle final chunk\n  if (currentChunk.trim().length > 0) {\n    if (currentChunk.length > opts.maxChunkSize) {\n      const subChunks = recursiveChunkingSplit(\n        currentChunk,\n        nextSeparators,\n        opts,\n        currentOffset\n      );\n      subChunks.forEach((c, idx) => {\n        c.index = chunkIndex + idx;\n      });\n      chunks.push(...subChunks);\n    } else {\n      chunks.push(\n        createChunk(chunkIndex, currentChunk.trim(), currentOffset, currentOffset + currentChunk.length, {\n          startsAtSentence: true,\n          endsAtSentence: true,\n          hasOverlapFromPrevious: chunkIndex > 0,\n          hasOverlapToNext: false,\n        })\n      );\n    }\n  }\n\n  return chunks;\n}\n\n/**\n * Semantic chunking - combines strategies for best results\n */\nfunction semanticChunking(\n  text: string,\n  opts: Required<ChunkerOptions>\n): Chunk[] {\n  // First, identify sections by headers\n  const sections = opts.preserveSections\n    ? splitIntoSections(text)\n    : [{ header: undefined, content: text }];\n\n  const allChunks: Chunk[] = [];\n  let globalIndex = 0;\n  let globalOffset = 0;\n\n  for (const section of sections) {\n    const sectionText = section.content;\n\n    // Use paragraph-based chunking within sections\n    const paragraphs = sectionText\n      .split(/\\n\\s*\\n/)\n      .filter((p) => p.trim().length > 0);\n\n    let currentChunk = \"\";\n    let chunkStart = globalOffset;\n\n    for (let i = 0; i < paragraphs.length; i++) {\n      const paragraph = paragraphs[i].trim();\n\n      // If adding this paragraph exceeds max size\n      if (\n        currentChunk.length + paragraph.length + 2 > opts.maxChunkSize &&\n        currentChunk.length > 0\n      ) {\n        // Save current chunk\n        allChunks.push(\n          createChunk(globalIndex, currentChunk.trim(), chunkStart, chunkStart + currentChunk.length, {\n            sectionHeader: section.header,\n            startsAtSentence: true,\n            endsAtSentence: true,\n            hasOverlapFromPrevious: globalIndex > 0,\n            hasOverlapToNext: true,\n          })\n        );\n        globalIndex++;\n\n        // Add overlap\n        const overlap = getOverlapText(currentChunk, opts.chunkOverlap);\n        chunkStart = chunkStart + currentChunk.length - overlap.length;\n        currentChunk = overlap + \"\\n\\n\" + paragraph;\n      } else if (\n        currentChunk.length + paragraph.length >= opts.chunkSize &&\n        currentChunk.length >= opts.minChunkSize\n      ) {\n        // Target size reached\n        currentChunk += (currentChunk ? \"\\n\\n\" : \"\") + paragraph;\n\n        allChunks.push(\n          createChunk(globalIndex, currentChunk.trim(), chunkStart, chunkStart + currentChunk.length, {\n            sectionHeader: section.header,\n            startsAtSentence: true,\n            endsAtSentence: true,\n            hasOverlapFromPrevious: globalIndex > 0,\n            hasOverlapToNext: i < paragraphs.length - 1,\n          })\n        );\n        globalIndex++;\n\n        // Add overlap for next chunk\n        const overlap = getOverlapText(currentChunk, opts.chunkOverlap);\n        chunkStart = chunkStart + currentChunk.length - overlap.length;\n        currentChunk = overlap;\n      } else {\n        currentChunk += (currentChunk ? \"\\n\\n\" : \"\") + paragraph;\n      }\n    }\n\n    // Save remaining content\n    if (currentChunk.trim().length > 0) {\n      allChunks.push(\n        createChunk(globalIndex, currentChunk.trim(), chunkStart, chunkStart + currentChunk.length, {\n          sectionHeader: section.header,\n          startsAtSentence: true,\n          endsAtSentence: true,\n          hasOverlapFromPrevious: globalIndex > 0,\n          hasOverlapToNext: false,\n        })\n      );\n      globalIndex++;\n    }\n\n    globalOffset += section.content.length;\n  }\n\n  // Renumber indices\n  return allChunks.map((chunk, idx) => ({\n    ...chunk,\n    index: idx,\n  }));\n}\n\n/**\n * Split text into sections by headers\n */\nfunction splitIntoSections(\n  text: string\n): Array<{ header: string | undefined; content: string }> {\n  // Match markdown headers and other common section patterns\n  const headerPattern = /^(#{1,6}\\s+.+|[A-Z][A-Za-z\\s]+:\\s*$|[A-Z][A-Z\\s]{3,}$)/gm;\n\n  const sections: Array<{ header: string | undefined; content: string }> = [];\n  let lastIndex = 0;\n  let lastHeader: string | undefined;\n\n  let match;\n  while ((match = headerPattern.exec(text)) !== null) {\n    // Save previous section\n    if (lastIndex < match.index) {\n      const content = text.slice(lastIndex, match.index);\n      if (content.trim().length > 0) {\n        sections.push({ header: lastHeader, content });\n      }\n    }\n\n    lastHeader = match[1].replace(/^#+\\s*/, \"\").trim();\n    lastIndex = match.index + match[0].length;\n  }\n\n  // Don't forget the last section\n  if (lastIndex < text.length) {\n    const content = text.slice(lastIndex);\n    if (content.trim().length > 0) {\n      sections.push({ header: lastHeader, content });\n    }\n  }\n\n  // If no sections found, return the whole text\n  if (sections.length === 0) {\n    return [{ header: undefined, content: text }];\n  }\n\n  return sections;\n}\n\n/**\n * Split text into sentences\n */\nfunction splitIntoSentences(text: string): string[] {\n  // Handle common abbreviations and edge cases\n  const sentenceEnders = /([.!?]+)\\s+(?=[A-Z])/g;\n  const sentences: string[] = [];\n  let lastIndex = 0;\n\n  let match;\n  while ((match = sentenceEnders.exec(text)) !== null) {\n    const endIndex = match.index + match[1].length;\n    sentences.push(text.slice(lastIndex, endIndex + 1));\n    lastIndex = endIndex + 1;\n  }\n\n  // Add remaining text\n  if (lastIndex < text.length) {\n    const remaining = text.slice(lastIndex);\n    if (remaining.trim().length > 0) {\n      sentences.push(remaining);\n    }\n  }\n\n  return sentences;\n}\n\n/**\n * Get overlap sentences for target character count\n */\nfunction getOverlapSentences(sentences: string[], targetChars: number): string {\n  let overlap = \"\";\n\n  for (let i = sentences.length - 1; i >= 0 && overlap.length < targetChars; i--) {\n    overlap = sentences[i] + overlap;\n  }\n\n  return overlap;\n}\n\n/**\n * Get overlap text from the end of a chunk\n */\nfunction getOverlapText(text: string, targetChars: number): string {\n  if (text.length <= targetChars) {\n    return text;\n  }\n\n  // Try to break at sentence boundary\n  const lastPart = text.slice(-targetChars * 1.5);\n  const sentenceMatch = lastPart.match(/[.!?]\\s+/);\n\n  if (sentenceMatch && sentenceMatch.index) {\n    return lastPart.slice(sentenceMatch.index + sentenceMatch[0].length);\n  }\n\n  // Fall back to word boundary\n  const wordMatch = lastPart.match(/\\s+/);\n  if (wordMatch && wordMatch.index) {\n    return lastPart.slice(wordMatch.index + wordMatch[0].length);\n  }\n\n  return text.slice(-targetChars);\n}\n\n/**\n * Create a chunk object with metadata\n */\nfunction createChunk(\n  index: number,\n  content: string,\n  startOffset: number,\n  endOffset: number,\n  metadata: Partial<ChunkMetadata>\n): Chunk {\n  const wordCount = content.split(/\\s+/).filter((w) => w.length > 0).length;\n\n  return {\n    index,\n    content,\n    startOffset,\n    endOffset,\n    wordCount,\n    tokenEstimate: Math.ceil(content.length / 4),\n    metadata: {\n      startsAtSentence: metadata.startsAtSentence ?? false,\n      endsAtSentence: metadata.endsAtSentence ?? false,\n      hasOverlapFromPrevious: metadata.hasOverlapFromPrevious ?? false,\n      hasOverlapToNext: metadata.hasOverlapToNext ?? false,\n      sectionHeader: metadata.sectionHeader,\n      paragraphNumber: metadata.paragraphNumber,\n    },\n  };\n}\n\n/**\n * Estimate token count for text\n */\nexport function estimateTokens(text: string): number {\n  // Rough estimate: ~4 characters per token for English text\n  return Math.ceil(text.length / 4);\n}\n\n/**\n * Merge small chunks that are below minimum size\n */\nexport function mergeSmallChunks(\n  chunks: Chunk[],\n  minSize: number = 100\n): Chunk[] {\n  if (chunks.length === 0) return [];\n\n  const merged: Chunk[] = [];\n  let current: Chunk | null = null;\n\n  for (const chunk of chunks) {\n    if (!current) {\n      current = { ...chunk };\n      continue;\n    }\n\n    if (current.content.length < minSize) {\n      // Merge with current\n      current = {\n        ...current,\n        content: current.content + \"\\n\\n\" + chunk.content,\n        endOffset: chunk.endOffset,\n        wordCount: current.wordCount + chunk.wordCount,\n        tokenEstimate: current.tokenEstimate + chunk.tokenEstimate,\n        metadata: {\n          ...current.metadata,\n          endsAtSentence: chunk.metadata.endsAtSentence,\n          hasOverlapToNext: chunk.metadata.hasOverlapToNext,\n        },\n      };\n    } else {\n      merged.push(current);\n      current = { ...chunk, index: merged.length };\n    }\n  }\n\n  if (current) {\n    merged.push(current);\n  }\n\n  return merged;\n}\n"],"mappings":"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","names":[]}

package/dist/chunker-K6WTR62A.js

@@ -0,0 +1,12 @@
+import {
+  chunkText,
+  estimateTokens,
+  mergeSmallChunks
+} from "./chunk-ZIYTHUM5.js";
+import "./chunk-UP2VWCW5.js";
+export {
+  chunkText,
+  estimateTokens,
+  mergeSmallChunks
+};
+//# sourceMappingURL=chunker-K6WTR62A.js.map

package/dist/cli.js

@@ -16,7 +16,7 @@ switch (command) {
     import("./commands/status.js").then((m) => m.default());
     break;
   case "pair":
-    import("./pair-JDFTERIK.js").then((m) => m.showPairingInfo());
+    import("./pair-YZJFQUU5.js").then((m) => m.showPairingInfo());
     break;
   case "version":
   case "--version":

package/dist/{client-ZQSFPMOB.js → client-FOIYPOZQ.js}

@@ -1,21 +1,20 @@
 import {
+  Client,
   getNotionClient,
   getRootPageId,
-  import_client,
   initNotionClient,
   init_client,
   isNotionInitialized,
   resetNotionClient
-} from "./chunk-VRD5CYRL.js";
-import "./chunk-PLDDJCW6.js";
+} from "./chunk-C6PELIHS.js";
+import "./chunk-UP2VWCW5.js";
 init_client();
-var export_Client = import_client.Client;
 export {
-  export_Client as Client,
+  Client,
   getNotionClient,
   getRootPageId,
   initNotionClient,
   isNotionInitialized,
   resetNotionClient
 };
-//# sourceMappingURL=client-ZQSFPMOB.js.map
+//# sourceMappingURL=client-FOIYPOZQ.js.map

package/dist/{clipboard-manager-TEO2GEDN.js → clipboard-manager-4SBNESGZ.js}

@@ -9,7 +9,7 @@ import {
   save,
   search
 } from "./chunk-MGFBLVR7.js";
-import "./chunk-PLDDJCW6.js";
+import "./chunk-UP2VWCW5.js";
 export {
   clearAll,
   clipboardTool,
@@ -21,4 +21,4 @@ export {
   save,
   search
 };
-//# sourceMappingURL=clipboard-manager-TEO2GEDN.js.map
+//# sourceMappingURL=clipboard-manager-4SBNESGZ.js.map