@gitsense/gsc-utils 0.2.25 → 0.2.28

package/README.md

@@ -1,6 +1,6 @@
 # GitSense Chat Utils (gsc-utils)
 
-A comprehensive JavaScript library providing utilities for processing, manipulating, and managing various elements within GitSense Chat messages, including code blocks, patches, analyzers, and context data.
+A comprehensive JavaScript library providing utilities for processing, manipulating, and managing various elements within GitSense Chat messages, including code blocks, patches, analyzers, context data, and compacted messages.
 
 ## Code Structure
 
@@ -12,72 +12,193 @@ A comprehensive JavaScript library providing utilities for processing, manipulat
 ├── package.json
 ├── rollup.config.js
 ├── src
-│   ├── AnalysisBlockUtils.js
-│   ├── AnalyzerUtils
-│   │   ├── constants.js
-│   │   ├── contextMapper.js
-│   │   ├── dataValidator.js
-│   │   ├── defaultPromptLoader.js
-│   │   ├── discovery.js
-│   │   ├── index.js
-│   │   ├── instructionLoader.js
-│   │   ├── management.js
-│   │   ├── responseProcessor.js
-│   │   ├── saver.js
-│   │   └── schemaLoader.js
-│   ├── ChatUtils.js
-│   ├── CodeBlockUtils
-│   │   ├── blockExtractor.js
-│   │   ├── blockProcessor.js
-│   │   ├── constants.js
-│   │   ├── continuationUtils.js
-│   │   ├── headerParser.js
-│   │   ├── headerUtils.js
-│   │   ├── index.js
-│   │   ├── lineNumberFormatter.js
-│   │   ├── markerRemover.js
-│   │   ├── patchIntegration.js
-│   │   ├── relationshipUtils.js
-│   │   ├── updateCodeBlock.js
-│   │   └── uuidUtils.js
-│   ├── ConfigUtils.js
-│   ├── ContextUtils.js
-│   ├── EnvUtils.js
-│   ├── GSToolBlockUtils.js
-│   ├── GitSenseChatUtils.js
-│   ├── JsonUtils.js
-│   ├── LLMUtils.js
-│   ├── MessageUtils.js
-│   ├── PatchUtils
-│   │   ├── constants.js
-│   │   ├── diagnosticReporter.js
-│   │   ├── enhancedPatchProcessor.js
-│   │   ├── fuzzyMatcher.js
-│   │   ├── hunkCorrector.js
-│   │   ├── hunkValidator.js
-│   │   ├── index.js
-│   │   ├── patchExtractor.js
-│   │   ├── patchHeaderFormatter.js
-│   │   ├── patchParser.js
-│   │   ├── patchProcessor.js
-│   │   └── patchVerifier
-│   │       ├── constants.js
-│   │       ├── detectAndFixOverlappingHunks.js
-│   │       ├── detectAndFixRedundantChanges.js
-│   │       ├── formatAndAddLineNumbers.js
-│   │       ├── index.js
-│   │       ├── verifyAndCorrectHunkHeaders.js
-│   │       └── verifyAndCorrectLineNumbers.js
-│   └── SharedUtils
-│       ├── timestampUtils.js
-│       └── versionUtils.js
+│   ├── AnalysisBlockUtils.js
+│   ├── AnalyzerUtils
+│   │   ├── constants.js
+│   │   ├── contextMapper.js
+│   │   ├── dataValidator.js
+│   │   ├── defaultPromptLoader.js
+│   │   ├── discovery.js
+│   │   ├── index.js
+│   │   ├── instructionLoader.js
+│   │   ├── management.js
+│   │   ├── responseProcessor.js
+│   │   ├── saver.js
+│   │   └── schemaLoader.js
+│   ├── ChatUtils.js
+│   ├── CodeBlockUtils
+│   │   ├── blockExtractor.js
+│   │   ├── blockProcessor.js
+│   │   ├── constants.js
+│   │   ├── continuationUtils.js
+│   │   ├── headerParser.js
+│   │   ├── headerUtils.js
+│   │   ├── index.js
+│   │   ├── lineNumberFormatter.js
+│   │   ├── markerRemover.js
+│   │   ├── patchIntegration.js
+│   │   ├── relationshipUtils.js
+│   │   ├── updateCodeBlock.js
+│   │   └── uuidUtils.js
+│   ├── CompactChatUtils
+│   │   ├── index.js
+│   │   ├── ReferenceMessageUtils.js
+│   │   ├── CompactedMessageUtils.js
+│   │   └── README.md
+│   ├── ConfigUtils.js
+│   ├── ContextUtils.js
+│   ├── DateUtils.js
+│   ├── DomUtils.js
+│   ├── EnvUtils.js
+│   ├── FormatterUtils.js
+│   ├── GSToolBlockUtils.js
+│   ├── GitSenseChatUtils.js
+│   ├── JsonUtils.js
+│   ├── LanguageNameUtils.js
+│   ├── LLMUtils.js
+│   ├── MarkdownUtils.js
+│   ├── MetaRawResultUtils.js
+│   ├── MessageUtils.js
+│   ├── ObjectUtils.js
+│   ├── PatchUtils
+│   │   ├── constants.js
+│   │   ├── diagnosticReporter.js
+│   │   ├── enhancedPatchProcessor.js
+│   │   ├── fuzzyMatcher.js
+│   │   ├── hunkCorrector.js
+│   │   ├── hunkValidator.js
+│   │   ├── index.js
+│   │   ├── patchExtractor.js
+│   │   ├── patchHeaderFormatter.js
+│   │   ├── patchParser.js
+│   │   ├── patchProcessor.js
+│   │   └── patchVerifier
+│   │       ├── constants.js
+│   │       ├── detectAndFixOverlappingHunks.js
+│   │       ├── detectAndFixRedundantChanges.js
+│   │       ├── formatAndAddLineNumbers.js
+│   │       ├── index.js
+│   │       ├── verifyAndCorrectHunkHeaders.js
+│   │       └── verifyAndCorrectLineNumbers.js
+│   └── SharedUtils
+│       ├── stringUtils.js
+│       ├── timestampUtils.js
+│       └── versionUtils.js
 ```
 
 ## Core Modules
 
 ### GitSenseChatUtils (Main Interface)
 
-This is the primary class exported by the library, offering a unified API for interacting with the various utility modules. It aggregates functionalities from `CodeBlockUtils`, `PatchUtils`, `AnalyzerUtils`, `MessageUtils`, `LLMUtils`, `ConfigUtils`, and `EnvUtils`.
+This is the primary class exported by the library, offering a unified API for interacting with the various utility modules. It aggregates functionalities from `CodeBlockUtils`, `PatchUtils`, `AnalyzerUtils`, `MessageUtils`, `LLMUtils`, `ConfigUtils`, `EnvUtils`, `MetaRawResultUtils`, and `CompactChatUtils`.
+
+### CompactChatUtils
+
+A utility module for working with compacted messages in GitSense Chat. This module provides functionality for parsing reference messages, formatting compacted messages, and validating message formats.
+
+#### Overview
+
+CompactChatUtils is designed to handle the compact message workflow in GitSense Chat, which allows for efficient storage and retrieval of chat messages by compacting older messages while preserving context. The module consists of two main utility classes:
+
+- **ReferenceMessageUtils**: Parses reference messages that contain information about which messages to compact and which to keep as context
+- **CompactedMessageUtils**: Formats, parses, and validates compacted messages with standardized metadata headers
+
+#### Core Functions
+
+*   **`extractReferenceMessageData(referenceMessage)`**: Extracts all data from a reference message including session data, metadata, and message sections.
+*   **`parseMessageSection(section)`**: Parses a message section to extract individual messages.
+*   **`extractReferenceMessageMetadata(referenceMessage)`**: Extracts just the metadata from a reference message without the message sections.
+*   **`isReferenceMessage(message)`**: Checks if a message is a reference message.
+*   **`formatCompactedMessage(content, originalChatUuid, messageRange, options)`**: Formats a compacted message with standardized metadata headers.
+*   **`extractCompactedMessageMetadata(compactedMessage)`**: Extracts metadata from a compacted message.
+*   **`extractCompactedMessageContent(compactedMessage)`**: Extracts just the content portion from a compacted message (without metadata).
+*   **`validateCompactedMessageFormat(compactedMessage)`**: Validates that a compacted message follows the expected format.
+*   **`isCompactedMessage(message)`**: Checks if a message is a compacted message.
+*   **`isValidUUID(uuid)`**: Validates if a string is a valid UUID v4.
+*   **`isValidMessageRange(range)`**: Validates if a string is a valid message range (e.g., "3-6").
+*   **`isValidISOTimestamp(timestamp)`**: Validates if a string is a valid ISO 8601 timestamp.
+
+#### Usage Example
+
+```javascript
+const { CompactChatUtils } = require('@gitsense/gsc-utils');
+
+// Parse a reference message
+if (CompactChatUtils.isReferenceMessage(message)) {
+  const data = CompactChatUtils.extractReferenceMessageData(message);
+  console.log(`Original Chat UUID: ${data.originalChatUuid}`);
+  console.log(`Messages to compact: ${data.messagesToCompact.length}`);
+}
+
+// Format a compacted message
+const compactedMessage = CompactChatUtils.formatCompactedMessage(
+  "This is the compacted content...",
+  "123e4567-e89b-12d3-a456-426614174000",
+  "3-6"
+);
+
+// Validate a compacted message
+const validation = CompactChatUtils.validateCompactedMessageFormat(compactedMessage);
+if (!validation.isValid) {
+  console.error("Validation errors:", validation.errors);
+}
+```
+
+### MetaRawResultUtils
+
+Provides utilities for parsing and extracting file metadata mappings from `meta-raw-result` messages in GitSense Chat. These utilities are essential for validating chat ID references in AI-generated context bundles and providing file information for metadata-driven workflows.
+
+#### Core Functions
+
+*   **`extractMetaRawResultMappings(chat, model)`**: The primary function for processing all messages in a chat and extracting mappings from `meta-raw-result` messages. It returns a Map of chatId to file metadata objects, enabling validation of chat ID references and providing comprehensive file information.
+*   **`isMetaRawResultMessage(message)`**: Validates whether a given message object represents a `meta-raw-result` message by checking the message type and content indicators like `profile:meta-raw` and the presence of data sections.
+*   **`parseMetaRawResultContent(messageContent)`**: Parses the content of a single `meta-raw-result` message to extract chat ID to file metadata mappings. Handles the markdown table format used in these messages.
+*   **`parseTableRow(rowLine)`**: Parses a single table row from `meta-raw-result` content, extracting file information like chat ID, path, repository, branch, language, size, and tokens.
+*   **`parseSize(sizeStr)`**: Converts size strings (e.g., "1.2 KB", "500 B") to bytes for consistent numerical processing.
+*   **`parseTokens(tokensStr)`**: Converts token strings (e.g., "1.2k", "500") to numerical token counts for analysis and validation.
+
+#### Mapping Structure
+
+The utility returns mappings with the following structure:
+```javascript
+{
+    chatId: {
+        id: number,              // The chat ID
+        name: string,            // File name
+        path: string,            // File path (repo/path)
+        repo: string,            // Repository name
+        branch: string,          // Branch name
+        language: string,        // File language
+        size: number,            // File size in bytes
+        tokens: number,          // Token count
+        commitHash: string,      // Last commit hash
+        commitTimestamp: number, // Unix timestamp
+        analyzedTimestamp: string, // ISO timestamp of last analysis
+        fullPath: string         // Full path including repo
+    }
+}
+```
+
+#### Usage Example
+
+```javascript
+const { MetaRawResultUtils } = require('@gitsense/gsc-utils');
+
+// Extract all meta-raw-result mappings from a chat
+const mappings = MetaRawResultUtils.extractMetaRawResultMappings(chat, message.model);
+
+// Validate a chat ID reference
+if (mappings.has(chatId)) {
+    const fileInfo = mappings.get(chatId);
+    console.log(`Valid file: ${fileInfo.fullPath} (${fileInfo.size} bytes)`);
+}
+
+// Check if a message is a meta-raw-result message
+if (MetaRawResultUtils.isMetaRawResultMessage(message)) {
+    const contentMappings = MetaRawResultUtils.parseMetaRawResultContent(message.message);
+    // Process individual message mappings
+}
+```
 
 ### CodeBlockUtils
 
@@ -243,6 +364,7 @@ Provides a suite of utilities for managing and interacting with GitSense Chat an
 
 *   **`getAnalyzers(basePath, options)`**: Discovers and lists all available analyzers by traversing the directory structure under `basePath`. An analyzer is considered valid if its corresponding `1.md` instruction file exists. The `options` parameter can include `includeDescription` to optionally load the analyzer's description from its JSON metadata.
 *   **`getAnalyzerSchema(basePath, analyzerId)`**: Retrieves the JSON schema for a specific analyzer identified by `analyzerId`. It reads the corresponding `1.md` file, extracts the JSON block, and deduces schema types from the metadata fields.
+*   **`getAnalyzerConfigMetadata(basePath, analyzerId)`**: Retrieves the configuration metadata (description, version, tags) for a specific analyzer identified by `analyzerId`. It reads the corresponding `1.md` file and extracts the top-level properties from the JSON block.
 *   **`getAnalyzerInstructionsContent(basePath, analyzerId)`**: Loads the raw Markdown content of a specific analyzer's `1.md` instruction file based on its `analyzerId`.
 *   **`saveConfiguration(basePath, analyzerId, instructionsContent, options)`**: Saves or updates an analyzer configuration. It parses the `analyzerId` to determine the directory structure, creates directories if necessary, and saves the `instructionsContent` to `1.md`. It can optionally ensure `config.json` files exist in the analyzer, content, and instructions directories.
 *   **`deleteAnalyzer(basePath, analyzerId)`**: Deletes a specific analyzer configuration and intelligently cleans up empty directories. It checks for protection at all levels (analyzer, content type, instructions type) before deletion.
@@ -341,6 +463,7 @@ Provides utility functions for parsing and formatting context message sections.
 *   **`parseContextSection(sectionText)`**: Parses the details (name, path, chat ID, etc.) and code content from a single context message section.
 *   **`extractContextSections(messageContent)`**: Extracts and parses all context sections from a full context message string.
 *   **`extractContextItemsOverviewTableRows(messageContent)`**: Parses the table rows from a Context Items Overview message.
+*   **`getContextFiles(chat)`**: Extracts all context files from a given chat object.
 *   **`formatContextContent(items, contentType, contentOption)`**: Formats an array of loaded items into a structured context message string suitable for LLM consumption.
 
 ### AnalysisBlockUtils
@@ -354,6 +477,121 @@ Provides utilities for identifying, parsing, and validating structured analysis
 *   **`parseOverviewMetadata(content)`**: Parses the metadata fields from an analysis block's content, assuming a Markdown list format.
 *   **`validateAnalysisMetadata(metadata)`**: Validates the parsed analysis metadata object, checking for required fields like 'Chat ID'.
 
+### ChatUtils
+
+Provides utility functions for analyzing and classifying chat sessions based on message content and structure.
+
+#### Core Functions
+
+*   **`isAskChat(chat, model)`**: Determines if the current chat session appears to be an "Ask" session.
+*   **`isNewAnalyzerChat(chat, model)`**: Determines if the current chat session appears to be a "New Analyzer" session.
+*   **`isAnalyzeChat(chat)`**: Determines if the current chat session appears to be an "Analyze" session.
+*   **`isAnalyzeBuilderChat(chat)`**: Determines if the current chat session appears to be an "Analyze Builder" session.
+*   **`isPlanChat(chat, model)`**: Determines if the current chat session appears to be a "Plan Chat" session.
+*   **`isCodeChat(chat, model)`**: Determines if the current chat session appears to be a "Code Chat" session.
+*   **`getChatMessages(chat, model)`**: Retrieves all messages from a chat session.
+
+### DateUtils
+
+Provides date formatting and manipulation utilities for GitSense Chat.
+
+#### Core Functions
+
+*   **`formatAge(dateString)`**: Formats a date string into a relative time string (e.g., "5m ago").
+*   **`isValidDateString(dateString)`**: Validates a date string format.
+*   **`compareDates(dateA, dateB)`**: Compares two date strings.
+*   **`normalizeDateTime(dateString)`**: Ensures a date string has a timezone indicator.
+*   **`getTimeDifference(dateString)`**: Calculates the time difference between now and a given date.
+*   **`formatTimeDifference(diff)`**: Formats a time difference in seconds to a human-readable string.
+
+### DomUtils
+
+Provides helper functions for creating and manipulating DOM elements.
+
+#### Core Functions
+
+*   **`h.createElement(type, params)`**: Creates a new DOM element with specified attributes and properties.
+*   **`h.createDiv(params)`**, **`h.createSpan(params)`**, **`h.createP(params)`**, etc.: Factory methods for creating common HTML elements.
+*   **`h.updateDOM(sourceNode, targetNode)`**: Efficiently updates a target DOM node to match a source node.
+*   **`h.safeEscape(html)`**: Escapes HTML in a string, preserving content within specified tags.
+*   **`h.injectStyles(cssString, id)`**: Injects CSS styles into the document head.
+*   **`h.getDistanceFromViewportEdge(elem, edge)`**: Calculates the distance from an element to the viewport edge.
+
+### LanguageNameUtils
+
+Utility for converting common lowercase language names and aliases to their proper capitalization.
+
+#### Core Functions
+
+*   **`normalizeLanguageName(language)`**: Normalizes a language name or alias to its proper capitalization.
+*   **`isKnownLanguage(language)`**: Checks if a language name or alias is known to the normalizer.
+*   **`getKnownLanguageAliases()`**: Gets all known language aliases.
+*   **`getLanguageNameMap()`**: Gets the mapping of language aliases to their normalized names.
+
+### ObjectUtils
+
+Utility functions for processing and manipulating JavaScript objects.
+
+#### Core Functions
+
+*   **`trimObjectStrings(obj, maxLength, suffix)`**: Recursively trims string properties in an object to a maximum length.
+
+### SVGUtils
+
+Utility module for creating and managing SVG elements. Provides factory methods for generating common SVG icons and elements with customizable parameters.
+
+#### Core Functions
+
+*   **`SVGUtils.create(xml, params, xmlOnly)`**: Creates an SVG element from an XML string.
+*   **`SVGUtils.aiModel(params)`**, **`SVGUtils.alert(params)`**, **`SVGUtils.apps(params)`**, etc.: Factory methods for generating a wide variety of SVG icons.
+
+### MarkdownUtils
+
+Provides utilities for configuring and using markdown-it with highlight.js for rendering Markdown content with syntax highlighting.
+
+#### Core Functions
+
+*   **`createMarkdownRenderer(hljs, hstyle, nhstyle)`**: Creates a configured markdown renderer instance.
+*   **`removeSignature(body)`**: Removes any existing LLM author signature from rendered markdown HTML.
+
+### FormatterUtils
+
+Utility functions for formatting content in GitSense Chat.
+
+#### Core Functions
+
+*   **`formatBytes(bytes)`**: Formats bytes into human-readable string (KB, MB, GB).
+*   **`formatTokens(count)`**: Formats token count into human-readable string (k, m, b).
+
+### SharedUtils
+
+Provides a collection of utility functions for common tasks shared across different parts of the GitSense Chat system.
+
+#### String Utilities
+
+*   **`splitWithLimit(text, delimiter, limit)`**: Splits a string into an array of substrings based on a delimiter, up to a specified limit.
+*   **`capitalize(text)`**: Capitalizes the first character of a string.
+*   **`titleCase(text)`**: Converts a string to title case (capitalizing the first letter of each word).
+*   **`camelCase(text)`**: Converts a string to camelCase.
+*   **`pascalCase(text)`**: Converts a string to PascalCase.
+*   **`kebabCase(text)`**: Converts a string to kebab-case.
+*   **`snakeCase(text)`**: Converts a string to snake_case.
+*   **`constantCase(text)`**: Converts a string to CONSTANT_CASE.
+*   **`trimWhitespace(text)`**: Trims leading and trailing whitespace and normalizes internal whitespace.
+*   **`truncate(text, maxLength, suffix)`**: Truncates a string to a specified maximum length and appends a suffix if truncated.
+*   **`escapeHtml(text)`**: Escapes HTML characters in a string to prevent them from being interpreted as HTML.
+*   **`stripHtml(text)`**: Removes HTML tags from a string.
+*   **`isValidEmail(email)`**: Performs a basic check to see if a string looks like a valid email address.
+
+#### Timestamp Utilities
+
+*   **`formatTimestamp(timestamp)`**: Formats a timestamp in a human-readable format.
+
+#### Version Utilities
+
+*   **`isValidVersion(version)`**: Validates version string format (X.Y.Z).
+*   **`incrementVersion(version, type)`**: Increments a semantic version string.
+
 ## Usage
 
 To use the GitSense Chat Utils library in your project, you can import the main interface class or individual modules/functions as needed.
@@ -376,6 +614,15 @@ const { text: fixedText, modified } = utils.fixTextCodeBlocks(markdownText);
 
 // Example: Check if a code block is a patch
 const isPatch = utils.isPatchBlock(codeBlockContentString);
+
+// Example: Extract meta-raw-result mappings
+const mappings = utils.extractMetaRawResultMappings(chat, message.model);
+
+// Example: Parse a reference message
+if (utils.isReferenceMessage(message)) {
+  const data = utils.extractReferenceMessageData(message);
+  console.log(`Original Chat UUID: ${data.originalChatUuid}`);
+}
 ```
 
 ### Individual Modules
