@critical-path/core 0.36.0 → 0.36.1

package/src/utils/fractional-index.ts

@@ -1,254 +0,0 @@
-/**
- * Fractional Lexical Indexing Utility
- *
- * Deterministic Base-62 fractional indexing for ordered lists and swimlane task sequences.
- * Produces lexicographically sortable strings (`orderIndex`) that allow infinite insertion
- * between any two items without floating-point precision loss.
- */
-
-export const BASE_62 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
-
-/**
- * Encodes a non-negative integer into Base-62.
- */
-function toBase62(n: number): string {
-  if (n === 0) return '0';
-  let s = '';
-  let curr = n;
-  while (curr > 0) {
-    s = BASE_62[curr % 62] + s;
-    curr = Math.floor(curr / 62);
-  }
-  return s;
-}
-
-/**
- * Decodes a Base-62 string into a non-negative integer.
- */
-function fromBase62(s: string): number {
-  let n = 0;
-  for (let i = 0; i < s.length; i++) {
-    const idx = BASE_62.indexOf(s[i]);
-    if (idx === -1) return 0;
-    n = n * 62 + idx;
-  }
-  return n;
-}
-
-/**
- * Encodes an integer into a prefix-encoded string such that standard
- * string comparison strictly matches integer comparison.
- *
- * Non-negative integers (0, 1, 2, ...):
- *   Prefix 'a'-'z' specifies the digit count (1 to 26 digits).
- *   0 -> "a0", 1 -> "a1", 61 -> "az", 62 -> "b10", ...
- *
- * Negative integers (-1, -2, ...):
- *   Prefix 'Z'-'A' specifies inverted digit count with inverted digits.
- *   -1 -> "Zz", -2 -> "Zy", ...
- */
-export function encodeInteger(n: number): string {
-  if (n >= 0) {
-    const digits = toBase62(n);
-    const prefixCode = 97 + digits.length - 1; // 97 is 'a'
-    const prefix = String.fromCharCode(Math.min(prefixCode, 122)); // clamp to 'z'
-    return prefix + digits;
-  } else {
-    const pos = -n - 1;
-    const digits = toBase62(pos);
-    let inverted = '';
-    for (let i = 0; i < digits.length; i++) {
-      const idx = BASE_62.indexOf(digits[i]);
-      inverted += BASE_62[61 - idx];
-    }
-    const prefixCode = 90 - (digits.length - 1); // 90 is 'Z'
-    const prefix = String.fromCharCode(Math.max(prefixCode, 65)); // clamp to 'A'
-    return prefix + inverted;
-  }
-}
-
-/**
- * Decodes a prefix-encoded integer string back into a number.
- */
-export function decodeInteger(s: string): number {
-  if (!s || s.length < 2) return 0;
-  const prefix = s[0];
-  if (prefix >= 'a' && prefix <= 'z') {
-    const len = prefix.charCodeAt(0) - 97 + 1;
-    const digits = s.slice(1, 1 + len);
-    return fromBase62(digits);
-  } else if (prefix >= 'A' && prefix <= 'Z') {
-    const len = 90 - prefix.charCodeAt(0) + 1;
-    const inverted = s.slice(1, 1 + len);
-    let digits = '';
-    for (let i = 0; i < inverted.length; i++) {
-      const idx = BASE_62.indexOf(inverted[i]);
-      digits += idx !== -1 ? BASE_62[61 - idx] : '0';
-    }
-    const pos = fromBase62(digits);
-    return -pos - 1;
-  }
-  return 0;
-}
-
-/**
- * Extracts the integer component from an order key.
- */
-export function getIntegerPart(key: string): string {
-  if (!key || key.length < 2) return 'a0';
-  const prefix = key[0];
-  if (prefix >= 'a' && prefix <= 'z') {
-    const len = prefix.charCodeAt(0) - 97 + 1;
-    return key.slice(0, Math.min(key.length, 1 + len));
-  } else if (prefix >= 'A' && prefix <= 'Z') {
-    const len = 90 - prefix.charCodeAt(0) + 1;
-    return key.slice(0, Math.min(key.length, 1 + len));
-  }
-  return 'a0';
-}
-
-/**
- * Computes a fractional suffix strictly between suffixes `a` and `b` (a < result < b).
- * Missing digits in `a` are treated as '0', so `a` may be shorter than `b`.
- * `b === null` means there is no upper bound.
- */
-function midpointSuffix(a: string, b: string | null): string {
-  if (b !== null) {
-    let n = 0;
-    while (n < b.length && (a[n] ?? '0') === b[n]) {
-      n++;
-    }
-    if (n > 0) {
-      return b.slice(0, n) + midpointSuffix(a.slice(n), b.slice(n));
-    }
-  }
-
-  const digitA = a.length > 0 ? BASE_62.indexOf(a[0]) : 0;
-  const digitB = b !== null ? BASE_62.indexOf(b[0]) : BASE_62.length;
-
-  if (digitB - digitA > 1) {
-    return BASE_62[Math.floor((digitA + digitB) / 2)];
-  }
-
-  // Adjacent digits: if b has more digits, its first digit alone already sits between a and b.
-  if (b !== null && b.length > 1) {
-    return b[0];
-  }
-
-  // Otherwise keep a's digit and subdivide the remainder with no upper bound.
-  return BASE_62[digitA] + midpointSuffix(a.slice(1), null);
-}
-
-/**
- * Generates a default initial order key for an index with optional spacing.
- * E.g. index 0 -> "a0", index 1 (spacing 2) -> "a2", index 2 -> "a4"
- */
-export function getInitialKey(index: number, spacing: number = 2): string {
-  return encodeInteger(Math.max(0, index) * Math.max(1, spacing));
-}
-
-/**
- * Generates a single key strictly between keys `a` and `b` (a < key < b).
- * Handles null/undefined for lower and upper bounds.
- */
-export function generateKeyBetween(
-  a: string | null | undefined,
-  b: string | null | undefined
-): string {
-  const hasA = a !== null && a !== undefined && a !== '';
-  const hasB = b !== null && b !== undefined && b !== '';
-
-  if (!hasA && !hasB) {
-    return 'a0';
-  }
-
-  if (!hasA && hasB) {
-    const intB = getIntegerPart(b!);
-    if (intB === b) {
-      const valB = decodeInteger(intB);
-      return encodeInteger(valB - 1);
-    }
-    // If b has fractional suffix (e.g. "a0V"), integer part is already strictly smaller than b
-    return intB;
-  }
-
-  if (hasA && !hasB) {
-    const intA = getIntegerPart(a!);
-    const valA = decodeInteger(intA);
-    return encodeInteger(valA + 1);
-  }
-
-  // Both a and b are present
-  if (a! >= b!) {
-    throw new RangeError(`generateKeyBetween: lower bound "${a}" must sort before upper bound "${b}"`);
-  }
-
-  const intA = getIntegerPart(a!);
-  const intB = getIntegerPart(b!);
-
-  if (intA !== intB) {
-    const valA = decodeInteger(intA);
-    const valB = decodeInteger(intB);
-
-    if (valB - valA > 1) {
-      const midVal = Math.floor((valA + valB) / 2);
-      return encodeInteger(midVal);
-    }
-
-    if (valB - valA === 1) {
-      const suffixA = a!.slice(intA.length);
-      return intA + midpointSuffix(suffixA, null);
-    }
-  }
-
-  // Same integer part or fractional subdivision
-  const suffixA = a!.slice(intA.length);
-  const suffixB = b!.slice(intB.length);
-  return intA + midpointSuffix(suffixA, suffixB);
-}
-
-/**
- * Generates `count` keys in strictly ascending order between keys `a` and `b`.
- * Uses a balanced divide-and-conquer partition to guarantee even spacing.
- */
-export function generateNKeysBetween(
-  a: string | null | undefined,
-  b: string | null | undefined,
-  count: number
-): string[] {
-  if (count <= 0) return [];
-  if (count === 1) return [generateKeyBetween(a, b)];
-
-  const result: string[] = new Array(count);
-
-  function fill(
-    leftKey: string | null | undefined,
-    rightKey: string | null | undefined,
-    startIdx: number,
-    endIdx: number
-  ) {
-    if (startIdx > endIdx) return;
-    const midIdx = Math.floor((startIdx + endIdx) / 2);
-    const midKey = generateKeyBetween(leftKey, rightKey);
-    result[midIdx] = midKey;
-    fill(leftKey, midKey, startIdx, midIdx - 1);
-    fill(midKey, rightKey, midIdx + 1, endIdx);
-  }
-
-  fill(a, b, 0, count - 1);
-  return result;
-}
-
-/**
- * Standard comparator for fractional order indices.
- * Uses strict code-point comparison matching Firestore, SQLite, and JavaScript array.sort().
- */
-export function compareOrderIndices(
-  a: string | null | undefined,
-  b: string | null | undefined
-): number {
-  if (!a && !b) return 0;
-  if (!a) return 1;
-  if (!b) return -1;
-  return a < b ? -1 : a > b ? 1 : 0;
-}

