@daviddh/llm-markdown-whatsapp 0.0.1

package/packages/core/src/chatSplit/listNormalization.ts

@@ -0,0 +1,189 @@
+import { INDEX_OFFSET, MAX_LIST_NUMBER } from './constants.js';
+
+/** Zero constant */
+const ZERO = 0;
+
+/** Not found constant for indexOf */
+const NOT_FOUND = -1;
+
+/** Match info for list item replacement */
+interface ListMatchInfo {
+  match: string;
+  before: string;
+  num: string;
+  after: string;
+  offset: number;
+}
+
+/** Replacement info */
+interface ReplacementInfo {
+  start: number;
+  end: number;
+  replacement: string;
+}
+
+/** Get replacement at index */
+const getReplacementAt = (replacements: ReplacementInfo[], index: number): ReplacementInfo | undefined =>
+  replacements[index];
+
+/** Check if text is already formatted */
+const isAlreadyFormatted = (text: string): boolean => /\d{1,2}\.\s+[^\n]+\n\s*\d{1,2}\.\s+/v.test(text);
+
+/** Check for inline list patterns */
+const hasInlineListPatterns = (text: string): boolean => {
+  const afterColon = /:[^\n]*\d{1,2}\.\s+[^\n]+[ ]+\d{1,2}\.\s+/v.test(text);
+  const afterPunctuation = /[?!][^\n]*\s+1\.\s+[^\n]+[ ]+2\.\s+/v.test(text);
+  return afterColon || afterPunctuation;
+};
+
+/** Check if offset is preceded by a digit (version number pattern) */
+const isPrecededByDigit = (text: string, offset: number): boolean => {
+  if (offset <= ZERO) return false;
+  const charBefore = text.charAt(offset - INDEX_OFFSET);
+  return /\d/v.test(charBefore);
+};
+
+/** Process a single list match and return replacement */
+const processListMatch = (info: ListMatchInfo, text: string): string => {
+  const numValue = parseInt(info.num, 10);
+
+  if (numValue > MAX_LIST_NUMBER) return info.match;
+  if (isPrecededByDigit(text, info.offset)) return info.match;
+
+  if (info.num === '1' && info.before === ':') {
+    return `${info.before}\n${info.num}. ${info.after}`;
+  }
+
+  if (info.before.trim() === '' || info.before === ':') {
+    return `\n${info.num}. ${info.after}`;
+  }
+
+  return info.match;
+};
+
+/** Get string length safely */
+const getStringLength = (str: string): number => str.length;
+
+/** Create list match info from regex match */
+const createListMatchInfo = (match: RegExpExecArray): ListMatchInfo => {
+  const { groups } = match;
+  const [firstMatch = ''] = match;
+  return {
+    match: firstMatch,
+    before: groups?.before ?? '',
+    num: groups?.num ?? '',
+    after: groups?.after ?? '',
+    offset: match.index,
+  };
+};
+
+/** Collect all replacements from text */
+const collectReplacements = (text: string): ReplacementInfo[] => {
+  const pattern = /(?<before>[:\s?!])(?<num>\d{1,2})\.\s+(?<after>[^\n])/gv;
+  const replacements: ReplacementInfo[] = [];
+  let match = pattern.exec(text);
+
+  while (match !== null) {
+    const info = createListMatchInfo(match);
+    const replacement = processListMatch(info, text);
+    if (replacement !== info.match) {
+      const matchLength = getStringLength(info.match);
+      replacements.push({ start: match.index, end: match.index + matchLength, replacement });
+    }
+    match = pattern.exec(text);
+  }
+
+  return replacements;
+};
+
+/** Apply replacements in reverse order */
+const applyReplacements = (text: string, replacements: ReplacementInfo[]): string => {
+  let result = text;
+  const { length: count } = replacements;
+
+  for (let i = count - INDEX_OFFSET; i >= ZERO; i -= INDEX_OFFSET) {
+    const r = getReplacementAt(replacements, i);
+    if (r !== undefined) {
+      result = result.substring(ZERO, r.start) + r.replacement + result.substring(r.end);
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Detects if text contains an inline numbered list pattern like "1. X 2. Y 3. Z"
+ * and normalizes it by adding line breaks between items
+ * IMPORTANT: Only normalizes truly inline lists, preserves already-formatted lists
+ */
+export const normalizeInlineNumberedList = (text: string): string => {
+  if (isAlreadyFormatted(text)) return text;
+  if (!hasInlineListPatterns(text)) return text;
+
+  const replacements = collectReplacements(text);
+  return applyReplacements(text, replacements);
+};
+
+/**
+ * Normalizes inline product card lists by adding line breaks.
+ * Detects patterns like "**1. 🛍️ Product** 💵 Price... **2. 🛍️ Product** 💵 Price..."
+ * and adds line breaks before each numbered item and emoji indicators.
+ */
+export const normalizeInlineProductCardList = (text: string): string => {
+  // Check if we have inline product cards (numbered items with 🛍️ or markdown + emoji indicators on same line)
+  // Pattern 1: Multiple product cards - "1. 🛍️...2. 🛍️"
+  // Pattern 2: Single product card - "1. 🛍️" followed by emoji indicators without line breaks
+  const hasInlineProductCards =
+    /(?:\*{1,2})?\d+\.\s*🛍️[^\n]*\s+(?:\*{1,2})?\d+\.\s*🛍️/v.test(text) ||
+    /\d+\.\s+\*{1,2}[^*\n]+\*{1,2}\s+\p{Extended_Pictographic}[^\n]+\s+(?:\*{1,2})?\d+\.\s+/v.test(text) ||
+    /(?:\*{1,2})?\d+\.\s*🛍️[^\n]+\p{Extended_Pictographic}[^\n]+\p{Extended_Pictographic}/v.test(text);
+
+  if (!hasInlineProductCards) {
+    return text; // No inline product cards, return as-is
+  }
+
+  let result = text;
+
+  // Step 1: Add line break before numbered product card items (but not the first one)
+  // Pattern matches: "**2. 🛍️" or "*2. 🛍️" or "2. 🛍️" or "**2. *Title*" or "*2. *Title*"
+  // Must be preceded by a period, exclamation, or emoji from previous card
+  result = result.replace(/(?<punct>[.!✅])\s+(?<card>\*{0,2}\d+\.\s+(?:🛍️|\*{1,2}))/gv, '$<punct>\n$<card>');
+
+  // Step 2: Add line breaks before ANY emoji when not already on new line
+  // Only apply to content AFTER the first 🛍️ marker (to avoid affecting intro text)
+  // But NOT if they immediately follow the product card number pattern (to avoid breaking "1. 🛍️")
+  const firstProductMarker = result.indexOf('🛍️');
+  if (firstProductMarker !== NOT_FOUND) {
+    const beforeProducts = result.substring(ZERO, firstProductMarker);
+    const productsContent = result.substring(firstProductMarker);
+
+    const transformedProducts = productsContent.replace(
+      /(?<before>[^\n])\s+(?<emoji>\p{Extended_Pictographic})/gv,
+      (match, before: string, emoji: string) => {
+        // Don't add newline if the emoji follows a number and period (like "1. 🛍️")
+        if (/\d\.\s*$/v.test(before)) {
+          return match;
+        }
+        // Don't add newline if there's no actual space (protects emoji sequences)
+        if (!/\s/v.test(match)) {
+          return match;
+        }
+        return `${before}\n${emoji}`;
+      }
+    );
+
+    result = beforeProducts + transformedProducts;
+  }
+
+  // Step 3: Add line break before trailing questions (after product card content)
+  // Pattern: period/exclamation followed by space and question starting with ¿
+  // Keep the trailing emoji with the question
+  result = result.replace(
+    /(?<punctuation>[.!])\s+(?<question>¿[^\n?]*\?(?:\s*[^\s\n]+)?)$/mv,
+    (_match, punctuation: string, question: string) =>
+      // Check if question ends with an emoji - if so, keep it together
+      `${punctuation}\n${question.trim()}`
+  );
+
+  return result;
+};

package/packages/core/src/chatSplit/listProcessor.ts

@@ -0,0 +1,74 @@
+import { AVG_ITEM_LENGTH_THRESHOLD, MAX_ITEMS_FOR_LONG_SPLIT } from './constants.js';
+import { findListSection } from './sections.js';
+import type { SplitResult } from './splitProcessors.js';
+
+/** Huge item length threshold */
+const HUGE_ITEM_LENGTH = 150;
+
+/** Zero constant for comparisons */
+const ZERO = 0;
+
+/**
+ * Processes numbered list items
+ */
+function processNumberedList(listText: string, afterList: string, chunks: string[]): SplitResult {
+  const items = listText.split(/\n(?=\d{1,2}\.\s+)/v).filter((item) => item.trim().length > ZERO);
+
+  const hasHugeItems = items.some((item) => item.length > HUGE_ITEM_LENGTH);
+  const avgItemLength = items.reduce((sum, item) => sum + item.length, ZERO) / items.length;
+  const hasLongItems = avgItemLength > AVG_ITEM_LENGTH_THRESHOLD;
+
+  if (hasHugeItems || (hasLongItems && items.length <= MAX_ITEMS_FOR_LONG_SPLIT)) {
+    items.forEach((item) => {
+      const trimmedItem = item.trim();
+      if (trimmedItem.length > ZERO) {
+        chunks.push(trimmedItem);
+      }
+    });
+  } else {
+    chunks.push(listText.trim());
+  }
+
+  return { splitFound: true, newRemainingText: afterList.trim() };
+}
+
+/**
+ * Processes bullet list items
+ */
+function processBulletList(listText: string, afterList: string, chunks: string[]): SplitResult {
+  const items = listText.split(/\n(?=[\-•]\s+)/v).filter((item) => item.trim().length > ZERO);
+  const hasHugeItems = items.some((item) => item.length > HUGE_ITEM_LENGTH);
+
+  if (hasHugeItems) {
+    items.forEach((item) => {
+      const trimmedItem = item.trim();
+      if (trimmedItem.length > ZERO) {
+        chunks.push(trimmedItem);
+      }
+    });
+  } else {
+    chunks.push(listText.trim());
+  }
+
+  return { splitFound: true, newRemainingText: afterList.trim() };
+}
+
+/**
+ * Processes list sections
+ */
+export function processListSection(remainingText: string, chunks: string[]): SplitResult {
+  const listSection = findListSection(remainingText);
+
+  if (listSection === null) {
+    return { splitFound: false, newRemainingText: remainingText };
+  }
+
+  const listText = remainingText.substring(listSection.start, listSection.end);
+  const afterList = remainingText.substring(listSection.end);
+
+  if (listSection.type === 'numbered') {
+    return processNumberedList(listText, afterList, chunks);
+  }
+
+  return processBulletList(listText, afterList, chunks);
+}

package/packages/core/src/chatSplit/mergeProcessor.ts

@@ -0,0 +1,124 @@
+import { INDEX_OFFSET, MIN_CHUNK_SIZE } from './constants.js';
+
+/** Long paragraph threshold */
+const LONG_PARAGRAPH_THRESHOLD = 150;
+
+/** Zero constant */
+const ZERO = 0;
+
+/** Get chunk at index safely */
+const getChunkAt = (chunks: string[], index: number): string | undefined => chunks[index];
+
+/** Check if chunk starts with question mark */
+const startsWithQuestion = (chunk: string): boolean => chunk.trim().startsWith('¿');
+
+/** Check if chunk starts with list */
+const startsWithList = (chunk: string): boolean => /^(?:\d{1,2}\.\s+|[\-•]\s+)/v.test(chunk.trim());
+
+/** Check if chunk ends with colon */
+const endsWithColon = (chunk: string): boolean => chunk.trim().endsWith(':');
+
+/** Check if chunk is a long paragraph */
+const isLongParagraph = (chunk: string): boolean => chunk.trim().length > LONG_PARAGRAPH_THRESHOLD;
+
+/** Checks if current chunk should be merged with next */
+const shouldMergeWithNext = (
+  chunk: string,
+  nextChunk: string,
+  isLastChunk: boolean
+): { shouldMerge: boolean; skipToNext: boolean } => {
+  if (endsWithColon(chunk) && (startsWithList(nextChunk) || isLongParagraph(nextChunk))) {
+    return { shouldMerge: false, skipToNext: false };
+  }
+
+  if (endsWithColon(nextChunk)) {
+    return { shouldMerge: false, skipToNext: false };
+  }
+
+  const shouldMerge = chunk.trim().length < MIN_CHUNK_SIZE && !startsWithQuestion(nextChunk) && !isLastChunk;
+  return { shouldMerge, skipToNext: shouldMerge };
+};
+
+/** Handle last chunk merge with previous */
+const handleLastChunkMerge = (chunk: string, mergedChunks: string[]): void => {
+  const previousChunk = mergedChunks.pop();
+  if (previousChunk !== undefined) {
+    mergedChunks.push(`${previousChunk} ${chunk.trim()}`);
+  }
+};
+
+/** Check if last chunk should merge with previous */
+const shouldMergeLastWithPrevious = (chunk: string, mergedChunksLength: number): boolean =>
+  chunk.trim().length < MIN_CHUNK_SIZE && mergedChunksLength > ZERO && !startsWithQuestion(chunk);
+
+/** Get current chunk from pending or working chunks */
+const getCurrentChunk = (
+  pendingMerge: string | null,
+  workingChunks: string[],
+  index: number
+): string | undefined => {
+  if (pendingMerge !== null) return pendingMerge;
+  return getChunkAt(workingChunks, index);
+};
+
+/** Process last chunk with potential merge */
+const processLastChunk = (chunk: string, mergedChunks: string[]): void => {
+  if (shouldMergeLastWithPrevious(chunk, mergedChunks.length)) {
+    handleLastChunkMerge(chunk, mergedChunks);
+  } else {
+    mergedChunks.push(chunk);
+  }
+};
+
+/** Process a non-last chunk and return pending merge if needed */
+const processNonLastChunk = (
+  currentChunk: string,
+  nextChunk: string | undefined,
+  mergedChunks: string[]
+): string | null => {
+  if (nextChunk === undefined) {
+    mergedChunks.push(currentChunk);
+    return null;
+  }
+
+  const { shouldMerge, skipToNext } = shouldMergeWithNext(currentChunk, nextChunk, false);
+
+  if (shouldMerge && skipToNext) {
+    return `${currentChunk} ${nextChunk}`;
+  }
+
+  mergedChunks.push(currentChunk);
+  return null;
+};
+
+/** Merges small chunks with adjacent chunks */
+export function mergeSmallChunks(chunks: string[]): string[] {
+  const mergedChunks: string[] = [];
+  const workingChunks = [...chunks];
+  let i = ZERO;
+  let pendingMerge: string | null = null;
+
+  while (i < workingChunks.length) {
+    const currentChunk = getCurrentChunk(pendingMerge, workingChunks, i);
+    pendingMerge = null;
+
+    if (currentChunk === undefined) {
+      i += INDEX_OFFSET;
+      continue;
+    }
+
+    const isLastChunk = i === workingChunks.length - INDEX_OFFSET;
+
+    if (isLastChunk) {
+      processLastChunk(currentChunk, mergedChunks);
+      i += INDEX_OFFSET;
+      continue;
+    }
+
+    const nextChunk = getChunkAt(workingChunks, i + INDEX_OFFSET);
+    pendingMerge = processNonLastChunk(currentChunk, nextChunk, mergedChunks);
+    i += INDEX_OFFSET;
+  }
+
+  return mergedChunks;
+}

package/packages/core/src/chatSplit/paragraphProcessor.ts

@@ -0,0 +1,86 @@
+import { FIRST_NEWLINE_SEARCH_LIMIT, INDEX_OFFSET } from './constants.js';
+import { findMarkdownSection } from './sections.js';
+import { type SplitResult, hasQuestionWithOptionsPattern } from './splitProcessors.js';
+
+/** Long paragraph threshold */
+const LONG_PARAGRAPH_THRESHOLD = 150;
+
+/** Minimum list items for question with options */
+const MIN_LIST_ITEMS_FOR_OPTIONS = 2;
+
+/** Zero constant for comparisons */
+const ZERO = 0;
+
+/**
+ * Processes long paragraphs after an intro
+ */
+export function processLongParagraphsAfterIntro(remainingText: string, chunks: string[]): SplitResult {
+  const firstNewline = remainingText.indexOf('\n');
+  const NOT_FOUND = -1;
+
+  if (firstNewline === NOT_FOUND || firstNewline >= FIRST_NEWLINE_SEARCH_LIMIT) {
+    return { splitFound: false, newRemainingText: remainingText };
+  }
+
+  const firstLine = remainingText.substring(ZERO, firstNewline);
+  if (!firstLine.trim().endsWith(':')) {
+    return { splitFound: false, newRemainingText: remainingText };
+  }
+
+  const afterIntro = remainingText.substring(firstNewline + INDEX_OFFSET);
+  const paragraphs = afterIntro.split('\n').filter((p) => p.trim().length > ZERO);
+
+  if (
+    paragraphs.length >= MIN_LIST_ITEMS_FOR_OPTIONS &&
+    paragraphs.some((p) => p.length > LONG_PARAGRAPH_THRESHOLD)
+  ) {
+    chunks.push(firstLine.trim());
+    return { splitFound: true, newRemainingText: afterIntro };
+  }
+
+  return { splitFound: false, newRemainingText: remainingText };
+}
+
+/**
+ * Processes sequence of long paragraphs
+ */
+export function processLongParagraphSequence(remainingText: string, chunks: string[]): SplitResult {
+  const lines = remainingText.split('\n');
+  const [firstLine] = lines;
+
+  if (lines.length < MIN_LIST_ITEMS_FOR_OPTIONS || firstLine === undefined) {
+    return { splitFound: false, newRemainingText: remainingText };
+  }
+
+  const firstParagraph = firstLine.trim();
+  if (firstParagraph.length <= LONG_PARAGRAPH_THRESHOLD) {
+    return { splitFound: false, newRemainingText: remainingText };
+  }
+
+  const afterFirstParagraph = lines.slice(INDEX_OFFSET).join('\n').trim();
+  const hasQuestionWithOptions = hasQuestionWithOptionsPattern(afterFirstParagraph);
+
+  if (!hasQuestionWithOptions) {
+    chunks.push(firstParagraph);
+    return { splitFound: true, newRemainingText: afterFirstParagraph };
+  }
+
+  return { splitFound: false, newRemainingText: remainingText };
+}
+
+/**
+ * Processes markdown sections
+ */
+export function processMarkdownSection(remainingText: string, chunks: string[]): SplitResult {
+  const markdownSection = findMarkdownSection(remainingText);
+
+  if (markdownSection !== null) {
+    chunks.push(markdownSection.fullSection.trim());
+    return {
+      splitFound: true,
+      newRemainingText: remainingText.substring(markdownSection.fullSection.length).trim(),
+    };
+  }
+
+  return { splitFound: false, newRemainingText: remainingText };
+}

package/packages/core/src/chatSplit/periodProcessor.ts

@@ -0,0 +1,148 @@
+import {
+  CURRENT_TEXT_SHORT_THRESHOLD,
+  INDEX_OFFSET,
+  SHORT_CHUNK_THRESHOLD,
+  SHORT_QUESTION_FRAGMENT_THRESHOLD,
+} from './constants.js';
+import { isPositionInsideParentheses } from './positionHelpers.js';
+import type { SplitResult } from './splitProcessors.js';
+import { smartTrim } from './textHelpers.js';
+
+/** Protected range interface */
+interface ProtectedRange {
+  start: number;
+  end: number;
+}
+
+/** Constants */
+const ZERO = 0;
+const INCREMENT = 1;
+
+/** Add matches from pattern to protected ranges */
+const addPatternMatches = (text: string, pattern: RegExp, ranges: ProtectedRange[]): void => {
+  const matches = text.matchAll(pattern);
+  for (const match of matches) {
+    const [matchedText] = match;
+    ranges.push({ start: match.index, end: match.index + matchedText.length });
+  }
+};
+
+/** Add period-ending matches to protected ranges */
+const addPeriodEndingMatches = (text: string, pattern: RegExp, ranges: ProtectedRange[]): void => {
+  const matches = text.matchAll(pattern);
+  for (const match of matches) {
+    const [matchedText] = match;
+    const periodIndex = match.index + matchedText.length - INDEX_OFFSET;
+    ranges.push({ start: periodIndex, end: periodIndex + INDEX_OFFSET });
+  }
+};
+
+/** URL patterns */
+const URL_PATTERN = /https?:\/\/[^\s]*[^\s.!?,;:]|www\.[^\s]*[^\s.!?,;:]/gv;
+const PLAIN_DOMAIN_PATTERN =
+  /\b[a-zA-Z0-9][a-zA-Z0-9\-]*(?:\.[a-zA-Z0-9][a-zA-Z0-9\-]*)*\.(?:com|co|net|org|edu|gov|io|ai|app|dev|ly|me|tv|info|biz|tech|store|shop|online|site|web|blog|news|uk|ca|au|de|fr|es|it|nl|mx|ar|br|cl|pe|ve|uy|py|bo|gt|hn|sv|cr|pa|ni|do|cu|pr)(?:\.[a-z]{2,3})?\b/giv;
+const EMAIL_PATTERN = /[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}/gv;
+const NUMBER_PATTERN = /\$?\d{1,3}(?:\.\d{3})+(?:\.\d+)?|\d+(?:\.\d+)+/gv;
+
+/** Period-ending patterns */
+const NUMBERED_LIST_PATTERN = /(?:^|\n)\s*\d+\./gv;
+const ABBREVIATIONS_PATTERN = /\b(?:etc|e\.g|i\.e|dr|mr|mrs|ms|prof|sr|jr|inc|ltd|co|corp)\./giv;
+const LOCATION_ABBR_PATTERN = /\b[A-Z]\.(?:[A-Z]\.)+/gv;
+const BULLET_POINT_PATTERN = /(?:^|\n)\s*[\-•]\s+[^\n]+\./gmv;
+
+/** Find URL and email protected ranges */
+const findUrlEmailRanges = (text: string): ProtectedRange[] => {
+  const ranges: ProtectedRange[] = [];
+  addPatternMatches(text, URL_PATTERN, ranges);
+  addPatternMatches(text, PLAIN_DOMAIN_PATTERN, ranges);
+  addPatternMatches(text, EMAIL_PATTERN, ranges);
+  addPatternMatches(text, NUMBER_PATTERN, ranges);
+  return ranges;
+};
+
+/** Find list and abbreviation protected ranges */
+const findListAbbreviationRanges = (text: string): ProtectedRange[] => {
+  const ranges: ProtectedRange[] = [];
+  addPeriodEndingMatches(text, NUMBERED_LIST_PATTERN, ranges);
+  addPeriodEndingMatches(text, ABBREVIATIONS_PATTERN, ranges);
+  addPatternMatches(text, LOCATION_ABBR_PATTERN, ranges);
+  addPeriodEndingMatches(text, BULLET_POINT_PATTERN, ranges);
+  return ranges;
+};
+
+/** Finds all protected ranges in text */
+const findProtectedRanges = (text: string): ProtectedRange[] => [
+  ...findUrlEmailRanges(text),
+  ...findListAbbreviationRanges(text),
+];
+
+/** Check if position is protected */
+const isPositionProtected = (position: number, ranges: ProtectedRange[]): boolean =>
+  ranges.some((range) => position >= range.start && position < range.end);
+
+/** Finds all valid period indices for splitting */
+const findValidPeriodIndices = (text: string, protectedRanges: ProtectedRange[]): number[] => {
+  const periodIndices: number[] = [];
+
+  for (let i = ZERO; i < text.length; i += INCREMENT) {
+    if (text[i] !== '.') continue;
+    if (isPositionProtected(i, protectedRanges)) continue;
+    if (isPositionInsideParentheses(text, i)) continue;
+    periodIndices.push(i);
+  }
+
+  return periodIndices;
+};
+
+/** Check if period should be skipped due to short question after */
+const shouldSkipForShortQuestion = (afterPeriod: string): boolean =>
+  afterPeriod.includes('?') && afterPeriod.length < SHORT_QUESTION_FRAGMENT_THRESHOLD;
+
+/** Check if period should be skipped due to short chunks */
+const shouldSkipForShortChunks = (
+  chunks: string[],
+  remainingTextLength: number,
+  afterPeriodLength: number
+): boolean => {
+  const lastChunkIndex = chunks.length - INDEX_OFFSET;
+  const lastChunk = lastChunkIndex >= ZERO ? chunks[lastChunkIndex] : undefined;
+
+  // Original logic: if no last chunk, lastChunkWasShort is false (not true)
+  const lastChunkWasShort = lastChunk !== undefined && lastChunk.trim().length < SHORT_CHUNK_THRESHOLD;
+  const currentTextIsShort = remainingTextLength < CURRENT_TEXT_SHORT_THRESHOLD;
+  const afterPeriodIsShort = afterPeriodLength < CURRENT_TEXT_SHORT_THRESHOLD;
+
+  return lastChunkWasShort && currentTextIsShort && afterPeriodIsShort;
+};
+
+/** Process a single period for potential split */
+const processSinglePeriod = (
+  remainingText: string,
+  periodIndex: number,
+  chunks: string[]
+): SplitResult | null => {
+  if (periodIndex >= remainingText.length - INDEX_OFFSET) return null;
+
+  const afterPeriod = smartTrim(remainingText.substring(periodIndex + INDEX_OFFSET));
+  if (afterPeriod.length === ZERO) return null;
+
+  if (shouldSkipForShortQuestion(afterPeriod)) return null;
+  if (shouldSkipForShortChunks(chunks, remainingText.length, afterPeriod.length)) return null;
+
+  const beforePart = remainingText.substring(ZERO, periodIndex + INDEX_OFFSET);
+  chunks.push(beforePart);
+  return { splitFound: true, newRemainingText: afterPeriod };
+};
+
+/** Processes period splits */
+export function processPeriodSplits(remainingText: string, chunks: string[]): SplitResult {
+  const protectedRanges = findProtectedRanges(remainingText);
+  const periodIndices = findValidPeriodIndices(remainingText, protectedRanges);
+
+  for (const periodIndex of periodIndices) {
+    const result = processSinglePeriod(remainingText, periodIndex, chunks);
+    if (result !== null) return result;
+  }
+
+  return { splitFound: false, newRemainingText: remainingText };
+}

package/packages/core/src/chatSplit/positionHelpers.ts

@@ -0,0 +1,66 @@
+/** Constants */
+const INCREMENT = 1;
+const DECREMENT = 1;
+const ZERO = 0;
+
+/** Get character at position safely */
+const getCharAt = (text: string, position: number): string | undefined => text[position];
+
+/** Update open count based on character */
+const updateOpenCount = (currentCount: number, char: string): number => {
+  if (char === '(') {
+    return currentCount + INCREMENT;
+  }
+  if (char === ')') {
+    const newCount = currentCount - DECREMENT;
+    return newCount < ZERO ? ZERO : newCount;
+  }
+  return currentCount;
+};
+
+/**
+ * Check if a position (index) in the text is within a bullet point line.
+ * This prevents splitting bullet lists at punctuation within bullet items.
+ */
+export const isPositionInBulletLine = (text: string, position: number): boolean => {
+  if (position < ZERO || position >= text.length) return false;
+
+  let lineStart = position;
+  while (lineStart > ZERO && getCharAt(text, lineStart - DECREMENT) !== '\n') {
+    lineStart -= DECREMENT;
+  }
+
+  let lineEnd = position;
+  while (lineEnd < text.length && getCharAt(text, lineEnd) !== '\n') {
+    lineEnd += INCREMENT;
+  }
+
+  const line = text.substring(lineStart, lineEnd);
+  const trimmedLine = line.trim();
+
+  return /^[\-•]\s+/v.test(trimmedLine);
+};
+
+/**
+ * Count open parentheses up to a position
+ */
+const countOpenParentheses = (text: string, position: number): number => {
+  let openCount = ZERO;
+
+  for (let i = ZERO; i < position; i += INCREMENT) {
+    const char = getCharAt(text, i) ?? '';
+    openCount = updateOpenCount(openCount, char);
+  }
+
+  return openCount;
+};
+
+/**
+ * Check if a position (index) in the text is within parentheses.
+ * This prevents splitting text inside parenthetical expressions.
+ * Returns true if the position is inside an unbalanced parenthetical expression.
+ */
+export const isPositionInsideParentheses = (text: string, position: number): boolean => {
+  if (position < ZERO || position >= text.length) return false;
+  return countOpenParentheses(text, position) > ZERO;
+};