@@ -394,7 +641,17 @@ const { JsonUtils } = require('@gitsense/gsc-utils');
 const { GSToolBlockUtils } = require('@gitsense/gsc-utils');
 const { ContextUtils } = require('@gitsense/gsc-utils');
 const { AnalysisBlockUtils } = require('@gitsense/gsc-utils');
+const { SharedUtils } = require('@gitsense/gsc-utils');
+const { SVGUtils } = require('@gitsense/gsc-utils');
+const { ObjectUtils } = require('@gitsense/gsc-utils');
+const { LanguageNameUtils } = require('@gitsense/gsc-utils');
+const { DomUtils } = require('@gitsense/gsc-utils');
+const { DateUtils } = require('@gitsense/gsc-utils');
 const { ChatUtils } = require('@gitsense/gsc-utils');
+const { MarkdownUtils } = require('@gitsense/gsc-utils');
+const { FormatterUtils } = require('@gitsense/gsc-utils');
+const { MetaRawResultUtils } = require('@gitsense/gsc-utils');
+const { CompactChatUtils } = require('@gitsense/gsc-utils');
 
 // Example: Using CodeBlockUtils directly
 const { blocks, warnings } = CodeBlockUtils.extractCodeBlocks(markdownText);
@@ -407,6 +664,31 @@ const analyzers = AnalyzerUtils.getAnalyzers('/path/to/analyzers');
 
 // Example: Using MessageUtils directly
 const messages = MessageUtils.getChatTemplateMessages('/path/to/messages', 'draft');