package/src/utils/index.ts

@@ -1,7 +0,0 @@
-export * from './status.js';
-export * from './key.js';
-export * from './workflow.js';
-export * from './mentions.js';
-export * from './fractional-index.js';
-
-

package/src/utils/key.test.ts

@@ -1,76 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { generateProjectKey, validateProjectKey, formatTaskKey, isTempTaskId } from './key.js';
-
-describe('Project Key Utilities', () => {
-  describe('generateProjectKey', () => {
-    it('generates a key for a single word name', () => {
-      expect(generateProjectKey('Operative')).toBe('OPE');
-      expect(generateProjectKey('App')).toBe('APP');
-      expect(generateProjectKey('Go')).toBe('GO');
-    });
-
-    it('generates a key for multi-word names', () => {
-      expect(generateProjectKey('Mobile App')).toBe('MA');
-      expect(generateProjectKey('Frontend Core Platform')).toBe('FCP');
-      expect(generateProjectKey('Very Long Project Name Here')).toBe('VLPN');
-    });
-
-    it('handles special characters and whitespace', () => {
-      expect(generateProjectKey('  v2.0  ')).toBe('V20');
-      expect(generateProjectKey('Project #1')).toBe('P1');
-    });
-
-    it('returns default PRJ fallback for empty input', () => {
-      expect(generateProjectKey('')).toBe('PRJ');
-      expect(generateProjectKey('   ')).toBe('PRJ');
-    });
-  });
-
-  describe('validateProjectKey', () => {
-    it('returns true for valid keys', () => {
-      expect(validateProjectKey('CP')).toBe(true);
-      expect(validateProjectKey('PROJ')).toBe(true);
-      expect(validateProjectKey('APP123')).toBe(true);
-    });
-
-    it('returns false for invalid keys', () => {
-      expect(validateProjectKey('A')).toBe(false); // too short
-      expect(validateProjectKey('TOOLONGKEY')).toBe(false); // too long
-      expect(validateProjectKey('proj')).toBe(false); // lowercase
-      expect(validateProjectKey('P-1')).toBe(false); // special char
-      expect(validateProjectKey('')).toBe(false);
-    });
-  });
-
-  describe('formatTaskKey', () => {
-    it('formats project key and task number', () => {
-      expect(formatTaskKey('MOB', 42)).toBe('MOB-42');
-      expect(formatTaskKey('op', 1)).toBe('OP-1');
-    });
-
-    it('uses fallback for missing project key', () => {
-      expect(formatTaskKey('', 10)).toBe('TASK-10');
-    });
-  });
-
-  describe('isTempTaskId', () => {
-    it('detects temp_ prefixed IDs', () => {
-      expect(isTempTaskId('temp_123456_abc')).toBe(true);
-      expect(isTempTaskId('#temp_123456_abc')).toBe(true);
-    });
-
-    it('detects temp- prefixed IDs', () => {
-      expect(isTempTaskId('temp-task-1')).toBe(true);
-      expect(isTempTaskId('#temp-task-1')).toBe(true);
-    });
-
-    it('returns false for permanent or invalid IDs', () => {
-      expect(isTempTaskId('task_123')).toBe(false);
-      expect(isTempTaskId('PROJ-1')).toBe(false);
-      expect(isTempTaskId(null)).toBe(false);
-      expect(isTempTaskId(undefined)).toBe(false);
-      expect(isTempTaskId('')).toBe(false);
-    });
-  });
-});
-

package/src/utils/key.ts

@@ -1,62 +0,0 @@
-/**
- * Generates a 2-6 character uppercase project short code/key from a project name.
- * e.g., "Mobile App" -> "MA", "Frontend Core" -> "FC", "Operative" -> "OPE".
- */
-export function generateProjectKey(name: string): string {
-  if (!name || !name.trim()) {
-    return 'PRJ';
-  }
-
-  const words = name.trim().split(/\s+/).filter(Boolean);
-  let rawKey = '';
-
-  if (words.length === 1) {
-    const word = words[0].replace(/[^a-zA-Z0-9]/g, '');
-    if (word.length <= 3) {
-      rawKey = word.toUpperCase();
-    } else {
-      rawKey = word.substring(0, 3).toUpperCase();
-    }
-  } else {
-    rawKey = words
-      .map((w) => w.replace(/[^a-zA-Z0-9]/g, '')[0] || '')
-      .join('')
-      .substring(0, 4)
-      .toUpperCase();
-  }
-
-  // Ensure key meets basic 2-6 char alphanumeric requirement
-  const cleanKey = rawKey.replace(/[^A-Z0-9]/g, '');
-  if (cleanKey.length >= 2 && cleanKey.length <= 6) {
-    return cleanKey;
-  }
-
-  return 'PRJ';
-}
-
-/**
- * Validates whether a given key meets project key format rules (2-6 uppercase alphanumeric characters).
- */
-export function validateProjectKey(key: string): boolean {
-  if (!key) return false;
-  return /^[A-Z0-9]{2,6}$/.test(key);
-}
-
-/**
- * Formats a task key using a project key and task index (e.g. "MOB-12").
- */
-export function formatTaskKey(projectKey: string, taskNumber: number): string {
-  const prefix = projectKey ? projectKey.toUpperCase() : 'TASK';
-  return `${prefix}-${taskNumber}`;
-}
-
-/**
- * Checks whether a given task ID represents a temporary/optimistic task
- * (e.g. temp_1790... or temp-task-...) while it is actively being created.
- */
-export function isTempTaskId(id?: string | null): boolean {
-  if (!id || typeof id !== 'string') return false;
-  const clean = id.trim().replace(/^#/, '');
-  return clean.startsWith('temp_') || clean.startsWith('temp-');
-}
-

package/src/utils/mentions.test.ts

@@ -1,132 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractMentions, parseMentionSegments, stripMarkdownCode } from './mentions.js';
-
-describe('mentions utility', () => {
-  describe('extractMentions', () => {
-    it('returns empty array for empty or non-string input', () => {
-      expect(extractMentions('')).toEqual([]);
-      expect(extractMentions(null as any)).toEqual([]);
-      expect(extractMentions(undefined as any)).toEqual([]);
-    });
-
-    it('extracts single mention', () => {
-      expect(extractMentions('Hello @planner, please review.')).toEqual(['planner']);
-    });
-
-    it('extracts multiple mentions and deduplicates them', () => {
-      const text = 'Hey @jane and @planner, can @jane check with @coordinator?';
-      expect(extractMentions(text)).toEqual(['jane', 'planner', 'coordinator']);
-    });
-
-    it('supports quoted handles with spaces', () => {
-      const text = 'Assigning to @"Agent Planner" and @"Jane Doe"';
-      expect(extractMentions(text)).toEqual(['Agent Planner', 'Jane Doe']);
-    });
-
-    it('ignores email addresses without leading space or boundary', () => {
-      const text = 'Send mail to user@example.com or ping @alex';
-      expect(extractMentions(text)).toEqual(['alex']);
-    });
-
-    it('handles mentions with dashes, underscores, and periods', () => {
-      const text = 'Call @agent-1, @super_user, and @john.doe';
-      expect(extractMentions(text)).toEqual(['agent-1', 'super_user', 'john.doe']);
-    });
-
-    it('correctly ignores trailing punctuation such as periods, commas, and exclamation marks', () => {
-      const text = 'Check with @turquoise. Then ping @john.doe! Also ask @coordinator, and @"Jane Doe".';
-      expect(extractMentions(text)).toEqual(['turquoise', 'john.doe', 'coordinator', 'Jane Doe']);
-    });
-
-    it('suppresses mentions inside fenced code blocks and inline backticks (UCH-128, UCH-138)', () => {
-      const markdown = `
-Hey @alice, please review this test output:
-\`\`\`ts
-import { describe } from '@vitest/runner';
-// mention in code comment: @bob
-const handler = () => '@charlie';
-\`\`\`
-Also do not match \`@david\` in inline backticks or ~~~@eva~~~ in tilde fences.
-Only real mentions like @frank should match.
-      `;
-      expect(extractMentions(markdown)).toEqual(['alice', 'frank']);
-    });
-
-    it('suppresses mentions inside HTML <pre> and <code> blocks', () => {
-      const html = 'Hello @alice! Check <pre>npm i @types/node</pre> and <code>@bob</code>. Thanks @charlie!';
-      expect(extractMentions(html)).toEqual(['alice', 'charlie']);
-    });
-
-    it('suppresses handles inside URLs and markdown link destinations', () => {
-      const text = 'Visit https://github.com/@org/repo and [profile](https://example.com/@jack) then ping @jack';
-      expect(extractMentions(text)).toEqual(['jack']);
-    });
-
-    it('preserves rich text HTML mention nodes while ignoring attributes', () => {
-      const html = '<p>Assigned to <span data-type="mention" data-label="Jane Doe" data-mention-suggestion-char="@">@Jane Doe</span> and ping @coordinator</p>';
-      expect(extractMentions(html)).toEqual(['Jane Doe', 'coordinator']);
-    });
-  });
-
-  describe('stripMarkdownCode', () => {
-    it('strips code blocks, tilde blocks, inline backticks, pre and code tags', () => {
-      const raw = 'Before ```code @foo``` and `inline @bar` and <pre>pre @baz</pre> and <code>c @qux</code> after @real';
-      expect(stripMarkdownCode(raw)).toBe('Before  and  and  and  after @real');
-    });
-  });
-
-  describe('parseMentionSegments', () => {
-    it('returns empty array for empty string', () => {
-      expect(parseMentionSegments('')).toEqual([]);
-    });
-
-    it('returns single text segment if no mentions', () => {
-      expect(parseMentionSegments('Just a normal comment without tags.')).toEqual([
-        { type: 'text', value: 'Just a normal comment without tags.' }
-      ]);
-    });
-
-    it('correctly segments text with single mention in the middle', () => {
-      const result = parseMentionSegments('Hello @planner, please check.');
-      expect(result).toEqual([
-        { type: 'text', value: 'Hello ' },
-        { type: 'mention', value: '@planner', handle: 'planner' },
-        { type: 'text', value: ', please check.' }
-      ]);
-    });
-
-    it('correctly segments mention with trailing period', () => {
-      const result = parseMentionSegments('Hello @turquoise.');
-      expect(result).toEqual([
-        { type: 'text', value: 'Hello ' },
-        { type: 'mention', value: '@turquoise', handle: 'turquoise' },
-        { type: 'text', value: '.' }
-      ]);
-    });
-
-    it('correctly segments text starting with a mention', () => {
-      const result = parseMentionSegments('@planner can you take a look?');
-      expect(result).toEqual([
-        { type: 'mention', value: '@planner', handle: 'planner' },
-        { type: 'text', value: ' can you take a look?' }
-      ]);
-    });
-
-    it('correctly segments text ending with a mention', () => {
-      const result = parseMentionSegments('Assigned to @coordinator');
-      expect(result).toEqual([
-        { type: 'text', value: 'Assigned to ' },
-        { type: 'mention', value: '@coordinator', handle: 'coordinator' }
-      ]);
-    });
-
-    it('correctly segments quoted mentions', () => {
-      const result = parseMentionSegments('Ping @"Agent Supervisor" ASAP');
-      expect(result).toEqual([
-        { type: 'text', value: 'Ping ' },
-        { type: 'mention', value: '@"Agent Supervisor"', handle: 'Agent Supervisor' },
-        { type: 'text', value: ' ASAP' }
-      ]);
-    });
-  });
-});