+
+// Example: Using SharedUtils directly
+const camelCaseText = SharedUtils.camelCase('hello world text');
+
+// Example: Using SVGUtils directly
+const svgIcon = SVGUtils.aiModel({ width: 24, height: 24 });
+
+// Example: Using DateUtils directly
+const ageString = DateUtils.formatAge('2025-10-31T12:00:00.000Z');
+
+// Example: Using MetaRawResultUtils directly
+const mappings = MetaRawResultUtils.extractMetaRawResultMappings(chat, message.model);
+if (mappings.has(chatId)) {
+    const fileInfo = mappings.get(chatId);
+    console.log(`Valid file: ${fileInfo.fullPath}`);
+}
+
+// Example: Using CompactChatUtils directly
+const { ReferenceMessageUtils, CompactedMessageUtils } = CompactChatUtils;
+const referenceData = ReferenceMessageUtils.extractReferenceMessageData(referenceMessage);
+const compactedMessage = CompactedMessageUtils.formatCompactedMessage(
+  content, 
+  originalChatUuid, 
+  messageRange
+);
 ```
 
 ### Individual Functions
@@ -421,7 +703,18 @@ const {
   getAnalyzers,
   getChatTemplateMessages,
   applyPatchWithDiagnostics,
-  estimateTokens
+  estimateTokens,
+  capitalize,
+  isValidVersion,
+  formatAge,
+  normalizeLanguageName,
+  trimObjectStrings,
+  extractMetaRawResultMappings,
+  isMetaRawResultMessage,
+  parseMetaRawResultContent,
+  extractReferenceMessageData,
+  formatCompactedMessage,
+  validateCompactedMessageFormat
 } = require('@gitsense/gsc-utils');
 
 // Example: Extract code blocks
@@ -429,4 +722,29 @@ const { blocks, warnings } = extractCodeBlocks(markdownText);
 
 // Example: Estimate tokens
 const tokenCount = estimateTokens("Sample text for token estimation.");
+
+// Example: Capitalize a string
+const capitalizedText = capitalize("hello world");
+
+// Example: Validate a version string
+const isValid = isValidVersion("1.2.3");
+
+// Example: Format a date
+const age = formatAge('2025-10-31T12:00:00.000Z');
+
+// Example: Normalize a language name
+const langName = normalizeLanguageName('javascript'); // Returns 'JavaScript'
+
+// Example: Extract meta-raw-result mappings
+const mappings = extractMetaRawResultMappings(chat, message.model);
+
+// Example: Parse a reference message
+const referenceData = extractReferenceMessageData(referenceMessage);
+
+// Example: Format a compacted message
+const compactedMessage = formatCompactedMessage(
+  content, 
+  originalChatUuid, 
+  messageRange
+);
 ```