package/src/utils/mentions.ts

@@ -1,131 +0,0 @@
-export interface MentionSegment {
-  type: 'text' | 'mention';
-  value: string;
-  handle?: string;
-}
-
-/**
- * Regex matching mentions:
- * - Quoted mentions: @"Jane Doe", "Jane Doe"
- * - Standard handles: @planner, @user-1, @john.smith
- * Unquoted handles exclude trailing punctuation (e.g. @turquoise. matches handle "turquoise" without the dot).
- */
-export const MENTION_REGEX =
-  /(?:^|[\s>(*_"';\\/[\]{}~`:]|"|>|<|&)@(?:"([^"]+)"|"([^&]+)"|([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*))/g;
-
-/**
- * Strips code blocks and inline code from markdown or HTML content:
- * - Fenced code blocks: ```...``` and ~~~...~~~
- * - Inline backtick code: `...`
- * - HTML code/pre tags: <pre>...</pre>, <code>...</code>
- * Used to avoid false-positive mention parsing within code snippets, terminal logs, or stack traces.
- */
-export function stripMarkdownCode(content: string): string {
-  if (!content || typeof content !== 'string') return '';
-  return content
-    .replace(/```[\s\S]*?```/g, '')
-    .replace(/~~~[\s\S]*?~~~/g, '')
-    .replace(/<pre[\s\S]*?<\/pre>/gi, '')
-    .replace(/<code[\s\S]*?<\/code>/gi, '')
-    .replace(/`[^`\n]*`/g, '');
-}
-
-/**
- * Extracts unique mention handles from a text string, ignoring trailing punctuation,
- * code blocks or inline code snippets, URLs, markdown link destinations, and pre-existing HTML mention nodes.
- * Preserves the order of their first appearance.
- */
-export function extractMentions(content: string): string[] {
-  if (!content || typeof content !== 'string') return [];
-
-  // Normalize rich text mention nodes (e.g. from TipTap or custom mention spans)
-  const normalizedMentionNodes = content.replace(
-    /<span\b[^>]*\b(?:data-type=["']mention["']|class=["'][^"']*pixerate-mention-node[^"']*["'])[^>]*>([\s\S]*?)<\/span>/gi,
-    (match, inner) => {
-      const labelMatch = match.match(/\bdata-label=["']([^"']+)["']/i);
-      if (labelMatch) {
-        const val = labelMatch[1].trim();
-        return val.includes(' ') ? ` @"${val}" ` : ` @${val} `;
-      }
-      const idMatch = match.match(/\bdata-id=["']([^"']+)["']/i);
-      if (idMatch) {
-        const val = idMatch[1].trim();
-        return val.includes(' ') ? ` @"${val}" ` : ` @${val} `;
-      }
-      return ` ${inner} `;
-    }
-  );
-
-  const cleanContent = stripMarkdownCode(normalizedMentionNodes);
-  // Strip URLs and markdown link destinations so @package or @handles in URLs are not extracted as mentions
-  const withoutUrls = cleanContent
-    .replace(/(?:https?|ftp|file):\/\/[^\s<>()]+/gi, '')
-    .replace(/\]\([^)]*\)/g, ']');
-  // Strip remaining HTML tags
-  const textOnly = withoutUrls.replace(/<[^>]+>/g, ' ');
-
-  const mentions: string[] = [];
-  const seen = new Set<string>();
-
-  const regex = new RegExp(MENTION_REGEX.source, 'g');
-  let match: RegExpExecArray | null;
-
-  while ((match = regex.exec(textOnly)) !== null) {
-    const handle = (match[1] ?? match[2] ?? match[3] ?? '').trim();
-    if (handle && !seen.has(handle)) {
-      seen.add(handle);
-      mentions.push(handle);
-    }
-  }
-
-  return mentions;
-}
-
-/**
- * Segments a text string into plain text parts and mention tokens.
- * Useful for rendering highlighted mention badges or links in UI components.
- */
-export function parseMentionSegments(content: string): MentionSegment[] {
-  if (!content) return [];
-
-  const segments: MentionSegment[] = [];
-  const regex = new RegExp(MENTION_REGEX.source, 'g');
-  let lastIndex = 0;
-  let match: RegExpExecArray | null;
-
-  while ((match = regex.exec(content)) !== null) {
-    const fullMatch = match[0];
-    const atIndex = fullMatch.indexOf('@');
-    const prefix = atIndex > 0 ? fullMatch.slice(0, atIndex) : '';
-    const mentionToken = fullMatch.slice(atIndex);
-    const handle = match[1] ?? match[2] ?? match[3];
-    const matchStart = match.index + prefix.length;
-
-    // Push text before this mention if any
-    if (matchStart > lastIndex) {
-      segments.push({
-        type: 'text',
-        value: content.slice(lastIndex, matchStart)
-      });
-    }
-
-    // Push the mention token
-    segments.push({
-      type: 'mention',
-      value: mentionToken,
-      handle
-    });
-
-    lastIndex = matchStart + mentionToken.length;
-  }
-
-  // Push any remaining text after the last match
-  if (lastIndex < content.length) {
-    segments.push({
-      type: 'text',
-      value: content.slice(lastIndex)
-    });
-  }
-
-  return segments;
-}