@gitsense/gsc-utils 0.2.25 → 0.2.27

package/dist/gsc-utils.esm.js

@@ -43,8 +43,8 @@ function getAugmentedNamespace(n) {
  * Authors: Claude 3.7 Sonnet (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Flash Thinking (v1.2.0)
  */
 
-const fs$8 = require$$0;
-const path$6 = require$$1;
+const fs$9 = require$$0;
+const path$7 = require$$1;
 const ANALYZE_MESSAGE_REGEXP = /^# Analyze - `([^`]+)`\n/;
 
 /**
@@ -78,12 +78,12 @@ function unescapeCodeBlocks(content) {
  * @returns {Array} An array of message objects with role and content properties
  */
 function getChatTemplateMessages$1(dirname, messageType) {
-    const messagesDir = messageType ? path$6.join(dirname, messageType) : dirname;
+    const messagesDir = messageType ? path$7.join(dirname, messageType) : dirname;
     const messages = [];
 
     try {
         // Read all files in the directory
-        const files = fs$8.readdirSync(messagesDir);
+        const files = fs$9.readdirSync(messagesDir);
 
         // Sort files numerically (1.md, 2.md, etc.)
         const sortedFiles = files.sort((a, b) => {
@@ -94,9 +94,9 @@ function getChatTemplateMessages$1(dirname, messageType) {
 
         // Process each file
         for (const file of sortedFiles) {
-            if (path$6.extname(file) === '.md') {
-                const filePath = path$6.join(messagesDir, file);
-                const fileContent = fs$8.readFileSync(filePath, 'utf8');
+            if (path$7.extname(file) === '.md') {
+                const filePath = path$7.join(messagesDir, file);
+                const fileContent = fs$9.readFileSync(filePath, 'utf8');
 
                 // Split by triple newline to separate metadata from content
                 const parts = fileContent.split('\n\n\n');
@@ -396,7 +396,7 @@ function getMessageContentType$1(messageContent) {
         return 'regular'; // Handle non-string input gracefully
     }
     const trimmedContent = messageContent.trimStart(); // Check from the beginning, ignoring leading whitespace
-    if (trimmedContent.startsWith('## FILE CONTENT')) {
+    if (trimmedContent.startsWith('## FILE CONTENT') || trimmedContent.startsWith('## REFERENCE FILE CONTENT')) {
         return 'file-content-context';
     } else if (trimmedContent.startsWith('## OVERVIEW')) {
         return 'overview-context';
@@ -617,7 +617,7 @@ function getChatMessages$1(chat, model) {
     return getMessagesBeforeId$1(model || chat.main_model, chat.messages[0], null);
 }
 
-var ChatUtils$1 = {
+var ChatUtils$2 = {
     isAskChat,
     isNewAnalyzerChat,
     isAnalyzeChat,
@@ -689,7 +689,7 @@ const COMMENT_STYLES$3 = {
     'vbscript': { type: 'apostrophe' }
 };
 
-var constants$2 = {
+var constants$3 = {
     COMMENT_STYLES: COMMENT_STYLES$3
 };
 
@@ -708,7 +708,7 @@ var constants$2 = {
  * Generates a valid RFC 4122 UUID v4
  * @returns {string} A valid UUID v4
  */
-function generateUUID$3() {
+function generateUUID$2() {
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
         const r = Math.random() * 16 | 0;
         const v = c === 'x' ? r : (r & 0x3 | 0x8);
@@ -727,7 +727,7 @@ function validateUUID$4(uuid) {
     if (!uuidPattern.test(uuid)) {
         return {
             "Block-UUID": "INVALID UUID",
-            "Correct Block-UUID": generateUUID$3()
+            "Correct Block-UUID": generateUUID$2()
         };
     }
 
@@ -737,7 +737,7 @@ function validateUUID$4(uuid) {
 }
 
 var uuidUtils = {
-    generateUUID: generateUUID$3,
+    generateUUID: generateUUID$2,
     validateUUID: validateUUID$4
 };
 
@@ -869,7 +869,7 @@ var lineNumberFormatter = {
  */
 
 // Dependencies from other modules within CodeBlockUtils
-const { COMMENT_STYLES: COMMENT_STYLES$2 } = constants$2;
+const { COMMENT_STYLES: COMMENT_STYLES$2 } = constants$3;
 const { removeLineNumbers: removeLineNumbers$9 } = lineNumberFormatter; // Assuming this utility exists
 const { validateUUID: validateUUID$3 } = uuidUtils; // Assuming uuidUtils.js is in the same directory
 
@@ -1538,24 +1538,63 @@ function isValidVersion$1(version) {
 var versionUtils = {
     isValidVersion: isValidVersion$1};
 
+/**
+ * Component: PatchUtils Constants
+ * Block-UUID: c6747054-2c8b-461f-910d-0fd725d9a350
+ * Parent-UUID: 32adc00e-7509-4219-8e40-6c1319371db9
+ * Version: 2.1.0
+ * Description: Contains shared constants and regular expressions used by the enhanced patch utilities.
+ * Language: JavaScript
+ * Created-at: 2025-05-14T16:55:00.000Z
+ * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Claude 3.7 Sonnet (v2.0.0), Qwen 3 Coder 480B - Cerebras (v2.1.0)
+ */
+
+// Traditional patch markers
+const PATCH_START_MARKER$1 = '# --- PATCH START MARKER ---';
+const PATCH_END_MARKER$1 = '# --- PATCH END MARKER ---';
+
+// Abbreviated patch markers
+const ABBREVIATED_PATCH_START_MARKER$1 = '# --- ABBREVIATED PATCH START MARKER ---';
+const ABBREVIATED_PATCH_END_MARKER$1 = '# --- ABBREVIATED PATCH END MARKER ---';
+
+// Patch metadata header
+const PATCH_METADATA_HEADER$1 = '# Patch Metadata';
+
+// Diff file headers
+const ORIGINAL_FILE_HEADER$1 = '--- Original';
+const MODIFIED_FILE_HEADER$1 = '+++ Modified';
+
+var constants$2 = {
+    PATCH_START_MARKER: PATCH_START_MARKER$1,
+    PATCH_END_MARKER: PATCH_END_MARKER$1,
+    ABBREVIATED_PATCH_START_MARKER: ABBREVIATED_PATCH_START_MARKER$1,
+    ABBREVIATED_PATCH_END_MARKER: ABBREVIATED_PATCH_END_MARKER$1,
+    PATCH_METADATA_HEADER: PATCH_METADATA_HEADER$1,
+    ORIGINAL_FILE_HEADER: ORIGINAL_FILE_HEADER$1,
+    MODIFIED_FILE_HEADER: MODIFIED_FILE_HEADER$1
+};
+
 /**
  * Component: PatchUtils Parser
  * Block-UUID: ce634df9-ff99-482a-a261-56ab34a2546e
  * Parent-UUID: fcc85ec1-0146-40bf-a937-6f7928258cbf
- * Version: 1.1.0
- * Description: Handles parsing, validation, extraction, and detection of traditional unified diff patches. Extracts metadata and raw diff content.
+ * Version: 1.2.0
+ * Description: Handles parsing, validation, extraction, and detection of traditional unified diff patches and abbreviated patches. Extracts metadata and raw diff content.
  * Language: JavaScript
  * Created-at: 2025-04-18T02:59:04.322Z
- * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0)
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Qwen 3 Coder 480B - Cerebras (v1.2.0)
  */
 
 const { isValidVersion } = versionUtils; // Assuming SharedUtils is one level up
+const { PATCH_START_MARKER, PATCH_END_MARKER, PATCH_METADATA_HEADER, 
+        ORIGINAL_FILE_HEADER, MODIFIED_FILE_HEADER, ABBREVIATED_PATCH_START_MARKER, 
+        ABBREVIATED_PATCH_END_MARKER } = constants$2;
 
 /**
  * Determines the type of patch format used based on markers.
- * Primarily looks for traditional unified diff markers after metadata.
+ * Looks for traditional unified diff markers or abbreviated patch markers.
  * @param {string} patchText - The patch text
- * @returns {string} 'traditional', or 'unknown'
+ * @returns {string} 'traditional', 'abbreviated', or 'unknown'
  */
 function determinePatchFormat$1(patchText) {
     if (!patchText || typeof patchText !== 'string') {
@@ -1563,29 +1602,33 @@ function determinePatchFormat$1(patchText) {
     }
 
     // Check for required metadata header first
-    if (!patchText.includes('# Patch Metadata')) {
+    if (!patchText.includes(PATCH_METADATA_HEADER)) {
         return 'unknown'; // Must have metadata header
     }
 
     // Check for traditional unified diff markers *after* potential metadata and start marker
     // Look for ---, +++, @@ after the start marker
-    const startMarkerIndex = patchText.indexOf('# --- PATCH START MARKER ---');
-    if (startMarkerIndex === -1) {
-        return 'unknown'; // Must have start marker
-    }
+    const traditionalStartMarkerIndex = patchText.indexOf(PATCH_START_MARKER);
+    if (traditionalStartMarkerIndex !== -1) {
+        const contentAfterMarker = patchText.substring(traditionalStartMarkerIndex);
 
-    const contentAfterMarker = patchText.substring(startMarkerIndex);
+        // Use regex for more reliable detection within the content part
+        const traditionalMarkers = /^\s*--- Original\s*\n\s*\+\+\+ Modified\s*\n\s*@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/m;
 
-    // Use regex for more reliable detection within the content part
-    const traditionalMarkers = /^\s*--- Original\s*\n\s*\+\+\+ Modified\s*\n\s*@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/m;
+        if (traditionalMarkers.test(contentAfterMarker)) {
+            return 'traditional';
+        }
+    }
 
-    if (traditionalMarkers.test(contentAfterMarker)) {
-        return 'traditional';
+    // Check for abbreviated patch markers
+    const abbreviatedStartMarkerIndex = patchText.indexOf(ABBREVIATED_PATCH_START_MARKER);
+    if (abbreviatedStartMarkerIndex !== -1) {
+        return 'abbreviated';
     }
 
     // Removed check for obsolete '@=' context marker
 
-    return 'unknown'; // Format doesn't match expected traditional structure after markers
+    return 'unknown'; // Format doesn't match expected structures after markers
 }
 
 /**
@@ -1606,7 +1649,8 @@ function extractPatchMetadata$1(patchText) {
         const trimmedLine = line.trim();
 
         // Stop processing metadata if we hit content markers or the start marker
-        if (trimmedLine === '# --- PATCH START MARKER ---' ||
+        if (trimmedLine === PATCH_START_MARKER ||
+            trimmedLine === ABBREVIATED_PATCH_START_MARKER ||
             line.startsWith('--- ') || // Standard diff header start
             line.startsWith('+++ ') || // Standard diff header start
             line.startsWith('@@ '))   // Standard diff hunk header start
@@ -1628,7 +1672,7 @@ function extractPatchMetadata$1(patchText) {
                 }
             }
             // Allow lines that are just comments (e.g., # Description continued)
-        } else if (trimmedLine !== '' && !trimmedLine.startsWith('# Patch Metadata')) {
+        } else if (trimmedLine !== '' && !trimmedLine.startsWith(PATCH_METADATA_HEADER)) {
             break;
         }
     }
@@ -1669,11 +1713,11 @@ function validatePatchMetadata$1(metadata) {
     }
 
     // Validate UUIDs are not the template string
-    if (metadata['Source-Block-UUID'] === '12d8a596-0620-4725-ba49-ae6fccdfa2ad') {
-        errors.push('Source-Block-UUID contains placeholder value "f016e2e4-f97f-4ffe-9f46-ea48f59a3eea".');
+    if (metadata['Source-Block-UUID'] === '{{GS-UUID}}') {
+        errors.push('Source-Block-UUID contains placeholder value "{{GS-UUID}}".');
     }
-     if (metadata['Target-Block-UUID'] === '5bfb717c-aaec-462e-a50e-d096aba0d63f') {
-        errors.push('Target-Block-UUID contains placeholder value "12e76392-f0ac-4c9d-a5be-c98401487352".');
+     if (metadata['Target-Block-UUID'] === '{{GS-UUID}}') {
+        errors.push('Target-Block-UUID contains placeholder value "{{GS-UUID}}".');
     }
 
     return errors;
@@ -1686,23 +1730,34 @@ function validatePatchMetadata$1(metadata) {
  * @param {string} format - Expected format (should be 'traditional').
  * @returns {string} Raw unified diff content, or empty string if not found/invalid.
  */
-function extractPatchContent$1(patchText, format) {
-    if (!patchText || format !== 'traditional') {
+function extractPatchContent$1(patchText, format = 'traditional') {
+    if (!patchText) {
         return "";
     }
 
     const lines = patchText.split('\n');
-
     let contentLines = [];
     let inContentBlock = false;
+    let startMarker, endMarker;
+
+    // Determine which markers to look for based on format
+    if (format === 'traditional') {
+        startMarker = PATCH_START_MARKER;
+        endMarker = PATCH_END_MARKER;
+    } else if (format === 'abbreviated') {
+        startMarker = ABBREVIATED_PATCH_START_MARKER;
+        endMarker = ABBREVIATED_PATCH_END_MARKER;
+    } else {
+        return ""; // Unsupported format
+    }
 
     for (const line of lines) {
-        if (line.trim() === '# --- PATCH START MARKER ---') {
+        if (line.trim() === startMarker) {
             inContentBlock = true;
             continue; // Skip the marker line itself
         }
 
-        if (line.trim() === '# --- PATCH END MARKER ---') {
+        if (line.trim() === endMarker) {
             inContentBlock = false;
             break; // Stop processing once end marker is found
         }
@@ -1741,23 +1796,25 @@ function detectPatch(messageText) {
     }
 
     // Find the first code block that contains patch metadata
-    // Regex looks for ``` optionally followed by 'diff' language hint
-    const codeBlockRegex = /```(?:diff)?\s*\n([\s\S]*?)```/g;
+    // Regex looks for ``` optionally followed by language hint
+    const codeBlockRegex = /```([a-zA-Z0-9#+_-]*)?\s*\n([\s\S]*?)```/g;
     let match;
     while ((match = codeBlockRegex.exec(messageText)) !== null) {
-        const blockContent = match[1];
+        const language = match[1] || '';
+        const blockContent = match[2];
         if (isPatchBlock$1(blockContent)) { // Use isPatchBlock for check
              const metadata = extractPatchMetadata$1(blockContent); // Use extractPatchMetadata
              // Basic validation: Check for essential UUIDs
              if (metadata['Source-Block-UUID'] && metadata['Target-Block-UUID'] &&
-                 metadata['Source-Block-UUID'] !== '26f930c9-2bc8-4906-bdf5-469700b2f857' && // Check placeholders
-                 metadata['Target-Block-UUID'] !== '48a957eb-dd72-44bb-84a2-0df3c7cb16ed')
+                 metadata['Source-Block-UUID'] !== '{{GS-UUID}}' && // Check placeholders
+                 metadata['Target-Block-UUID'] !== '{{GS-UUID}}')
              {
                  return {
                      patchText: blockContent, // Return the content inside the fence
                      metadata,
                      sourceBlockUUID: metadata['Source-Block-UUID'],
                      targetBlockUUID: metadata['Target-Block-UUID'],
+                     language: language,
                      startIndex: match.index, // Store block position if needed
                      endIndex: match.index + match[0].length
                  };
@@ -1779,25 +1836,28 @@ function findAllPatches(messageText) {
     }
 
     const patches = [];
-    const codeBlockRegex = /```(?:diff)?\s*\n([\s\S]*?)```/g;
+    // Find code blocks with any language identifier
+    const codeBlockRegex = /```([a-zA-Z0-9#+_-]*)?\s*\n([\s\S]*?)```/g;
 
     let match;
     while ((match = codeBlockRegex.exec(messageText)) !== null) {
-        const blockContent = match[1];
+        const language = match[1] || '';
+        const blockContent = match[2];
 
         if (isPatchBlock$1(blockContent)) {
             const metadata = extractPatchMetadata$1(blockContent);
 
             // Basic validation: Check for essential UUIDs and non-placeholder values
             if (metadata['Source-Block-UUID'] && metadata['Target-Block-UUID'] &&
-                metadata['Source-Block-UUID'] !== 'e898f14f-14f6-4710-b35b-1cf3478fb5da' &&
-                metadata['Target-Block-UUID'] !== '0093be2a-fd84-4925-a0c1-13f8a8260cbf')
+                metadata['Source-Block-UUID'] !== '{{GS-UUID}}' &&
+                metadata['Target-Block-UUID'] !== '{{GS-UUID}}')
             {
                 patches.push({
                     patchText: blockContent,
                     metadata,
                     sourceBlockUUID: metadata['Source-Block-UUID'],
                     targetBlockUUID: metadata['Target-Block-UUID'],
+                    language: language,
                     startIndex: match.index,
                     endIndex: match.index + match[0].length
                 });
@@ -2867,7 +2927,7 @@ var detectAndFixRedundantChanges_1 = {
 
 /**
  * Component: PatchUtils Detect and Fix Overlapping Hunks
- * Block-UUID: 0e1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5d
+ * Block-UUID: 7324dab8-24ae-4a42-9dc3-766e69104ef6
  * Parent-UUID: 2308ed72-91ff-48ba-bc80-310c23c01ff1
  * Version: 1.0.0
  * Description: Detects and optionally fixes overlapping hunks in a patch file by merging them.
@@ -8744,6 +8804,8 @@ var PatchUtils$2 = {
  * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Flash (v1.1.0)
  */
 
+const GS_TOOL_BLOCK_TYPE = 'gs-tool';
+
 /**
  * Checks if a given code block content represents a GitSense Chat Tool Block.
  * It verifies if the first non-empty line starts with "# GitSense Chat Tool".
@@ -8762,6 +8824,65 @@ function isToolBlock$1(content) {
     return false;
 }
 
+
+// TODO: Add JSDocs
+function getToolBlocksByTool(content, tool, CodeBlockUtils) {
+    const { blocks, warnings } = CodeBlockUtils.extractCodeBlocks(content, { silent: true });
+
+    return blocks.filter((block, index) => {
+        if (block.type !== GS_TOOL_BLOCK_TYPE)
+            return;
+
+        try {
+            const data = parseToolBlock$1(block.content);
+
+            if (data.tool === tool) {
+                block.index = index;
+                return block;
+            }
+        } catch(error) {
+            // FIXME: We need a more elegant way to identify examples. 
+            if (!content.includes(/Internal INTEGER IDs/)) {
+                console.warn(`Invalid tool block JSON: ${error.message}`);
+            }
+        }
+    });
+}
+
+// TODO: Add JSDocs
+function getToolBlockElemsByTool(dom, tool) {
+    const elems = dom.querySelectorAll('pre');
+    const toolBockElems = [];
+
+    for ( let i = 0; i < elems.length; i++ ) {
+        const elem = elems[i];
+        let content = elem.textContent;
+
+        // We need to strip out the first two lines since this is not part of the actual code
+        // block. These two lines are designed to make it easy to identify the language 
+        content = content.split('\n').slice(2).join('\n');
+
+        if (!isToolBlock$1(content)) 
+            continue;
+
+        try {
+            const data = parseToolBlock$1(content, { silent: true });
+
+            if (data.tool === tool)
+                toolBockElems.push(elem);
+        } catch(error) {
+            // FIXME: We need a more elegant way to identify examples. 
+            if (!content.match(/Internal INTEGER IDs/)) {
+                console.warn("getToolBlockElemsByTool: ",error.message);
+            }
+            continue; 
+        }
+    }
+
+    return toolBockElems;
+}
+
+
 /**
  * Parses the content of a GitSense Chat Tool Block to extract the JSON payload.
  * It strips the marker line and any subsequent lines starting with '#' (comments)
@@ -8870,7 +8991,7 @@ function replaceToolBlock(markdownContent, toolName, newToolData, CodeBlockUtils
     // 2. Iterate through the processed blocks to find the target GitSense Chat Tool Block
     for (let i = 0; i < blocks.length; i++) {
         const block = blocks[i];
-        if (block.type === 'gs-tool' && block.toolData && block.toolData.tool === toolName) {
+        if (block.type === GS_TOOL_BLOCK_TYPE && block.toolData && block.toolData.tool === toolName) {
             targetBlockIndex = i;
             break; // Found the first matching tool block
         }
@@ -9004,11 +9125,15 @@ function detectAndFormatUnfencedToolBlock(messageContent) {
     };
 }
 
+
+
 var GSToolBlockUtils$3 = {
     isToolBlock: isToolBlock$1,
     parseToolBlock: parseToolBlock$1,
     formatToolBlock,
     replaceToolBlock,
+    getToolBlocksByTool,
+    getToolBlockElemsByTool,
     detectAndFormatUnfencedToolBlock,
 };
 
@@ -9308,16 +9433,16 @@ var JsonUtils$2 = {
  * Component: CodeBlockUtils Block Processor
  * Block-UUID: 1d8a559b-4f7a-4b0b-9e0a-13786f94a74e
  * Parent-UUID: 082abf8b-079f-4c95-8464-0e66c0de45eb
- * Version: 1.4.0
+ * Version: 1.5.0
  * Description: Processes the content of identified code blocks, parsing headers or patch details, and provides utilities like fixing UUIDs within blocks.
  * Language: JavaScript
  * Created-at: 2025-07-21T00:33:22.312Z
- * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Pro (v1.2.0), Gemini 2.5 Flash Thinking (v1.3.0), Gemini 2.5 Flash Thinking (v1.4.0)
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Gemini 2.5 Pro (v1.2.0), Gemini 2.5 Flash Thinking (v1.3.0), Gemini 2.5 Flash Thinking (v1.4.0), Qwen 3 Coder 480B - Cerebras (v1.5.0)
  */
 
 const { findAllCodeFences: findAllCodeFences$3, matchFencesAndExtractBlocks: matchFencesAndExtractBlocks$3 } = blockExtractor;
 const { parseHeader: parseHeader$2 } = headerUtils;
-const { validateUUID: validateUUID$2, generateUUID: generateUUID$2 } = uuidUtils;
+const { validateUUID: validateUUID$2 } = uuidUtils;
 const AnalysisBlockUtils$2 = AnalysisBlockUtils$3;
 const PatchUtils$1 = PatchUtils$2;
 const GSToolBlockUtils$2 = GSToolBlockUtils$3;
@@ -9433,7 +9558,7 @@ function processBlockContent(content, language, position, incomplete, options =
     if (PatchUtils$1.isPatchBlock(content)) {
         const patchFormat = PatchUtils$1.determinePatchFormat(content);
         const metadata = PatchUtils$1.extractPatchMetadata(content); // Extract metadata regardless of validation
-        const patchContent = PatchUtils$1.extractPatchContent(content); // Extract raw patch content
+        const patchContent = PatchUtils$1.extractPatchContent(content, patchFormat); // Extract raw patch content
 
         let patchValidationResult = { valid: true, errors: [], patches: null }; // Default valid state
 
@@ -9450,36 +9575,16 @@ function processBlockContent(content, language, position, incomplete, options =
             // For now, just warn, but return the extracted (potentially invalid) metadata.
         }
 
-        // Optionally validate context patch structure if requested
-        if (patchFormat === 'context' && validatePatches) {
-            try {
-                const patches = PatchUtils$1.extractContextPatches(content);
-                if (!patches || patches.length === 0) {
-                    patchValidationResult = { valid: false, errors: ['No valid context patch content found.'], patches: null };
-                    warnings.push({
-                        position: position,
-                        type: 'patch_content_error',
-                        message: 'No valid context patch content found.',
-                        content: content,
-                    });
-                } else {
-                    // Basic validation passed (structure was parsable)
-                    patchValidationResult = { valid: true, errors: [], patches: patches };
-                }
-            } catch (error) {
-                patchValidationResult = { valid: false, errors: [error.message], patches: null };
-                warnings.push({
-                    position: position,
-                    type: 'patch_parse_error',
-                    message: `Error parsing context patch: ${error.message}`,
-                    content: content,
-                });
-            }
+        // Determine the correct language for the block
+        let blockLanguage = language; // Default to the fence language
+        if (patchFormat === 'traditional') {
+            blockLanguage = 'diff'; // Enforce 'diff' for traditional patches
         }
+        // For abbreviated patches, keep the original language (e.g., 'javascript', 'python')
 
         return {
             type: 'patch',
-            language: language === 'diff' ? 'diff' : language, // Use 'diff' if specified, else keep original
+            language: blockLanguage, // Use determined language
             content: content, // Full original content within fences
             position: position,
             incomplete: incomplete,
@@ -9673,8 +9778,10 @@ function processBlockContents(text, completeBlocks, incompleteBlocks, options) {
  * @returns {Object} { blocks: Array, warnings: Array, hasIncompleteBlocks: boolean, lastIncompleteBlock: Object|null }
  */
 function processCodeBlocks$5(text, options = { silent: false, validatePatches: false }) {
-    if (typeof text !== "string") { // Allow empty strings
-        console.warn("Warning: Input must be a string.");
+    if (typeof text !== "string") {
+        if (text != null )
+            console.warn("Warning: Input must be a string.");
+
         return {
             blocks: [],
             warnings: [{ type: 'invalid_input', message: 'Input must be a string.' }],
@@ -10595,19 +10702,114 @@ var updateCodeBlock_1 = {
     updateCodeBlockInMessage: updateCodeBlockInMessage$1,
     deleteCodeBlockByIndex: deleteCodeBlockByIndex$2};
 
+/**
+ * Component: CodeBlockUtils Lineage Tracer
+ * Block-UUID: 13b08cce-6fd1-4ec9-a915-240714ee89b9
+ * Parent-UUID: df1a629b-2cc0-4677-b410-3172ee0e0f9f
+ * Version: 1.1.0
+ * Description: Provides a utility function to trace the full lineage (patch-based and parent-based) of code blocks within a chat, including loop detection.
+ * Language: JavaScript
+ * Created-at: 2025-10-23T01:28:10.456Z
+ * Authors: Qwen 3 Coder 480B - Cerebras (v1.0.0), Qwen 3 Coder 480B - Cerebras (v1.1.0)
+ */
+
+/**
+ * Traces the full lineage of a code block or patch identified by a UUID.
+ * The lineage includes the block itself and all its ancestors, tracing backwards
+ * first through patch relationships (Source-Block-UUID -> Target-Block-UUID)
+ * and then through Parent-UUID relationships.
+ * Loop detection is included to prevent infinite tracing.
+ *
+ * @param {string} uuid - The UUID of the target code block or patch.
+ * @param {Map<string, object>} blockMap - A map where keys are UUIDs (for code blocks)
+ *                                         or patch UUIDs (source:target) and values
+ *                                         are the corresponding block objects.
+ *                                         Block objects are expected to have
+ *                                         properties like `isPatch`, `metadata`, and `header`.
+ * @returns {Array<object>} An array of block objects representing the lineage.
+ *                          The first element is the block for the provided `uuid`.
+ *                          Subsequent elements are its ancestors.
+ *                          Returns an empty array if the initial uuid is not found.
+ *                          If a loop is detected, the last element will have a property `loopDetected: true`.
+ */
+function getLineage$2(uuid, blockMap) {
+    if (!uuid || !blockMap) {
+        return [];
+    }
+
+    const lineage = [];
+    const visitedUuids = new Set();
+    let currentUuid = uuid;
+
+    while (currentUuid) {
+        // --- Loop Detection ---
+        if (visitedUuids.has(currentUuid)) {
+            // Add a marker or the block itself to indicate the loop
+            const loopBlock = blockMap.get(currentUuid) || { uuid: currentUuid, loopDetected: true, type: 'loop-marker' };
+            loopBlock.loopDetected = true; // Ensure the property is set
+            lineage.push(loopBlock);
+            break; // Stop the trace
+        }
+        visitedUuids.add(currentUuid);
+
+        // --- 1. Try to find the block directly by its UUID ---
+        let block = blockMap.get(currentUuid);
+
+        // --- 2. If not found directly, search patch keys ---
+        if (!block) {
+            for (const [key, value] of blockMap) {
+                // Check if the map key is a patch key (contains ':') and ends with our target UUID
+                if (key.includes(':') && key.endsWith(`:${currentUuid}`)) {
+                    block = value;
+                    break;
+                }
+            }
+        }
+
+        // --- 3. If a block was found, add it to the lineage ---
+        if (block) {
+            lineage.push(block);
+
+            let nextUuid = null;
+
+            // --- 3a. If it's a patch, move to its source UUID ---
+            if (block.isPatch && block.metadata && block.metadata['Source-Block-UUID']) {
+                nextUuid = block.metadata['Source-Block-UUID'];
+            }
+            // --- 3b. If it's a code block, move to its Parent-UUID (if valid) ---
+            else if (!block.isPatch && block.header && block.header['Parent-UUID'] && block.header['Parent-UUID'] !== 'N/A') {
+                 nextUuid = block.header['Parent-UUID'];
+            }
+// If it's a code block with Parent-UUID: 0c104865-260a-4942-8cb6-93bebf40c450
+
+            currentUuid = nextUuid;
+        } else {
+            // If no block is found for currentUuid, the lineage is incomplete.
+            // We could add a placeholder here if needed, but for now, we just stop.
+            currentUuid = null;
+        }
+    }
+
+    return lineage;
+}
+
+var lineageTracer = {
+    getLineage: getLineage$2
+};
+
 /**
  * Component: CodeBlockUtils Index
- * Block-UUID: 7e9d3f8a-1b2c-4d5e-8f9a-0123456789ab
- * Parent-UUID: a3b9c8d1-e0f2-4a1b-8c7d-5e6f0a9b1c2d
- * Version: 1.4.0
+ * Block-UUID: 98684aa5-d597-41b6-a7fd-cc16482aafdc
+ * Parent-UUID: 7e9d3f8a-1b2c-4d5e-8f9a-0123456789ab
+ * Version: 1.5.0
  * Description: Aggregates and exports all utilities related to code block processing from the CodeBlockUtils module. Serves as the main entry point for this module.
  * Language: JavaScript
  * Created-at: 2025-04-15T16:02:20.217Z
- * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Claude 3.7 Sonnet (v1.2.0), Gemini 2.5 Pro (v1.3.0), Gemini 2.5 Flash Thinking (v1.4.0)
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Pro (v1.1.0), Claude 3.7 Sonnet (v1.2.0), Gemini 2.5 Pro (v1.3.0), Gemini 2.5 Flash Thinking (v1.4.0), Qwen 3 Coder 480B - Cerebras (v1.5.0)
  */
 
 // Import from individual utility files
-const { COMMENT_STYLES: COMMENT_STYLES$1 } = constants$2;
+const { COMMENT_STYLES: COMMENT_STYLES$1 } = constants$3;
 const { generateUUID: generateUUID$1, validateUUID: validateUUID$1 } = uuidUtils;
 const { isValidISOTimestamp: isValidISOTimestamp$1, parseHeader: parseHeader$1, getHeaderLineCount } = headerUtils;
 const { findAllCodeFences: findAllCodeFences$1, matchFencesAndExtractBlocks: matchFencesAndExtractBlocks$1, extractCodeBlocksWithUUIDs, findCodeBlockByUUID } = blockExtractor;
@@ -10619,9 +10821,10 @@ const { parseCodeBlocks: parseCommentDelimitedBlocks$1 } = headerParser;
 const { removeCodeBlockMarkers: removeCodeBlockMarkers$1 } = markerRemover;
 const { updateCodeBlockByIndex: updateCodeBlockByIndex$1, updateCodeBlockByUUID, updateCodeBlock, updateCodeBlockInMessage, deleteCodeBlockByIndex: deleteCodeBlockByIndex$1 } = updateCodeBlock_1;
 const { formatWithLineNumbers: formatWithLineNumbers$1, formatBlockWithLineNumbers: formatBlockWithLineNumbers$1, formatBlocksWithLineNumbers: formatBlocksWithLineNumbers$1, removeLineNumbers: removeLineNumbers$1 } = lineNumberFormatter;
+const { getLineage: getLineage$1 } = lineageTracer;
 
 // Export all imported items
-var CodeBlockUtils$5 = {
+var CodeBlockUtils$7 = {
     // Constants
     COMMENT_STYLES: COMMENT_STYLES$1,
 
@@ -10673,22 +10876,23 @@ var CodeBlockUtils$5 = {
     // Line Number Formatting Utilities
     formatWithLineNumbers: formatWithLineNumbers$1,
     formatBlockWithLineNumbers: formatBlockWithLineNumbers$1,
-    formatBlocksWithLineNumbers: formatBlocksWithLineNumbers$1,
+    formatBlocksWithLineNumbers: formatBlocksWithLineNumbers$1, 
+    getLineage: getLineage$1,
     removeLineNumbers: removeLineNumbers$1,
 };
 
 /*
  * Component: ContextUtils
- * Block-UUID: a0b71292-b1cc-401a-8ce2-544a047b0fef
- * Parent-UUID: c018b1f9-2291-4bc9-9c4b-ab53a5db745e
- * Version: 1.3.0
+ * Block-UUID: 534c348d-a11f-4de6-ad15-f33068d51fb8
+ * Parent-UUID: a0b71292-b1cc-401a-8ce2-544a047b0fef
+ * Version: 1.4.0
  * Description: Provides utility functions for parsing context message sections to extract file details and code blocks, and for formatting content for LLM context.
  * Language: JavaScript
  * Created-at: 2025-05-09T01:36:20.107Z
- * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Gemini 2.5 Flash (v1.1.0), Qwen 3 Coder 480B - Cerebras (v1.2.0), Qwen 3 Coder 480B - Cerebras (v1.3.0)
+ * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Gemini 2.5 Flash (v1.1.0), Qwen 3 Coder 480B - Cerebras (v1.2.0), Qwen 3 Coder 480B - Cerebras (v1.3.0), Qwen 3 Coder 480B - Cerebras (v1.4.0)
  */
 
-const CodeBlockUtils$4 = CodeBlockUtils$5;
+const CodeBlockUtils$6 = CodeBlockUtils$7;
 const MessageUtils$2 = MessageUtils$3;
 
 /**
@@ -10755,6 +10959,41 @@ function _createContextSummary(items, contentType) {
     return summary + "\n";
 }
 
+/**
+ * Extracts all context files from a given chat object.
+ * Iterates through chat messages, identifies context loader outputs,
+ * and parses them into individual file objects.
+ *
+ * @param {object} chat - The GitSense chat object.
+ * @returns {Array<object>} An array of parsed context file objects.
+ *                           Returns an empty array if no context files are found or on error.
+ */
+function getContextFiles$1(chat) {
+    const ChatUtils = ChatUtils$2;
+    const contextFiles = [];
+    const messages = ChatUtils.getChatMessages(chat);
+
+    if (!Array.isArray(messages)) {
+        console.warn("getContextFiles: Provided chat object does not contain a valid messages array.");
+        return contextFiles;
+    }
+
+    messages.forEach(message => {
+        // Check if the message content is a context message
+        if (MessageUtils$2.isContextMessage(message.message)) {
+            try {
+                // Extract all context sections from the message content
+                const extractedFiles = extractContextSections$1(message.message);
+                contextFiles.push(...extractedFiles);
+            } catch (error) {
+                console.warn(`getContextFiles: Failed to extract context sections from message ID ${message.id}:`, error);
+            }
+        }
+    });
+
+    return contextFiles;
+}
+
 /**
  * Escapes backticks in code blocks to prevent premature termination of LLM-generated code blocks.
  * @param {string} content - The content string to escape.
@@ -10827,7 +11066,7 @@ function parseContextSection$1(sectionText) {
         }
     });
 
-    const { blocks, warnings } = CodeBlockUtils$4.extractCodeBlocks(sectionText, { silent: true });
+    const { blocks, warnings } = CodeBlockUtils$6.extractCodeBlocks(sectionText, { silent: true });
     const codeBlocks = blocks.filter(block => block.type === 'code');
 
     if (codeBlocks.length === 0) {
@@ -11029,6 +11268,7 @@ function formatContextContent$1(items, contentType, contentOption) {
 var ContextUtils$2 = {
     parseContextSection: parseContextSection$1,
     extractContextSections: extractContextSections$1,
+    getContextFiles: getContextFiles$1,
     extractContextItemsOverviewTableRows: extractContextItemsOverviewTableRows$1,
     formatContextContent: formatContextContent$1,
 };
@@ -11086,7 +11326,7 @@ var contextMapper = {
 
 /*
  * Component: AnalyzerUtils Constants
- * Block-UUID: 01b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d
+ * Block-UUID: fec5dcc4-a1d0-4ef7-8828-3e44a75892c4
  * Parent-UUID: N/A
  * Version: 1.0.0
  * Description: Defines constants specific to the AnalyzerUtils module.
@@ -11112,7 +11352,7 @@ var constants = {
  * Authors: Gemini 2.5 Flash (v1.0.0)
  */
 
-const CodeBlockUtils$3 = CodeBlockUtils$5;
+const CodeBlockUtils$5 = CodeBlockUtils$7;
 const GSToolBlockUtils$1 = GSToolBlockUtils$3;
 const JsonUtils$1 = JsonUtils$2;
 const { ANALYZE_HEADER_PREFIX } = constants;
@@ -11129,7 +11369,7 @@ const { ANALYZE_HEADER_PREFIX } = constants;
  */
 function processLLMAnalysisResponse$2(messageContent, stoppedStreaming) {
     const silent = { silent: true };
-    const { blocks, warnings } = CodeBlockUtils$3.extractCodeBlocks(messageContent, silent);
+    const { blocks, warnings } = CodeBlockUtils$5.extractCodeBlocks(messageContent, silent);
 
     const analysisBlocks = [];
     const analysisMetadataBlocks = [];
@@ -11314,7 +11554,7 @@ var dataValidator = {
 
 /*
  * Component: AnalyzerUtils Instruction Loader
- * Block-UUID: 0a1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5e
+ * Block-UUID: 3ecd422e-1dd8-482d-ae3f-90a5eae3ae44
  * Parent-UUID: N/A
  * Version: 1.0.0
  * Description: Provides utility functions for loading raw analyzer instruction content.
@@ -11323,19 +11563,19 @@ var dataValidator = {
  * Authors: Gemini 2.5 Flash (v1.0.0)
  */
 
-const fs$7 = require$$0.promises;
-const path$5 = require$$1;
+const fs$8 = require$$0.promises;
+const path$6 = require$$1;
 
 /**
  * Retrieves the raw Markdown content of the analyzer's '1.md' instruction file.
  *
- * @param {string} analyzeMessagesBasePath - The absolute path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
  * @param {string} analyzerId - The unique ID of the analyzer (format: 'analyzer_name::content_type::instructions_type').
  * @returns {Promise<string|null>} A promise that resolves with the full Markdown content of the '1.md' file, or null if not found/invalid.
  */
-async function getAnalyzerInstructionsContent$3(analyzeMessagesBasePath, analyzerId) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        console.error('Error: analyzeMessagesBasePath is required.');
+async function getAnalyzerInstructionsContent$3(analyzersBasePath, analyzerId) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        console.error('Error: analyzersBasePath is required.');
         return null;
     }
     if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
@@ -11350,10 +11590,10 @@ async function getAnalyzerInstructionsContent$3(analyzeMessagesBasePath, analyze
     }
     const [analyzerName, contentType, instructionsType] = parts;
 
-    const instructionsFilePath = path$5.join(analyzeMessagesBasePath, analyzerName, contentType, instructionsType, '1.md');
+    const instructionsFilePath = path$6.join(analyzersBasePath, analyzerName, contentType, instructionsType, '1.md');
 
     try {
-        const fileContent = await fs$7.readFile(instructionsFilePath, 'utf8');
+        const fileContent = await fs$8.readFile(instructionsFilePath, 'utf8');
         const parts = fileContent.split('\n\n\n');
         parts.shift();
         return parts.join('\n\n\n');
@@ -11373,20 +11613,56 @@ var instructionLoader = {
 };
 
 /*
+ * Component: AnalyzerUtils JSON Parser
+ * Block-UUID: 4dd21efd-3ad3-43e1-adf0-d52d7c560970
+ * Version: 1.0.0
+ * Description: Provides utility functions for pre-processing JSON content from analyzer instructions.
+ * Language: JavaScript
+ * Created-at: 2025-11-23T05:38:15.725Z
+ * Authors: GLM-4.6 (v1.0.0)
+ */
+
+/**
+ * Pre-processes JSON content to quote unquoted template strings before parsing.
+ * This handles cases where {{SYSTEM: ...}} and {{ANALYZER: ...}} placeholders
+ * are not properly quoted in the JSON.
+ *
+ * @param {string} jsonString - The raw JSON string content.
+ * @returns {string} The processed JSON string with template strings quoted.
+ */
+function preprocessJsonForValidation$5(jsonString) {
+    // Find all unquoted template strings and quote them with proper escaping
+    // This regex looks for template strings that aren't already quoted
+    return jsonString.replace(
+        /(?<!")(\{\{(SYSTEM|ANALYZER):[^}]+\}\})(?!")/g,
+        (match, template) => {
+            // Escape any double quotes within the template string
+            const escapedTemplate = template.replace(/"/g, '\\"');
+            return `"${escapedTemplate}"`;
+        }
+    );
+}
+
+var jsonParser = {
+    preprocessJsonForValidation: preprocessJsonForValidation$5
+};
+
+/**
  * Component: AnalyzerUtils Discovery
- * Block-UUID: a87a86c4-69fc-4cbb-80a8-857f56122395
- * Parent-UUID: 0b1c2d3e-4f5a-6b7c-8d9e-0f1a2b3c4d5f
- * Version: 1.1.0
- * Description: Provides utility functions for discovering available analyzers.
+ * Block-UUID: 26a7df9b-ef29-4dcd-aab2-9cdc3a11133c
+ * Parent-UUID: aa999515-84fb-43f6-91a7-cf79248d7286
+ * Version: 1.3.1
+ * Description: Provides utility functions for discovering available analyzers. Updated to include version and tags in analyzer objects.
  * Language: JavaScript
- * Created-at: 2025-08-28T23:48:00.000Z
- * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Flash (v1.1.0)
+ * Created-at: 2025-11-27T14:45:30.978Z
+ * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Flash (v1.1.0), Qwen 3 Coder 480B - Cerebras (v1.2.0), GLM-4.6 (v1.2.1), GLM-4.6 (v1.3.0), GLM-4.6 (v1.3.1)
  */
 
-const fs$6 = require$$0.promises;
-const path$4 = require$$1;
+const fs$7 = require$$0.promises;
+const path$5 = require$$1;
 const { getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$2 } = instructionLoader;
-const CodeBlockUtils$2 = CodeBlockUtils$5;
+const { preprocessJsonForValidation: preprocessJsonForValidation$4 } = jsonParser;
+const CodeBlockUtils$4 = CodeBlockUtils$7;
 
 /**
  * Reads and parses the config.json file in a directory.
@@ -11394,10 +11670,10 @@ const CodeBlockUtils$2 = CodeBlockUtils$5;
  * @returns {Promise<object|null>} A promise that resolves to the parsed config object
  *                                 or null if the file doesn't exist or is invalid.
  */
-async function readConfig$1(dirPath) {
-    const configPath = path$4.join(dirPath, 'config.json');
+async function readConfig$2(dirPath) {
+    const configPath = path$5.join(dirPath, 'config.json');
     try {
-        const fileContent = await fs$6.readFile(configPath, 'utf8');
+        const fileContent = await fs$7.readFile(configPath, 'utf8');
         return JSON.parse(fileContent);
     } catch (error) {
         if (error.code !== 'ENOENT') {
@@ -11409,12 +11685,12 @@ async function readConfig$1(dirPath) {
 }
 
 /**
- * Checks if a directory name is valid based on the rules in messages/analyze/README.md.
+ * Checks if a directory name is valid
  * Allowed: a-z, A-Z, 0-9, dash (-), underscore (_). Cannot start with underscore or contain dots.
  * @param {string} name - The directory name to check.
  * @returns {boolean} True if the name is valid, false otherwise.
  */
-function isValidDirName(name) {
+function isValidDirName$2(name) {
     // Exclude names starting with underscore or containing dots
     if (name.startsWith('_') || name.includes('.')) {
         return false;
@@ -11427,51 +11703,53 @@ function isValidDirName(name) {
  * Discovers and lists all available analyzers by traversing the directory structure.
  * An analyzer is considered valid if a '1.md' file exists in the instructions directory.
  *
- * @param {string} analyzeMessagesBasePath - The absolute or relative path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers (e.g., 'analyzers/analyzer-1').
  * @param {object} [options={}] - Optional configuration.
- * @param {boolean} [options.includeDescription=false] - Whether to include the description of the analyzer.
- * @returns {Promise<Array<{id: string, label: string, name: string, protected: boolean, description?: string}>>} A promise that resolves to an array of analyzer objects.
+ * @returns {Promise<Array<{id: string, label: string, name: string, protected: boolean, description?: string, version?: string, tags?: Array<string>}>>} A promise that resolves to an array of analyzer objects.
  */
-async function getAnalyzers$2(analyzeMessagesBasePath, options = {}) {
-    const { includeDescription = false } = options;
+async function getAnalyzers$3(analyzersBasePath, options = {}) {
     const analyzers = [];
+    const demoAnalyzerPattern = /^demo-.+-\w{6}$/;
 
     try {
-        const analyzerEntries = await fs$6.readdir(analyzeMessagesBasePath, { withFileTypes: true });
+        const analyzerEntries = await fs$7.readdir(analyzersBasePath, { withFileTypes: true });
 
         for (const analyzerEntry of analyzerEntries) {
-            if (analyzerEntry.isDirectory() && isValidDirName(analyzerEntry.name)) {
+            if (analyzerEntry.isDirectory() && isValidDirName$2(analyzerEntry.name)) {
                 const analyzerName = analyzerEntry.name;
-                const analyzerPath = path$4.join(analyzeMessagesBasePath, analyzerName);
-                const analyzerConfig = await readConfig$1(analyzerPath);
+                const analyzerPath = path$5.join(analyzersBasePath, analyzerName);
+                const analyzerConfig = await readConfig$2(analyzerPath);
                 const analyzerLabel = analyzerConfig?.label || analyzerName;
 
-                const contentEntries = await fs$6.readdir(analyzerPath, { withFileTypes: true });
+                const contentEntries = await fs$7.readdir(analyzerPath, { withFileTypes: true });
 
                 for (const contentEntry of contentEntries) {
-                    if (contentEntry.isDirectory() && isValidDirName(contentEntry.name)) {
+                    if (contentEntry.isDirectory() && isValidDirName$2(contentEntry.name)) {
                         const contentType = contentEntry.name;
-                        const contentPath = path$4.join(analyzerPath, contentType);
-                        const contentConfig = await readConfig$1(contentPath);
+                        const contentPath = path$5.join(analyzerPath, contentType);
+                        const contentConfig = await readConfig$2(contentPath);
                         const contentLabel = contentConfig?.label || contentType;
 
-                        const instructionsEntries = await fs$6.readdir(contentPath, { withFileTypes: true });
+                        const instructionsEntries = await fs$7.readdir(contentPath, { withFileTypes: true });
 
                         for (const instructionsEntry of instructionsEntries) {
-                            if (instructionsEntry.isDirectory() && isValidDirName(instructionsEntry.name)) {
+                            if (instructionsEntry.isDirectory() && isValidDirName$2(instructionsEntry.name)) {
                                 const instructionsType = instructionsEntry.name;
-                                const instructionsPath = path$4.join(contentPath, instructionsType);
-                                const instructionsConfig = await readConfig$1(instructionsPath);
+                                const instructionsPath = path$5.join(contentPath, instructionsType);
+                                const instructionsConfig = await readConfig$2(instructionsPath);
                                 const instructionsLabel = instructionsConfig?.label || instructionsType;
 
+                                // Construct the analyzer ID and label
+                                const analyzerId = `${analyzerName}::${contentType}::${instructionsType}`;
+
                                 // Check for the existence of 1.md to confirm a valid analyzer configuration
-                                const instructionsFilePath = path$4.join(instructionsPath, '1.md');
+                                const instructionsFilePath = path$5.join(instructionsPath, '1.md');
                                 try {
-                                    await fs$6.access(instructionsFilePath); // Check if file exists and is accessible
+                                    await fs$7.access(instructionsFilePath); // Check if file exists and is accessible
 
                                     // If analyzerName starts with 'tutorial-', check its last modified time.
-                                    if (analyzerName.startsWith('tutorial-')) {
-                                        const stats = await fs$6.stat(instructionsFilePath);
+                                    if (analyzerName.startsWith('tutorial-') || demoAnalyzerPattern.test(analyzerName)) {
+                                        const stats = await fs$7.stat(instructionsFilePath);
                                         const lastModified = stats.mtime.getTime(); // Get timestamp in milliseconds
                                         const sixtyMinutesAgo = Date.now() - (60 * 60 * 1000); // Current time - 60 minutes in ms
 
@@ -11480,37 +11758,43 @@ async function getAnalyzers$2(analyzeMessagesBasePath, options = {}) {
                                             continue;
                                         }
                                     }
-                                    // Construct the analyzer ID and label
-                                    const analyzerId = `${analyzerName}::${contentType}::${instructionsType}`;
-                                    const analyzerFullLabel = `${analyzerLabel} (${contentLabel} - ${instructionsLabel})`;
+                                    // TODO: Decide if we should show the contentLabel and instructionsLabel. For now we will ignore them.
+                                    const analyzerFullLabel = `${analyzerLabel}`; // (${contentLabel} - ${instructionsLabel})`;
 
+                                    // Extract description, version, and tags from the JSON block in 1.md
                                     let description = null;
-                                    if (includeDescription) {
-                                        try {
-                                            const content = await getAnalyzerInstructionsContent$2(analyzeMessagesBasePath, analyzerId);
-                                            const { blocks, warnings } = CodeBlockUtils$2.extractCodeBlocks(content, { silent: true });
-                                            const jsonBlock = blocks.find(block => block.language === 'json');
-
-                                            if (jsonBlock && jsonBlock.content) {
-                                                try {
-                                                    const json = JSON.parse(jsonBlock.content);
-                                                    description = json.description;
-                                                } catch(error) {
-                                                    console.warn(`${analyzerId} contains an invalid JSON`);
-                                                }
-                                            }
-                                        } catch (descError) {
-                                            console.warn(`Warning: Could not load description for ${analyzerId}: ${descError.message}`);
-                                            descriptionContent = null;
+                                    let version = null;
+                                    let tags = [];
+                                    let label = null;
+                                    let requires_reference_files = null;
+                                    
+                                    try {
+                                        const content = await getAnalyzerInstructionsContent$2(analyzersBasePath, analyzerId);
+                                        const { blocks, warnings } = CodeBlockUtils$4.extractCodeBlocks(content, { silent: true });
+                                        const jsonBlock = blocks.find(block => block.language === 'json');
+
+                                        if (jsonBlock && jsonBlock.content) {
+                                            const preprocessedContent = preprocessJsonForValidation$4(jsonBlock.content);
+                                            const json = JSON.parse(preprocessedContent);
+                                            description = json.description || null;
+                                            label = json.label || null;
+                                            requires_reference_files = json.requires_reference_files || false;
+                                            version = json.version || null;
+                                            tags = Array.isArray(json.tags) ? json.tags : [];
                                         }
+                                    } catch (descError) {
+                                        console.warn(`Warning: Could not load metadata for ${analyzerId}: ${descError.message}`);
                                     }
 
                                     analyzers.push({
                                         id: analyzerId,
-                                        label: analyzerFullLabel,
                                         name: analyzerName,
+                                        description,
+                                        label: label || analyzerFullLabel,
+                                        requires_reference_files,
                                         protected: analyzerConfig?.protected || false,
-                                        description
+                                        version,
+                                        tags
                                      });
                                 } catch (error) {
                                     // If 1.md doesn't exist, this is not a complete analyzer configuration, skip.
@@ -11525,7 +11809,7 @@ async function getAnalyzers$2(analyzeMessagesBasePath, options = {}) {
             }
         }
     } catch (error) {
-        console.error(`Error traversing analyze messages directory ${analyzeMessagesBasePath}: ${error.message}`);
+        console.error(`Error traversing analyzers directory ${analyzersBasePath}: ${error.message}`);
         // Depending on requirements, you might want to throw the error or return an empty array
         throw error; // Re-throw to indicate failure
     }
@@ -11534,8 +11818,10 @@ async function getAnalyzers$2(analyzeMessagesBasePath, options = {}) {
 }
 
 var discovery = {
-    getAnalyzers: getAnalyzers$2,
-    readConfig: readConfig$1};
+    getAnalyzers: getAnalyzers$3,
+    readConfig: readConfig$2,
+    isValidDirName: isValidDirName$2,
+};
 
 /**
  * Component: Analyzer Saver Utility
@@ -11548,8 +11834,8 @@ var discovery = {
  * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Gemini 2.5 Flash Thinking (v1.1.0)
  */
 
-const fs$5 = require$$0.promises;
-const path$3 = require$$1;
+const fs$6 = require$$0.promises;
+const path$4 = require$$1;
 
 /**
  * Saves or updates an analyzer configuration.
@@ -11559,19 +11845,19 @@ const path$3 = require$$1;
  * if necessary, saves the instructions to '1.md'. Optionally, it can
  * ensure config.json files exist with labels derived from directory names.
  *
- * @param {string} analyzeMessagesBasePath - The absolute or relative path to the 'messages/analyze' directory.
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers (e.g., 'analyzers/analyzer-1').
  * @param {string} analyzerId - The unique ID of the analyzer (format: 'analyzer_name::content_type::instructions_type').
  * @param {string} instructionsContent - The full content of the analyzer instructions message to be saved in '1.md'.
  * @param {object} [options={}] - Optional configuration options.
  * @param {boolean} [options.ensureConfigs=false] - If true, ensures config.json files exist in the analyzer, content, and instructions directories. Defaults to false.
  * @returns {Promise<{success: boolean, message?: string}>} A promise that resolves with a result object.
  */
-async function saveConfiguration$1(analyzeMessagesBasePath, analyzerId, instructionsContent, options = {}) {
+async function saveConfiguration$2(analyzersBasePath, analyzerId, instructionsContent, options = {}) {
     const { ensureConfigs = false } = options;
 
     // 1. Validate inputs
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        return { success: false, message: 'analyzeMessagesBasePath is required.' };
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        return { success: false, message: 'analyzersBasePath is required.' };
     }
     if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
         return { success: false, message: 'analyzerId is required.' };
@@ -11604,18 +11890,18 @@ async function saveConfiguration$1(analyzeMessagesBasePath, analyzerId, instruct
     }
 
     // 3. Construct directory paths
-    const analyzerDir = path$3.join(analyzeMessagesBasePath, analyzerName);
-    const contentDir = path$3.join(analyzerDir, contentType);
-    const instructionsDir = path$3.join(contentDir, instructionsType);
-    const instructionsFilePath = path$3.join(instructionsDir, '1.md');
+    const analyzerDir = path$4.join(analyzersBasePath, analyzerName);
+    const contentDir = path$4.join(analyzerDir, contentType);
+    const instructionsDir = path$4.join(contentDir, instructionsType);
+    const instructionsFilePath = path$4.join(instructionsDir, '1.md');
 
     try {
         // 4. Create directories recursively
-        await fs$5.mkdir(instructionsDir, { recursive: true });
+        await fs$6.mkdir(instructionsDir, { recursive: true });
 
         // 5. Save instructions content to 1.md
         const finalContent = `; role: assistant\n\n\n${instructionsContent}`; 
-        await fs$5.writeFile(instructionsFilePath, finalContent, 'utf8');
+        await fs$6.writeFile(instructionsFilePath, finalContent, 'utf8');
 
         // 6. Optionally create/Update config.json files
         if (ensureConfigs) {
@@ -11641,11 +11927,11 @@ async function saveConfiguration$1(analyzeMessagesBasePath, analyzerId, instruct
  * @param {string} label - The label to ensure is in the config.json.
  */
 async function ensureConfigJson(dirPath, label) {
-    const configPath = path$3.join(dirPath, 'config.json');
+    const configPath = path$4.join(dirPath, 'config.json');
     let config = {};
 
     try {
-        const fileContent = await fs$5.readFile(configPath, 'utf8');
+        const fileContent = await fs$6.readFile(configPath, 'utf8');
         config = JSON.parse(fileContent);
     } catch (error) {
         // If file doesn't exist or parsing fails, start with an empty config
@@ -11662,28 +11948,103 @@ async function ensureConfigJson(dirPath, label) {
     }
 
     // Write the updated config back to the file
-    await fs$5.writeFile(configPath, JSON.stringify(config, null, 4), 'utf8');
+    await fs$6.writeFile(configPath, JSON.stringify(config, null, 4), 'utf8');
 }
 
 
 var saver = {
-    saveConfiguration: saveConfiguration$1,
+    saveConfiguration: saveConfiguration$2,
 };
 
-/*
+/**
  * Component: AnalyzerUtils Schema Loader
- * Block-UUID: 0c1d2e3f-4a5b-6c7d-8e9f-0a1b2c3d4e5f
- * Parent-UUID: N/A
- * Version: 1.0.0
+ * Block-UUID: bf25c501-f9e1-4e5b-ad22-9ed24ba50787
+ * Parent-UUID: 66208fdc-2c80-4264-8500-06d5f4db103a
+ * Version: 1.4.1
  * Description: Provides utility functions for retrieving and deducing JSON schemas for analyzers.
  * Language: JavaScript
- * Created-at: 2025-08-28T23:48:00.000Z
- * Authors: Gemini 2.5 Flash (v1.0.0)
+ * Created-at: 2025-11-23T05:40:43.016Z
+ * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Pro (v1.1.0), Claude Haiku 4.5 (v1.2.0), Claude Haiku 4.5 (v1.3.0), Qwen 3 Coder 480B - Cerebras (v1.4.0), GLM-4.6 (v1.4.1)
  */
 
-const fs$4 = require$$0.promises;
-const path$2 = require$$1;
-const CodeBlockUtils$1 = CodeBlockUtils$5;
+/**
+ * Parses the 'Custom Metadata Definitions' block from the markdown content.
+ * Handles both formats:
+ *   - With backticks: * `fieldName` (type): description
+ *   - Without backticks: * fieldName (type): description
+ *
+ * @param {string} markdownContent - The full content of the 1.md file.
+ * @returns {Map<string, {type: string, description: string}>} A map from field name to its type and description.
+ */
+function parseMetadataDefinitions(markdownContent) {
+    const definitions = new Map();
+    
+    // Match the "### Custom Metadata Definitions" section until the next code block or section
+    const sectionRegex = /### Custom Metadata Definitions\s*([\s\S]*?)(?=```|\n##|\n---)/;
+    const match = markdownContent.match(sectionRegex);
+
+    if (!match || !match[1]) {
+        return definitions;
+    }
+
+    const definitionBlock = match[1];
+    
+    // Regex to match both formats:
+    // Format 1: * `fieldName` (type): description
+    // Format 2: * fieldName (type): description
+    // Capture groups:
+    //   Group 1: backtick-wrapped field name (if present)
+    //   Group 2: non-backtick field name (if present)
+    //   Group 3: field type
+    //   Group 4: description
+    const lineRegex = /^\s*\*\s+(?:`([^`]+)`|([a-zA-Z0-9_-]+))\s+\(([^)]+)\):\s*(.+)/gm;
+
+    let lineMatch;
+    while ((lineMatch = lineRegex.exec(definitionBlock)) !== null) {
+        // Extract field name from either group 1 (backtick-wrapped) or group 2 (plain)
+        const fieldName = (lineMatch[1] || lineMatch[2]).trim();
+        const fieldType = lineMatch[3].trim();
+        const description = lineMatch[4].trim();
+
+        if (fieldName && fieldType && description) {
+            definitions.set(fieldName, { type: fieldType, description });
+        }
+    }
+
+    return definitions;
+}
+
+const fs$5 = require$$0.promises;
+const path$3 = require$$1;
+const CodeBlockUtils$3 = CodeBlockUtils$7;
+const { preprocessJsonForValidation: preprocessJsonForValidation$3 } = jsonParser;
+
+/**
+ * Maps a simple type string (from the definitions block) to a JSON schema type object.
+ * @param {string} simpleType - The type string (e.g., "number", "array of strings").
+ * @returns {object} A JSON schema type definition.
+ */
+function mapSimpleTypeToSchema(simpleType) {
+    const lowerType = simpleType.toLowerCase().trim();
+    switch (lowerType) {
+        case 'string':
+            return { type: 'string' };
+        case 'number':
+        case 'integer':
+            return { type: 'number' };
+        case 'boolean':
+            return { type: 'boolean' };
+        case 'array of strings':
+            return { type: 'array', items: { type: 'string' } };
+        case 'date':
+            return { type: 'string', format: 'date' };
+        case 'datetime':
+        case 'iso 8601 timestamp':
+            return { type: 'string', format: 'date-time' };
+        default:
+            return { type: 'string' }; // Default to string for unknown types
+    }
+}
 
 /**
  * Deduces the JSON schema type and format/items from a string value pattern.
@@ -11696,6 +12057,15 @@ const CodeBlockUtils$1 = CodeBlockUtils$5;
  */
 function deduceSchemaType(value, fieldName) {
     const defaultSchema = { type: 'string' }; // Default fallback
+    
+    // Handle new placeholder format {{SYSTEM: ...}} and {{ANALYZER: ...}}
+    // These are valid placeholders and should not generate warnings
+    if (typeof value === 'string') {
+        const trimmedValue = value.trim();
+        if (trimmedValue.startsWith('{{SYSTEM:') || trimmedValue.startsWith('{{ANALYZER:')) {
+            return defaultSchema; // Return default string schema for system/analyzer placeholders
+        }
+    }
 
     if (typeof value !== 'string') {
         const jsType = typeof value;
@@ -11707,35 +12077,35 @@ function deduceSchemaType(value, fieldName) {
     }
 
     const trimmedValue = value.trim();
-
+    
     if (/^\[string:.*\]$/.test(trimmedValue) || (/^\[[^:]+\]$/.test(trimmedValue) && !/^\[(number|datetime|date|<string>):.*\]$/.test(trimmedValue))) {
         return { type: 'string' };
     }
-
+    
     if (/^\[number:.*\]$/.test(trimmedValue)) {
         return { type: 'number' };
     }
-
+    
     if (/^\[boolean:.*\]$/.test(trimmedValue)) {
         return { type: 'boolean' };
     }
-
+    
     if (/^\[date-*time:.*\]$/.test(trimmedValue)) {
         return { type: 'string', format: 'date-time' };
     }
-
+    
     if (/^\[date:.*\]$/.test(trimmedValue)) {
         return { type: 'string', format: 'date' };
     }
-
+    
     if (/^\[<string>:.*\]$/.test(trimmedValue) || trimmedValue.toLowerCase().includes('array of strings')) {
         return { type: 'array', items: { type: 'string' } };
     }
-
+    
     if (trimmedValue.toLowerCase().includes("output 'true' or 'false'") || trimmedValue.toLowerCase().includes("determine if") && (trimmedValue.toLowerCase().includes("true") || trimmedValue.toLowerCase().includes("false"))) {
         return { type: 'boolean' };
     }
-
+    
     console.warn(`Warning: Unknown metadata value pattern for field "${fieldName}". Defaulting to type 'string'. Value: "${value}"`);
     return defaultSchema;
 }
@@ -11746,14 +12116,14 @@ function deduceSchemaType(value, fieldName) {
  * Reads the corresponding '1.md' file, extracts the JSON block,
  * and deduces schema types from the string values.
  *
- * @param {string} analyzeMessagesBasePath - The absolute or relative path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute or relative path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
  * @param {string} analyzerId - The unique ID of the analyzer (format: 'analyzer_name::content_type::instructions_type').
  * @returns {Promise<object|null>} A promise that resolves with the JSON schema object or null if the analyzer ID is invalid or the schema cannot be retrieved/parsed.
  * @throws {Error} If the 1.md file is found but does not contain exactly one JSON code block.
  */
-async function getAnalyzerSchema$2(analyzeMessagesBasePath, analyzerId) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        console.error('Error: analyzeMessagesBasePath is required.');
+async function getAnalyzerSchema$2(analyzersBasePath, analyzerId) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        console.error('Error: analyzersBasePath is required.');
         return null;
     }
     if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
@@ -11768,11 +12138,14 @@ async function getAnalyzerSchema$2(analyzeMessagesBasePath, analyzerId) {
     }
     const [analyzerName, contentType, instructionsType] = parts;
 
-    const instructionsFilePath = path$2.join(analyzeMessagesBasePath, analyzerName, contentType, instructionsType, '1.md');
+    const instructionsFilePath = path$3.join(analyzersBasePath, analyzerName, contentType, instructionsType, '1.md');
 
     try {
-        const fileContent = await fs$4.readFile(instructionsFilePath, 'utf8');
-        const { blocks } = CodeBlockUtils$1.extractCodeBlocks(fileContent, { silent: true });
+        const fileContent = await fs$5.readFile(instructionsFilePath, 'utf8');
+        // New: Parse the structured definitions block first
+        const definedFields = parseMetadataDefinitions(fileContent);
+
+        const { blocks } = CodeBlockUtils$3.extractCodeBlocks(fileContent, { silent: true });
         const jsonBlocks = blocks.filter(block => block.type === 'code' && block.language === 'json');
 
         if (jsonBlocks.length !== 1) {
@@ -11780,19 +12153,24 @@ async function getAnalyzerSchema$2(analyzeMessagesBasePath, analyzerId) {
         }
 
         const jsonBlockContent = jsonBlocks[0].content;
+        const preprocessedContent = preprocessJsonForValidation$3(jsonBlockContent);
         let rawJson = null;
         try {
-            rawJson = JSON.parse(jsonBlockContent);
+            rawJson = JSON.parse(preprocessedContent);
         } catch (parseError) {
             console.error(`Error parsing JSON content from ${instructionsFilePath}: ${parseError.message}`);
             return null;
         }
 
+        const startOfInstructions = fileContent.indexOf('# Analyze ');
+
         const schema = {
             type: 'object',
             description: rawJson.description,
+            version: rawJson.version,
             properties: {},
-            required: []
+            required: [],
+            instructions: fileContent.slice(startOfInstructions),
         };
 
         const metadataProperties = rawJson?.extracted_metadata;
@@ -11800,9 +12178,20 @@ async function getAnalyzerSchema$2(analyzeMessagesBasePath, analyzerId) {
         if (metadataProperties && typeof metadataProperties === 'object') {
             for (const fieldName in metadataProperties) {
                 if (Object.hasOwnProperty.call(metadataProperties, fieldName)) {
-                    const rawValue = metadataProperties[fieldName];
-                    const fieldSchema = deduceSchemaType(rawValue, fieldName);
-                    const description = rawValue.match(/^\[\w+: ([^\]]+)\]/)?.[1] || '';
+                    let fieldSchema;
+                    let description;
+
+                    if (definedFields.has(fieldName)) {
+                        // Priority 1: Use the explicit definition
+                        const definition = definedFields.get(fieldName);
+                        fieldSchema = mapSimpleTypeToSchema(definition.type);
+                        description = definition.description;
+                    } else {
+                        // Priority 2: Fallback for system fields or backward compatibility
+                        const rawValue = metadataProperties[fieldName];
+                        fieldSchema = deduceSchemaType(rawValue, fieldName);
+                        description = rawValue.match(/^\[\w+: ([^\]]+)\]/)?.[1] || '';
+                    }
 
                     schema.properties[fieldName] = {
                         ...fieldSchema,
@@ -11816,7 +12205,6 @@ async function getAnalyzerSchema$2(analyzeMessagesBasePath, analyzerId) {
         }
 
         return schema;
-
     } catch (error) {
         if (error.code === 'ENOENT') {
             console.warn(`Analyzer instructions file not found: ${instructionsFilePath}`);
@@ -11833,7 +12221,7 @@ var schemaLoader = {
 
 /*
  * Component: AnalyzerUtils Management
- * Block-UUID: 0d1e2f3a-4b5c-6d7e-8f9a-0b1c2d3e4f5a
+ * Block-UUID: 6241f381-512b-48a7-b70e-6b45683831fe
  * Parent-UUID: N/A
  * Version: 1.0.0
  * Description: Provides utility functions for managing (deleting) analyzer configurations.
@@ -11842,9 +12230,9 @@ var schemaLoader = {
  * Authors: Gemini 2.5 Flash (v1.0.0)
  */
 
-const fs$3 = require$$0.promises;
-const path$1 = require$$1;
-const { readConfig } = discovery; // Import helper from discovery
+const fs$4 = require$$0.promises;
+const path$2 = require$$1;
+const { readConfig: readConfig$1 } = discovery; // Import helper from discovery
 
 /**
  * Checks if a directory is empty or only contains a config.json.
@@ -11853,7 +12241,7 @@ const { readConfig } = discovery; // Import helper from discovery
  */
 async function isDirectoryEmpty(dirPath) {
     try {
-        const files = await fs$3.readdir(dirPath);
+        const files = await fs$4.readdir(dirPath);
         return files.length === 0 || (files.length === 1 && files[0] === 'config.json');
     } catch (error) {
         if (error.code === 'ENOENT') {
@@ -11866,13 +12254,13 @@ async function isDirectoryEmpty(dirPath) {
 /**
  * Deletes a specific analyzer configuration and intelligently cleans up empty directories.
  *
- * @param {string} analyzeMessagesBasePath - The absolute or relative path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers (e.g., 'analyzers/analyzer-1').
  * @param {string} analyzerId - The unique ID of the analyzer to delete (format: 'analyzer_name::content_type::instructions_type').
  * @returns {Promise<{success: boolean, message: string}>} A promise that resolves with a result object indicating success or failure.
  */
-async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        return { success: false, message: 'analyzeMessagesBasePath is required.' };
+async function deleteAnalyzer$2(analyzersBasePath, analyzerId) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        return { success: false, message: 'analyzersBasePath is required.' };
     }
     if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
         return { success: false, message: 'analyzerId is required.' };
@@ -11884,31 +12272,31 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
     }
     const [analyzerName, contentType, instructionsType] = parts;
 
-    const analyzerDir = path$1.join(analyzeMessagesBasePath, analyzerName);
-    const contentDir = path$1.join(analyzerDir, contentType);
-    const instructionsDir = path$1.join(contentDir, instructionsType);
-    const instructionsFilePath = path$1.join(instructionsDir, '1.md');
+    const analyzerDir = path$2.join(analyzersBasePath, analyzerName);
+    const contentDir = path$2.join(analyzerDir, contentType);
+    const instructionsDir = path$2.join(contentDir, instructionsType);
+    const instructionsFilePath = path$2.join(instructionsDir, '1.md');
 
     try {
         // 1. Check for protection at all levels
-        const analyzerConfig = await readConfig(analyzerDir);
+        const analyzerConfig = await readConfig$1(analyzerDir);
         if (analyzerConfig?.protected) {
             return { success: false, message: `Analyzer '${analyzerName}' is protected and cannot be deleted.` };
         }
 
-        const contentConfig = await readConfig(contentDir);
+        const contentConfig = await readConfig$1(contentDir);
         if (contentConfig?.protected) {
             return { success: false, message: `Content type '${contentType}' for analyzer '${analyzerName}' is protected and cannot be deleted.` };
         }
 
-        const instructionsConfig = await readConfig(instructionsDir);
+        const instructionsConfig = await readConfig$1(instructionsDir);
         if (instructionsConfig?.protected) {
             return { success: false, message: `Instructions type '${instructionsType}' for content type '${contentType}' is protected and cannot be deleted.` };
         }
 
         // 2. Delete the 1.md file
         try {
-            await fs$3.unlink(instructionsFilePath);
+            await fs$4.unlink(instructionsFilePath);
         } catch (error) {
             if (error.code === 'ENOENT') {
                 return { success: false, message: `Analyzer instructions file not found: ${instructionsFilePath}. It may have already been deleted.` };
@@ -11922,7 +12310,7 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
         // Check and delete instructions directory
         if (await isDirectoryEmpty(instructionsDir)) {
             try {
-                await fs$3.rmdir(instructionsDir);
+                await fs$4.rmdir(instructionsDir);
                 deletedDirs.push(instructionsDir);
             } catch (error) {
                 console.warn(`Warning: Could not remove empty instructions directory ${instructionsDir}: ${error.message}`);
@@ -11932,7 +12320,7 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
         // Check and delete content directory
         if (await isDirectoryEmpty(contentDir)) {
             try {
-                await fs$3.rmdir(contentDir);
+                await fs$4.rmdir(contentDir);
                 deletedDirs.push(contentDir);
             } catch (error) {
                 console.warn(`Warning: Could not remove empty content directory ${contentDir}: ${error.message}`);
@@ -11942,7 +12330,7 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
         // Check and delete analyzer directory
         if (await isDirectoryEmpty(analyzerDir)) {
             try {
-                await fs$3.rmdir(analyzerDir);
+                await fs$4.rmdir(analyzerDir);
                 deletedDirs.push(analyzerDir);
             } catch (error) {
                 console.warn(`Warning: Could not remove empty analyzer directory ${analyzerDir}: ${error.message}`);
@@ -11958,7 +12346,9 @@ async function deleteAnalyzer$2(analyzeMessagesBasePath, analyzerId) {
 }
 
 var management = {
-    deleteAnalyzer: deleteAnalyzer$2};
+    deleteAnalyzer: deleteAnalyzer$2,
+    isDirectoryEmpty,
+};
 
 /*
  * Component: AnalyzerUtils Default Prompt Loader
@@ -11971,25 +12361,25 @@ var management = {
  * Authors: Gemini 2.5 Flash (v1.0.0)
  */
 
-const fs$2 = require$$0.promises;
-const path = require$$1;
+const fs$3 = require$$0.promises;
+const path$1 = require$$1;
 
 /**
  * Retrieves the raw Markdown content of the shared system message ('_shared/system/1.md').
  *
- * @param {string} analyzeMessagesBasePath - The absolute path to the base directory containing analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers (e.g., 'analyzers/analyzer-1').
  * @returns {Promise<string|null>} A promise that resolves with the full Markdown content, or null if not found/invalid.
  */
-async function getSystemMessageContent$2(analyzeMessagesBasePath) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        console.error('Error: analyzeMessagesBasePath is required for getSystemMessageContent.');
+async function getSystemMessageContent$2(analyzersBasePath) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        console.error('Error: analyzersBasePath is required for getSystemMessageContent.');
         return null;
     }
 
-    const systemMessageFilePath = path.join(analyzeMessagesBasePath, '_shared', 'system', '1.md');
+    const systemMessageFilePath = path$1.join(analyzersBasePath, '_shared', 'system', '1.md');
 
     try {
-        const fileContent = await fs$2.readFile(systemMessageFilePath, 'utf8');
+        const fileContent = await fs$3.readFile(systemMessageFilePath, 'utf8');
         const parts = fileContent.split('\n\n\n');
         parts.shift();
         return parts.join('\n\n\n');
@@ -12007,19 +12397,19 @@ async function getSystemMessageContent$2(analyzeMessagesBasePath) {
 /**
  * Retrieves the raw Markdown content of the shared start message ('_shared/start/1.md').
  *
- * @param {string} analyzeMessagesBasePath - The absolute path to the base directory containing analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers (e.g., 'analyzers/analyzer-1').
  * @returns {Promise<string|null>} A promise that resolves with the full Markdown content, or null if not found/invalid.
  */
-async function getStartMessageContent$2(analyzeMessagesBasePath) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        console.error('Error: analyzeMessagesBasePath is required for getStartMessageContent.');
+async function getStartMessageContent$2(analyzersBasePath) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        console.error('Error: analyzersBasePath is required for getStartMessageContent.');
         return null;
     }
 
-    const startMessageFilePath = path.join(analyzeMessagesBasePath, '_shared', 'start', '1.md');
+    const startMessageFilePath = path$1.join(analyzersBasePath, '_shared', 'start', '1.md');
 
     try {
-        const fileContent = await fs$2.readFile(startMessageFilePath, 'utf8');
+        const fileContent = await fs$3.readFile(startMessageFilePath, 'utf8');
         const parts = fileContent.split('\n\n\n');
         parts.shift();
         return parts.join('\n\n\n');
@@ -12040,59 +12430,400 @@ var defaultPromptLoader = {
 };
 
 /*
- * Component: AnalyzerUtils Index
- * Block-UUID: b403b6a1-230b-4247-8cd6-2a3d068f4bbf
- * Parent-UUID: N/A
- * Version: 1.2.0
- * Description: Aggregates and exports all utility functions from the AnalyzerUtils module.
- * Language: JavaScript
- * Created-at: 2025-08-28T15:56:40.319Z
- * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Flash (v1.1.0), Gemini 2.5 Flash (v1.2.0)
- */
-
-const { buildChatIdToPathMap: buildChatIdToPathMap$1 } = contextMapper;
-const { processLLMAnalysisResponse: processLLMAnalysisResponse$1 } = responseProcessor;
-const { validateLLMAnalysisData: validateLLMAnalysisData$1 } = dataValidator;
-const { getAnalyzers: getAnalyzers$1 } = discovery;
-const { saveConfiguration } = saver;
-const { getAnalyzerSchema: getAnalyzerSchema$1 } = schemaLoader;
-const { deleteAnalyzer: deleteAnalyzer$1 } = management;
-const { getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$1 } = instructionLoader;
-const { getSystemMessageContent: getSystemMessageContent$1, getStartMessageContent: getStartMessageContent$1 } = defaultPromptLoader; // NEW: Import default prompt loaders
-
-var AnalyzerUtils$1 = {
-    buildChatIdToPathMap: buildChatIdToPathMap$1,
-    processLLMAnalysisResponse: processLLMAnalysisResponse$1,
-    validateLLMAnalysisData: validateLLMAnalysisData$1,
-    getAnalyzers: getAnalyzers$1,
-    getAnalyzerSchema: getAnalyzerSchema$1,
-    deleteAnalyzer: deleteAnalyzer$1,
-    getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$1,
-    saveConfiguration,
-    getSystemMessageContent: getSystemMessageContent$1,
-    getStartMessageContent: getStartMessageContent$1
-};
-
-/**
- * Component: LLMUtils
- * Block-UUID: a3106054-42f1-474f-96f3-182d66eb19a0
+ * Component: AnalyzerUtils Updater
+ * Block-UUID: 8a7b6c5d-4e3f-2a1b-9c8d-7e6f5a4b3c2d
  * Parent-UUID: N/A
  * Version: 1.0.0
- * Description: Provides utility functions related to Large Language Model interactions, such as token estimation.
+ * Description: Provides utility functions for updating analyzer configurations, including renaming and metadata updates.
  * Language: JavaScript
- * Created-at: 2025-04-22T17:16:00.590Z
- * Authors: Gemini 2.5 Pro (v1.0.0)
+ * Created-at: 2025-12-25T19:55:00.000Z
+ * Authors: GLM-4.6 (v1.0.0)
  */
 
+const fs$2 = require$$0.promises;
+const path = require$$1;
+const CodeBlockUtils$2 = CodeBlockUtils$7;
+const { preprocessJsonForValidation: preprocessJsonForValidation$2 } = jsonParser;
+const { isValidDirName: isValidDirName$1 } = discovery;
+const { readConfig } = discovery;
+
 /**
- * Estimates the number of tokens in a given text string.
- * This is a basic estimation using the common heuristic of ~4 characters per token.
- * Actual token count can vary significantly based on the specific tokenizer used by an LLM.
+ * Updates an analyzer configuration, including renaming the analyzer if needed.
  *
- * @param {string} text - The text to estimate tokens for.
- * @returns {number} An estimated token count. Returns 0 if input is not a non-empty string.
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers.
+ * @param {string} analyzerId - The current unique ID of the analyzer (format: 'analyzer_name::content_type::instructions_type').
+ * @param {object} updates - The updates to apply to the analyzer.
+ * @param {string} [updates.name] - The new analyzer name (for renaming the directory).
+ * @param {string} [updates.label] - The new label for the analyzer.
+ * @param {string} [updates.description] - The new description for the analyzer.
+ * @param {string} [updates.version] - The new version for the analyzer.
+ * @param {Array<string>} [updates.tags] - The new tags for the analyzer.
+ * @returns {Promise<{success: boolean, message: string, newAnalyzerId?: string}>} A promise that resolves with a result object.
  */
-function estimateTokens$1(text) {
+async function updateAnalyzer$1(analyzersBasePath, analyzerId, updates) {
+    // 1. Validate inputs
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        return { success: false, message: 'analyzersBasePath is required.' };
+    }
+    if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
+        return { success: false, message: 'analyzerId is required.' };
+    }
+    if (!updates || typeof updates !== 'object') {
+        return { success: false, message: 'updates object is required.' };
+    }
+
+    // 2.0 Parse current analyzerId
+    const parts = analyzerId.split('::');
+    if (parts.length !== 3) {
+        return { success: false, message: `Invalid analyzerId format. Expected 'analyzer_name::content_type::instructions_type', but got '${analyzerId}'.` };
+    }
+    const [analyzerName, contentType, instructionsType] = parts;
+
+    // 2.1 Unset name if it has been provided but is the same as the analyzerName
+    if (updates.name && analyzerName === updates.name) {
+        delete updates.name;
+    }
+
+    // 3. Validate new name if provided
+    if (updates.name && !isValidDirName$1(updates.name)) {
+        return { success: false, message: `Invalid analyzer name '${updates.name}'. Names must be alphanumeric, dash, or underscore, cannot start with underscore, and cannot contain dots.` };
+    }
+
+    // 4. Check if analyzer is protected
+    const analyzerDir = path.join(analyzersBasePath, analyzerName);
+    const analyzerConfig = await readConfig(analyzerDir);
+    if (analyzerConfig?.protected) {
+        return { success: false, message: `Analyzer '${analyzerName}' is protected and cannot be updated.` };
+    }
+
+    // 5. Get current instructions content
+    const instructionsFilePath = path.join(analyzerDir, contentType, instructionsType, '1.md');
+    let instructionsContent;
+    try {
+        instructionsContent = await fs$2.readFile(instructionsFilePath, 'utf8');
+    } catch (error) {
+        return { success: false, message: `Failed to read analyzer instructions: ${error.message}` };
+    }
+
+    // 6. Extract and update JSON block
+    const { blocks } = CodeBlockUtils$2.extractCodeBlocks(instructionsContent, { silent: true });
+    const jsonBlock = blocks.find(block => block.language === 'json');
+    
+    if (!jsonBlock) {
+        return { success: false, message: 'No JSON block found in analyzer instructions.' };
+    }
+
+    let jsonData;
+    try {
+        const preprocessedContent = preprocessJsonForValidation$2(jsonBlock.content);
+        jsonData = JSON.parse(preprocessedContent);
+    } catch (error) {
+        return { success: false, message: `Failed to parse JSON block: ${error.message}` };
+    }
+
+    // 7. Update JSON data with provided values
+    if (updates.label !== undefined) jsonData.label = updates.label;
+    if (updates.description !== undefined) jsonData.description = updates.description;
+    if (updates.version !== undefined) jsonData.version = updates.version;
+    if (updates.tags !== undefined) jsonData.tags = updates.tags;
+
+    // 8. Rebuild the instructions content with updated JSON
+    const updatedJsonContent = JSON.stringify(jsonData, null, 2);
+    const updatedInstructionsContent = instructionsContent.replace(
+        jsonBlock.content,
+        updatedJsonContent
+    );
+
+    // 9. Handle directory renaming if needed
+    let newAnalyzerId = analyzerId;
+    if (updates.name && updates.name !== analyzerName) {
+        // Create new directory structure
+        const newAnalyzerDir = path.join(analyzersBasePath, updates.name);
+        const newContentDir = path.join(newAnalyzerDir, contentType);
+        const newInstructionsDir = path.join(newContentDir, instructionsType);
+        const newInstructionsFilePath = path.join(newInstructionsDir, '1.md');
+
+        try {
+            // Create new directories
+            await fs$2.mkdir(newInstructionsDir, { recursive: true });
+
+            // Copy config.json if it exists
+            const configPath = path.join(analyzerDir, 'config.json');
+            const newConfigPath = path.join(newAnalyzerDir, 'config.json');
+            try {
+                const configContent = await fs$2.readFile(configPath, 'utf8');
+                await fs$2.writeFile(newConfigPath, configContent, 'utf8');
+            } catch (error) {
+                // Config file might not exist, that's okay
+            }
+
+            // Copy content config.json if it exists
+            const contentConfigPath = path.join(analyzerDir, contentType, 'config.json');
+            const newContentConfigPath = path.join(newContentDir, 'config.json');
+            try {
+                const contentConfigContent = await fs$2.readFile(contentConfigPath, 'utf8');
+                await fs$2.writeFile(newContentConfigPath, contentConfigContent, 'utf8');
+            } catch (error) {
+                // Config file might not exist, that's okay
+            }
+
+            // Copy instructions config.json if it exists
+            const instructionsConfigPath = path.join(analyzerDir, contentType, instructionsType, 'config.json');
+            const newInstructionsConfigPath = path.join(newInstructionsDir, 'config.json');
+            try {
+                const instructionsConfigContent = await fs$2.readFile(instructionsConfigPath, 'utf8');
+                await fs$2.writeFile(newInstructionsConfigPath, instructionsConfigContent, 'utf8');
+            } catch (error) {
+                // Config file might not exist, that's okay
+            }
+
+            // Write updated instructions to new location
+            const finalContent = `; role: assistant\n\n\n${updatedInstructionsContent}`;
+            await fs$2.writeFile(newInstructionsFilePath, finalContent, 'utf8');
+
+            // Update the analyzer ID
+            newAnalyzerId = `${updates.name}::${contentType}::${instructionsType}`;
+
+            // Delete old analyzer directory (will be done after successful save)
+        } catch (error) {
+            return { success: false, message: `Failed to create new analyzer directory: ${error.message}` };
+        }
+    } else {
+        // Just update the existing file
+        const finalContent = `; role: assistant\n\n\n${updatedInstructionsContent}`;
+        await fs$2.writeFile(instructionsFilePath, finalContent, 'utf8');
+    }
+
+    // 10. Clean up old directory if renamed
+    if (updates.name && updates.name !== analyzerName) {
+        try {
+            // Use the deleteAnalyzer function to clean up the old directory
+            const { deleteAnalyzer } = management;
+            await deleteAnalyzer(analyzersBasePath, analyzerId);
+        } catch (error) {
+            console.warn(`Warning: Could not clean up old analyzer directory: ${error.message}`);
+        }
+    }
+
+    return { 
+        success: true, 
+        message: `Analyzer '${analyzerId}' updated successfully.`, 
+        newAnalyzerId 
+    };
+}
+
+var updater = {
+    updateAnalyzer: updateAnalyzer$1
+};
+
+/*
+ * Component: AnalyzerUtils Cloner
+ * Block-UUID: 56b8c9f4-97ce-406c-a598-22a838ebefda
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions for cloning analyzer configurations.
+ * Language: JavaScript
+ * Created-at: 2025-12-26T16:59:39.782Z
+ * Authors: GLM-4.6 (v1.0.0)
+ */
+
+require$$0.promises;
+const CodeBlockUtils$1 = CodeBlockUtils$7;
+const { preprocessJsonForValidation: preprocessJsonForValidation$1 } = jsonParser;
+const { isValidDirName } = discovery;
+const { saveConfiguration: saveConfiguration$1 } = saver;
+const { getAnalyzers: getAnalyzers$2 } = discovery;
+
+/**
+ * Clones an existing analyzer with a new name.
+ *
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers.
+ * @param {string} originalAnalyzerId - The ID of the analyzer to clone (format: 'analyzer_name::content_type::instructions_type').
+ * @param {string} newAnalyzerName - The new name for the cloned analyzer.
+ * @param {object} [options={}] - Optional configuration options.
+ * @param {string} [options.label] - The new label for the cloned analyzer (optional, defaults to newAnalyzerName).
+ * @param {string} [options.description] - The new description for the cloned analyzer (optional, keeps original if not provided).
+ * @returns {Promise<{success: boolean, message: string, newAnalyzerId?: string}>} A promise that resolves with a result object.
+ */
+async function cloneAnalyzer$1(analyzersBasePath, originalAnalyzerId, newAnalyzerName, options = {}) {
+    // 1. Validate inputs
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        return { success: false, message: 'analyzersBasePath is required.' };
+    }
+    if (typeof originalAnalyzerId !== 'string' || originalAnalyzerId.trim() === '') {
+        return { success: false, message: 'originalAnalyzerId is required.' };
+    }
+    if (typeof newAnalyzerName !== 'string' || newAnalyzerName.trim() === '') {
+        return { success: false, message: 'newAnalyzerName is required.' };
+    }
+
+    // 2. Parse original analyzerId
+    const parts = originalAnalyzerId.split('::');
+    if (parts.length !== 3) {
+        return { success: false, message: `Invalid originalAnalyzerId format. Expected 'analyzer_name::content_type::instructions_type', but got '${originalAnalyzerId}'.` };
+    }
+    const [originalAnalyzerName, contentType, instructionsType] = parts;
+
+    // 3. Validate new analyzer name
+    if (!isValidDirName(newAnalyzerName)) {
+        return { success: false, message: `Invalid analyzer name '${newAnalyzerName}'. Names must be alphanumeric, dash, or underscore, cannot start with underscore, and cannot contain dots.` };
+    }
+
+    // 4. Check if new analyzer name already exists
+    try {
+        const existingAnalyzers = await getAnalyzers$2(analyzersBasePath);
+        const nameExists = existingAnalyzers.some(analyzer => analyzer.name === newAnalyzerName);
+        if (nameExists) {
+            return { success: false, message: `An analyzer with name '${newAnalyzerName}' already exists. Please choose a different name.` };
+        }
+    } catch (error) {
+        return { success: false, message: `Failed to check for existing analyzers: ${error.message}` };
+    }
+
+    // 5. Get original analyzer's instructions content
+    const { getAnalyzerInstructionsContent } = instructionLoader;
+    let instructionsContent;
+    try {
+        instructionsContent = await getAnalyzerInstructionsContent(analyzersBasePath, originalAnalyzerId);
+        if (!instructionsContent) {
+            return { success: false, message: `Could not find original analyzer '${originalAnalyzerId}'.` };
+        }
+    } catch (error) {
+        return { success: false, message: `Failed to read original analyzer instructions: ${error.message}` };
+    }
+
+    // 6. Extract and update JSON block
+    const { blocks } = CodeBlockUtils$1.extractCodeBlocks(instructionsContent, { silent: true });
+    const jsonBlocks = blocks.filter((block, index) => {
+        if (block.language === 'json') {
+            block.index = index;
+            return block;
+        }
+    });
+    const jsonBlock = jsonBlocks[jsonBlocks.length - 1];
+    
+    if (!jsonBlock) {
+        return { success: false, message: 'No JSON block found in original analyzer instructions.' };
+    }
+
+    let jsonData;
+    try {
+        const preprocessedContent = preprocessJsonForValidation$1(jsonBlock.content);
+        jsonData = JSON.parse(preprocessedContent);
+    } catch (error) {
+        return { success: false, message: `Failed to parse JSON block: ${error.message}` };
+    }
+
+    // 7. Update JSON data with new values
+    if (options.label !== undefined) { 
+        jsonData.label = options.label;
+    } 
+    if (options.description !== undefined) {
+        jsonData.description = options.description;
+    }
+    // Reset version for cloned analyzer
+    jsonData.version = '1.0.0';
+
+    // 8. Rebuild the instructions content with updated JSON
+    let updatedInstructionsContent = CodeBlockUtils$1.updateCodeBlockByIndex(
+        instructionsContent,
+        jsonBlock.index,
+        JSON.stringify(jsonData, null, 2),
+        'json'
+    );
+
+    // 9. Create the new analyzer ID
+    const newAnalyzerId = `${newAnalyzerName}::${contentType}::${instructionsType}`;
+
+    // 10. Update the analyzer id in the instructions
+    updatedInstructionsContent = updatedInstructionsContent.replaceAll(originalAnalyzerId, newAnalyzerId);
+
+    // 11. Save the new analyzer
+    try {
+        const saveResult = await saveConfiguration$1(
+            analyzersBasePath,
+            newAnalyzerId,
+            updatedInstructionsContent
+        );
+        
+        if (saveResult.success) {
+            return { 
+                success: true, 
+                message: `Analyzer '${originalAnalyzerName}' cloned successfully as '${newAnalyzerName}'.`, 
+                newAnalyzerId 
+            };
+        } else {
+            return { success: false, error: saveResult.message };
+        }
+    } catch (error) {
+        return { success: false, message: `Failed to save cloned analyzer: ${error.message}` };
+    }
+}
+
+var cloner = {
+    cloneAnalyzer: cloneAnalyzer$1
+};
+
+/*
+ * Component: AnalyzerUtils Index
+ * Block-UUID: 780e17b0-0c1e-4d77-bf6e-302951b341bf
+ * Parent-UUID: b403b6a1-230b-4247-8cd6-2a3d068f4bbf
+ * Version: 1.5.0
+ * Description: Aggregates and exports all utility functions from the AnalyzerUtils module. Added cloneAnalyzer method.
+ * Language: JavaScript
+ * Created-at: 2025-08-28T15:56:40.319Z
+ * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Flash (v1.1.0), Gemini 2.5 Flash (v1.2.0), GLM-4.6 (v1.3.0), GLM-4.6 (v1.4.0), GLM-4.6 (v1.5.0)
+ */
+
+const { buildChatIdToPathMap: buildChatIdToPathMap$1 } = contextMapper;
+const { processLLMAnalysisResponse: processLLMAnalysisResponse$1 } = responseProcessor;
+const { validateLLMAnalysisData: validateLLMAnalysisData$1 } = dataValidator;
+const { getAnalyzers: getAnalyzers$1 } = discovery;
+const { saveConfiguration } = saver;
+const { getAnalyzerSchema: getAnalyzerSchema$1 } = schemaLoader;
+const { deleteAnalyzer: deleteAnalyzer$1 } = management;
+const { getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$1 } = instructionLoader;
+const { getSystemMessageContent: getSystemMessageContent$1, getStartMessageContent: getStartMessageContent$1 } = defaultPromptLoader;
+const { preprocessJsonForValidation } = jsonParser;
+const { updateAnalyzer } = updater;
+const { cloneAnalyzer } = cloner;
+
+var AnalyzerUtils$1 = {
+    buildChatIdToPathMap: buildChatIdToPathMap$1,
+    processLLMAnalysisResponse: processLLMAnalysisResponse$1,
+    validateLLMAnalysisData: validateLLMAnalysisData$1,
+    getAnalyzers: getAnalyzers$1,
+    getAnalyzerSchema: getAnalyzerSchema$1,
+    deleteAnalyzer: deleteAnalyzer$1,
+    getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$1,
+    saveConfiguration,
+    getSystemMessageContent: getSystemMessageContent$1,
+    getStartMessageContent: getStartMessageContent$1,
+    preprocessJsonForValidation,
+    updateAnalyzer,
+    cloneAnalyzer
+};
+
+/**
+ * Component: LLMUtils
+ * Block-UUID: a3106054-42f1-474f-96f3-182d66eb19a0
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions related to Large Language Model interactions, such as token estimation.
+ * Language: JavaScript
+ * Created-at: 2025-04-22T17:16:00.590Z
+ * Authors: Gemini 2.5 Pro (v1.0.0)
+ */
+
+/**
+ * Estimates the number of tokens in a given text string.
+ * This is a basic estimation using the common heuristic of ~4 characters per token.
+ * Actual token count can vary significantly based on the specific tokenizer used by an LLM.
+ *
+ * @param {string} text - The text to estimate tokens for.
+ * @returns {number} An estimated token count. Returns 0 if input is not a non-empty string.
+ */
+function estimateTokens$1(text) {
     if (typeof text !== 'string' || text.length === 0) {
         return 0;
     }
@@ -12274,13 +13005,13 @@ var FormatterUtils$1 = {
 
 /**
  * Component: DomUtils Helper Functions
- * Block-UUID: e85d4e1d-f45e-450b-a0f2-941af362c2be
- * Parent-UUID: fe462d17-e1c8-45d6-9fb0-f53322c9cda9
- * Version: 1.1.0
+ * Block-UUID: 9a8e8e8e-8b15-4346-bbfa-740e6a5d2d79
+ * Parent-UUID: 8a528728-ce54-4445-946d-1743fb4b16be
+ * Version: 1.3.0
  * Description: Provides helper functions for creating and manipulating DOM elements.
  * Language: JavaScript
- * Created-at: 2025-09-11T19:03:50.026Z
- * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Flash (v1.1.0)
+ * Created-at: 2025-12-14T04:18:40.180Z
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Flash (v1.1.0), Qwen 3 Coder 480B - Cerebras (v1.2.0), GLM-4.6 (v1.2.1), GLM-4.6 (v1.3.0)
  */
 
 function createElement(type, params) {
@@ -12292,6 +13023,7 @@ function createElement(type, params) {
     let {
         id,
         ariaLabel,
+        xmlns,
         role,
         html,
         text,
@@ -12314,11 +13046,15 @@ function createElement(type, params) {
         "data-message-role": dmr,
         attrs = {},
         dataset,
+        rows
     } = params;
 
     // Set standard attributes
     if (id != null) elem.id = id;
     if (ariaLabel) elem.setAttribute("aria-label", ariaLabel);
+    if (xmlns) elem.setAttribute("xmlns", xmlns);
+    if (params.viewBox) elem.setAttribute("viewBox", params.viewBox);
+    if (params.fill) elem.setAttribute("fill", params.fill);
     if (role) elem.setAttribute("role", role);
     if (placeholder) elem.setAttribute("placeholder", placeholder);
     if (cls || className) elem.setAttribute("class", cls || className);
@@ -12326,6 +13062,9 @@ function createElement(type, params) {
     if (title != null) elem.setAttribute("title", title);
     if (inputType) elem.setAttribute("type", inputType);
     if (name != null) elem.setAttribute("name", name);
+    if (params.width) elem.setAttribute("width", params.width);
+    if (params.height) elem.setAttribute("height", params.height);
+    if (params.stroke) elem.setAttribute("stroke", params.stroke);
     if (value != null) elem.value = value;
     if (checked != null && checked) elem.checked = true; // Use property for checked
     if (selected != null && selected) elem.selected = true; // Use property for selected
@@ -12333,13 +13072,21 @@ function createElement(type, params) {
     if (dmi != null) elem.setAttribute("data-message-id", dmi);
     if (dmr != null) elem.setAttribute("data-message-role", dmr);
     if (_for != null ) elem.setAttribute("for", _for);
+    if (params.strokeWidth) elem.setAttribute("stroke-width", params.strokeWidth);
+    if (params.strokeLinecap) elem.setAttribute("stroke-linecap", params.strokeLinecap);
+    if (params.strokeLinejoin) elem.setAttribute("stroke-linejoin", params.strokeLinejoin);
     if (colSpan != null) elem.colSpan = colSpan;
+    if (rows) elem.setAttribute("rows", params.rows);
 
     // Set content
     if (html != null) {
         if (typeof html === "object" && html instanceof Node) { // Ensure html is a Node
             elem.appendChild(html);
         } else if (typeof html === "string") {
+            // For SVG elements, use innerHTML to support path elements
+            if (type === 'svg' && params.innerHTML) {
+                elem.innerHTML = params.innerHTML;
+            }
             elem.innerHTML = html;
         }
     } else if (text != null) {
@@ -12365,12 +13112,12 @@ function createElement(type, params) {
         });
     }
 
-    // NEW: Set additional attributes from attrs object
+    // Set additional attributes from attrs object
     if (attrs && typeof attrs === 'object') {
         for (const [key, value] of Object.entries(attrs)) {
             if (value !== undefined && value !== null) {
                 // Skip if already set by standard properties or handled directly
-                if (!['id', 'class', 'role', 'aria-label', 'title', 'style', 'checked', 'selected', 'disabled', 'value', 'name', 'type', 'for'].includes(key) && !key.startsWith('data-')) {
+                if (!['id', 'class', 'role', 'aria-label', 'title', 'style', 'selected', 'disabled', 'value', 'name', 'type', 'for'].includes(key) && !key.startsWith('data-')) {
                     elem.setAttribute(key, value);
                 }
             }
@@ -12483,14 +13230,17 @@ const h$1 = {
     },
     createLink: (params) => {
         const link = createElement("a", params);
-        // href and target are handled by createElement
-        if (params?.href) link.href = params.href; // Ensure href is set if provided
+        if (params?.href) link.href = params.href;
+        if (params?.target) link.target = params.target;
         return link;
     },
     createNav: (params) => {
         return createElement("nav", params);
     },
-    createOL: (params) => { // Added
+    createOl: (params) => {
+        return createElement("ol", params);
+    },
+    createOL: (params) => {
         return createElement("ol", params);
     },
     createOption: (params) => { // Added
@@ -12508,11 +13258,33 @@ const h$1 = {
     },
     createSelect: (params) => { // Added
         // name, disabled etc handled by createElement
-        return createElement("select", params);
+        const select = createElement("select", params);
+        
+        // Handle options array if provided
+        if (params && params.options && Array.isArray(params.options)) {
+            params.options.forEach(option => {
+                if (option && typeof option === 'object') {
+                    const optionElement = createElement("option", {
+                        value: option.value,
+                        text: option.text,
+                        selected: option.selected
+                    });
+                    select.appendChild(optionElement);
+                }
+            });
+        }
+        
+        return select;
     },
     createSpan: (params) => {
         return createElement("span", params);
     },
+    createSvg: (params) => {
+        // Create SVG element with xmlns attribute
+        const svgParams = { ...params, xmlns: "http://www.w3.org/2000/svg" };
+        const svg = createElement("svg", svgParams);
+        return svg;
+    },
     createStrong: (params) => { // Added
         return createElement("strong", params);
     },
@@ -12525,6 +13297,10 @@ const h$1 = {
     createText: (text) => {
         return document.createTextNode(text);
     },
+    createTextarea: (params) => {
+        const textArea = createElement("textarea", params);
+        return textArea;
+    },
     createTextArea: (params) => {
         const textArea = createElement("textarea", params);
         return textArea;
@@ -12723,6 +13499,35 @@ const h$1 = {
             })
             .join('');
     },
+    
+    /**
+     * Injects CSS styles into the document head.
+     * @param {string} cssString - The CSS string to inject.
+     * @param {string} [id] - Optional ID for the style element to prevent duplicates.
+     * @returns {HTMLStyleElement} The created or existing style element.
+     */
+    injectStyles: (cssString, id) => {
+        // If an ID is provided, check if styles with this ID already exist
+        if (id) {
+            const existingStyle = document.getElementById(id);
+            if (existingStyle) {
+                // Styles already injected, return the existing element
+                return existingStyle;
+            }
+        }
+
+        // Create a new style element
+        const styleElement = document.createElement('style');
+        if (id) {
+            styleElement.id = id;
+        }
+        styleElement.textContent = cssString;
+
+        // Append to the document head
+        document.head.appendChild(styleElement);
+
+        return styleElement;
+    },
 
     /**
      * Calculates the distance between an element's edge and the viewport's corresponding edge
@@ -22355,7 +23160,10 @@ function createMarkdownRenderer$1(hljs, hstyle = {}, nhstyle = {}) {
                     // Create the inner code element with the highlighted content
                     // and the language label prepended.
                     const codeElement = h.createCode({
-                        html: `<span class='gs-chat-lang'>${lang}</span>\n\n${highlightedCode}`
+                        html: `<span class='gs-chat-lang'>${lang}</span>\n\n${highlightedCode}`,
+                        style: {
+                            fontSize: '13px'
+                        }
                     });
 
                     // Wrap the code element in a pre tag with styling
@@ -23163,6 +23971,18 @@ let SVGUtils$1 = class SVGUtils {
         return this.create(xml, params);
     }
 
+    /**
+     * Generate dropZone SVG icon
+     * @param {Object} params - Configuration parameters
+     * @returns {Element} SVG element
+     */
+    static dropZone(params) {
+        const xml = `<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' width='64' height='64'><path d="M7 18C4.23858 18 2 15.7614 2 13C2 10.2386 4.23858 8 7 8C7.55228 8 8 8.44772 8 9C8 9.55228 7.55228 10 7 10C5.34315 10 4 11.3431 4 13C4 14.6569 5.34315 16 7 16H17C18.6569 16 20 14.6569 20 13C20 11.3431 18.6569 10 17 10C16.4477 10 16 9.55228 16 9C16 8.44772 16.4477 8 17 8C19.7614 8 22 10.2386 22 13C22 15.7614 19.7614 18 17 18H7Z" fill="currentColor"/><path d="M12 2L12 14M12 14L9 11M12 14L15 11" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+        return this.create(xml, params);
+    }
+
+
+
     /**
      * Generate dot SVG icon
      * @param {Object} params - Configuration parameters
@@ -23203,6 +24023,26 @@ let SVGUtils$1 = class SVGUtils {
         return this.create(xml, params);
     }
 
+    /**
+     * Generate eye SVG icon
+     * @param {Object} params - Configuration parameters
+     * @returns {Element} SVG element
+     */
+    static eye(params) {
+        const xml = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16"><path d="M8 2c1.981 0 3.671.992 4.933 2.078 1.27 1.091 2.187 2.345 2.637 3.023a1.62 1.62 0 0 1 0 1.798c-.45.678-1.367 1.932-2.637 3.023C11.67 13.008 9.981 14 8 14c-1.981 0-3.671-.992-4.933-2.078C1.797 10.83.88 9.576.43 8.898a1.62 1.62 0 0 1 0-1.798c.45-.677 1.367-1.931 2.637-3.022C4.33 2.992 6.019 2 8 2ZM1.679 7.932a.12.12 0 0 0 0 .136c.411.622 1.241 1.75 2.366 2.717C5.176 11.758 6.527 12.5 8 12.5c1.473 0 2.825-.742 3.955-1.715 1.124-.967 1.954-2.096 2.366-2.717a.12.12 0 0 0 0-.136c-.412-.621-1.242-1.75-2.366-2.717C10.824 4.242 9.473 3.5 8 3.5c-1.473 0-2.825.742-3.955 1.715-1.124.967-1.954 2.096-2.366 2.717ZM8 10a2 2 0 1 1-.001-3.999A2 2 0 0 1 8 10Z"></path></svg>`;
+        return this.create(xml, params);
+    }
+
+    /**
+     * Generate eye closed SVG icon
+     * @param {Object} params - Configuration parameters
+     * @returns {Element} SVG element
+     */
+    static eyeClosed(params) {
+        const xml = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16"><path d="M.143 2.31a.75.75 0 0 1 1.047-.167l14.5 10.5a.75.75 0 1 1-.88 1.214l-2.248-1.628C11.346 13.19 9.792 14 8 14c-1.981 0-3.67-.992-4.933-2.078C1.797 10.832.88 9.577.43 8.9a1.619 1.619 0 0 1 0-1.797c.353-.533.995-1.42 1.868-2.305L.31 3.357A.75.75 0 0 1 .143 2.31Zm1.536 5.622A.12.12 0 0 0 1.657 8c0 .021.006.045.022.068.412.621 1.242 1.75 2.366 2.717C5.175 11.758 6.527 12.5 8 12.5c1.195 0 2.31-.488 3.29-1.191L9.063 9.695A2 2 0 0 1 6.058 7.52L3.529 5.688a14.207 14.207 0 0 0-1.85 2.244ZM8 3.5c-.516 0-1.017.09-1.499.251a.75.75 0 1 1-.473-1.423A6.207 6.207 0 0 1 8 2c1.981 0 3.67.992 4.933 2.078 1.27 1.091 2.187 2.345 2.637 3.023a1.62 1.62 0 0 1 0 1.798c-.11.166-.248.365-.41.587a.75.75 0 1 1-1.21-.887c.148-.201.272-.382.371-.53a.119.119 0 0 0 0-.137c-.412-.621-1.242-1.75-2.366-2.717C10.825 4.242 9.473 3.5 8 3.5Z"></path></svg>`;
+        return this.create(xml, params);
+    }
+
     /**
      * Generate file SVG icon
      * @param {Object} params - Configuration parameters
@@ -23759,6 +24599,16 @@ let SVGUtils$1 = class SVGUtils {
         return this.create(xml, params);
     }
 
+    /**
+     * Generate squarCircle SVG icon
+     * @param {Object} params - Configuration parameters
+     * @returns {Element} SVG element
+     */
+    static squareCircle(params) {
+        const xml = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16"><path d="M8 16A8 8 0 1 1 8 0a8 8 0 0 1 0 16Zm0-1.5a6.5 6.5 0 1 0 0-13 6.5 6.5 0 0 0 0 13Z"></path><path d="M5 5.75A.75.75 0 0 1 5.75 5h4.5a.75.75 0 0 1 .75.75v4.5a.75.75 0 0 1-.75.75h-4.5a.75.75 0 0 1-.75-.75Z"></path></svg>`;
+        return this.create(xml, params);
+    }
+
     /**
      * Generate stack SVG icon
      * @param {Object} params - Configuration parameters
@@ -24049,6 +24899,16 @@ let SVGUtils$1 = class SVGUtils {
         return this.create(xml, params);
     }
 
+    /**
+     * Generate verticalEllipsis SVG icon
+     * @param {Object} params - Configuration parameters
+     * @returns {Element} SVG element
+     */
+    static verticalEllipsis(params) {
+        const xml = `<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' width='16' height='16' transform='rotate(90)'><path d='M8 9a1.5 1.5 0 100-3 1.5 1.5 0 000 3zM1.5 9a1.5 1.5 0 100-3 1.5 1.5 0 000 3zm13 0a1.5 1.5 0 100-3 1.5 1.5 0 000 3z'></path></svg>`;
+        return this.create(xml, params);
+    }
+
     /**
      * Generate x SVG icon
      * @param {Object} params - Configuration parameters
@@ -24078,35 +24938,343 @@ let SVGUtils$1 = class SVGUtils {
         const xml = `<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' width='16' height='16'><path fill-rule='evenodd' d='M2.343 13.657A8 8 0 1113.657 2.343 8 8 0 012.343 13.657zM6.03 4.97a.75.75 0 00-1.06 1.06L6.94 8 4.97 9.97a.75.75 0 101.06 1.06L8 9.06l1.97 1.97a.75.75 0 101.06-1.06L9.06 8l1.97-1.97a.75.75 0 10-1.06-1.06L8 6.94 6.03 4.97z'></path></svg>`;
         return this.create(xml, params);
     }
+
+    static zai(params) {
+        const xml = `<svg xmlns="http://www.w3.org/2000/svg" fill="currentColor" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em"><title>Z.ai</title><path d="M12.105 2L9.927 4.953H.653L2.83 2h9.276zM23.254 19.048L21.078 22h-9.242l2.174-2.952h9.244zM24 2L9.264 22H0L14.736 2H24z"/></svg>`;
+        return this.create(xml, params);
+    }
 };
 
 var SVGUtils_1 = SVGUtils$1;
 
 /*
- * Component: Language Name Utils 
- * Block-UUID: 313abeab-2bb3-49d1-8693-e9e88aa97113
- * Parent-UUID: N/A
+ * Component: StringUtils
+ * Block-UUID: 7069f2b4-f0b3-4dcd-9eae-5cecaddcdd66
  * Version: 1.0.0
- * Description: Utility for converting common lowercase language names and aliases to their proper capitalization
+ * Description: A collection of utility functions for common string manipulation and processing tasks within GitSense Chat.
  * Language: JavaScript
- * Created-at: 2025-10-19T23:25:09.231Z
+ * Created-at: 2025-10-30T22:06:47.000Z
  * Authors: Qwen 3 Coder 480B - Cerebras (v1.0.0)
  */
 
 /**
- * A mapping of language aliases to their properly capitalized names
+ * Splits a string into an array of substrings based on a delimiter, up to a specified limit.
+ * This mimics behavior similar to Python's `str.split(sep, maxsplit)` or Java's `String.split(regex, limit)`.
+ * 
+ * @param {string} text - The string to split.
+ * @param {string|RegExp} delimiter - The delimiter to split the string by.
+ * @param {number} [limit=Infinity] - The maximum number of parts to return. The final part will contain the remainder of the string.
+ * @returns {string[]} An array of substrings.
  */
-const LANGUAGE_NAME_MAP = {
-  // Core Programming Languages
-  'javascript': 'JavaScript',
-  'js': 'JavaScript',
-  'typescript': 'TypeScript',
-  'ts': 'TypeScript',
-  'python': 'Python',
-  'py': 'Python',
-  'java': 'Java',
-  'c': 'C',
-  'c++': 'C++',
+function splitWithLimit$1(text, delimiter, limit = Infinity) {
+    if (limit === 0) {
+        return [];
+    }
+    if (limit === 1) {
+        return [text];
+    }
+
+    const parts = [];
+    let remainingText = text;
+    let count = 0;
+
+    // Handle RegExp delimiter
+    if (delimiter instanceof RegExp) {
+        // For RegExp, we need to manually find matches and slice the string
+        // This is a simplified approach and might not cover all edge cases of global regex matching
+        // especially with capture groups or zero-width matches.
+        const flags = delimiter.flags.includes('g') ? delimiter.flags : delimiter.flags + 'g';
+        const globalDelimiter = new RegExp(delimiter.source, flags);
+        let match;
+        let lastIndex = 0;
+        let matchCount = 0;
+
+        // We need (limit - 1) matches to create `limit` parts
+        while ((match = globalDelimiter.exec(remainingText)) !== null && matchCount < limit - 1) {
+            // Add the part before the match
+            parts.push(remainingText.substring(lastIndex, match.index));
+            // Add the matched delimiter part itself if it's non-empty (important for zero-width matches)
+            // This part is tricky; typically, the delimiter itself is not part of the returned array.
+            // The logic below follows the standard split behavior where the delimiter is not included.
+            lastIndex = match.index + match[0].length;
+            matchCount++;
+            // Avoid infinite loop for zero-length matches
+            if (match.index === globalDelimiter.lastIndex) {
+                globalDelimiter.lastIndex++;
+            }
+        }
+        // Add the final part
+        parts.push(remainingText.substring(lastIndex));
+    } else {
+        // Handle string delimiter
+        const delimLength = delimiter.length;
+        if (delimLength === 0) {
+             // If delimiter is an empty string, split by characters
+             // This is consistent with JS String.split('')
+            return text.split('').slice(0, limit);
+        }
+        let index;
+        while (count < limit - 1 && (index = remainingText.indexOf(delimiter)) !== -1) {
+            parts.push(remainingText.substring(0, index));
+            remainingText = remainingText.substring(index + delimLength);
+            count++;
+        }
+        // Add the final part (the rest of the string)
+        parts.push(remainingText);
+    }
+
+    return parts;
+}
+
+/**
+ * Capitalizes the first character of a string.
+ * 
+ * @param {string} text - The string to capitalize.
+ * @returns {string} The string with its first character capitalized.
+ */
+function capitalize$1(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+/**
+ * Converts a string to title case (capitalizing the first letter of each word).
+ * Words are sequences of characters separated by space, tab, or newline.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in title case.
+ */
+function titleCase$1(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    // Split by one or more whitespace characters
+    return text.split(/\s+/).map(word => capitalize$1(word)).join(' ');
+}
+
+/**
+ * Converts a string to camelCase.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in camelCase.
+ */
+function camelCase$1(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text
+        .split(/\W+/) // Split on non-word characters
+        .map((word, index) => {
+            if (index === 0) {
+                // First word is lowercase
+                return word.toLowerCase();
+            }
+            // Subsequent words have their first letter capitalized
+            return capitalize$1(word.toLowerCase());
+        })
+        .join('');
+}
+
+/**
+ * Converts a string to PascalCase.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in PascalCase.
+ */
+function pascalCase$1(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text
+        .split(/\W+/) // Split on non-word characters
+        .map(word => capitalize$1(word.toLowerCase()))
+        .join('');
+}
+
+/**
+ * Converts a string to kebab-case.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in kebab-case.
+ */
+function kebabCase$1(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text
+        .split(/\W+/) // Split on non-word characters
+        .map(word => word.toLowerCase())
+        .filter(word => word.length > 0) // Remove empty strings from split
+        .join('-');
+}
+
+/**
+ * Converts a string to snake_case.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in snake_case.
+ */
+function snakeCase$1(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text
+        .split(/\W+/) // Split on non-word characters
+        .map(word => word.toLowerCase())
+        .filter(word => word.length > 0) // Remove empty strings from split
+        .join('_');
+}
+
+/**
+ * Converts a string to CONSTANT_CASE.
+ * 
+ * @param {string} text - The string to convert.
+ * @returns {string} The string in CONSTANT_CASE.
+ */
+function constantCase$1(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text
+        .split(/\W+/) // Split on non-word characters
+        .map(word => word.toUpperCase())
+        .filter(word => word.length > 0) // Remove empty strings from split
+        .join('_');
+}
+
+/**
+ * Trims leading and trailing whitespace and normalizes internal whitespace
+ * (replacing sequences of whitespace characters with a single space).
+ * 
+ * @param {string} text - The string to trim and normalize.
+ * @returns {string} The trimmed and normalized string.
+ */
+function trimWhitespace$1(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text.trim().replace(/\s+/g, ' ');
+}
+
+/**
+ * Truncates a string to a specified maximum length and appends a suffix if truncated.
+ * 
+ * @param {string} text - The string to truncate.
+ * @param {number} maxLength - The maximum length of the string.
+ * @param {string} [suffix='...'] - The suffix to append if the string is truncated.
+ * @returns {string} The truncated string with suffix, or the original string if not truncated.
+ */
+function truncate$1(text, maxLength, suffix = '...') {
+    if (!text || typeof text !== 'string' || maxLength <= 0) {
+        return '';
+    }
+    if (text.length <= maxLength) {
+        return text;
+    }
+    // Ensure we don't cut the suffix itself if maxLength is very small
+    const suffixLength = suffix.length;
+    if (maxLength <= suffixLength) {
+         // If max length is less than or equal to suffix, return a truncated suffix
+         // This is a bit of an edge case, but handles it gracefully.
+        return suffix.substring(0, maxLength);
+    }
+    return text.substring(0, maxLength - suffixLength) + suffix;
+}
+
+/**
+ * Escapes HTML characters in a string to prevent them from being interpreted as HTML.
+ * 
+ * @param {string} text - The string to escape.
+ * @returns {string} The escaped string.
+ */
+function escapeHtml(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    const htmlEscapes = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#39;',
+    };
+    return text.replace(/[&<>"']/g, match => htmlEscapes[match]);
+}
+
+/**
+ * Removes HTML tags from a string.
+ * 
+ * @param {string} text - The string to strip tags from.
+ * @returns {string} The string without HTML tags.
+ */
+function stripHtml(text) {
+    if (!text || typeof text !== 'string') {
+        return text;
+    }
+    return text.replace(/<[^>]*>/g, '');
+}
+
+/**
+ * Performs a basic check to see if a string looks like a valid email address.
+ * This is a simple validation and should not be used for robust security checks.
+ * 
+ * @param {string} email - The email string to validate.
+ * @returns {boolean} True if the string looks like a valid email, false otherwise.
+ */
+function isValidEmail(email) {
+    if (!email || typeof email !== 'string') {
+        return false;
+    }
+    // A basic regex for email validation. Note: Fully validating email addresses
+    // is extremely complex. This covers common cases.
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}
+
+
+var stringUtils = {
+    splitWithLimit: splitWithLimit$1,
+    capitalize: capitalize$1,
+    titleCase: titleCase$1,
+    camelCase: camelCase$1,
+    kebabCase: kebabCase$1,
+    snakeCase: snakeCase$1,
+    constantCase: constantCase$1,
+    pascalCase: pascalCase$1,
+    trimWhitespace: trimWhitespace$1,
+    truncate: truncate$1,
+    escapeHtml,
+    stripHtml,
+    isValidEmail,
+};
+
+/*
+ * Component: Language Name Utils 
+ * Block-UUID: 313abeab-2bb3-49d1-8693-e9e88aa97113
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Utility for converting common lowercase language names and aliases to their proper capitalization
+ * Language: JavaScript
+ * Created-at: 2025-10-19T23:25:09.231Z
+ * Authors: Qwen 3 Coder 480B - Cerebras (v1.0.0)
+ */
+
+/**
+ * A mapping of language aliases to their properly capitalized names
+ */
+const LANGUAGE_NAME_MAP = {
+  // Core Programming Languages
+  'javascript': 'JavaScript',
+  'js': 'JavaScript',
+  'typescript': 'TypeScript',
+  'ts': 'TypeScript',
+  'python': 'Python',
+  'py': 'Python',
+  'java': 'Java',
+  'c': 'C',
+  'c++': 'C++',
   'cpp': 'C++',
   'c#': 'C#',
   'csharp': 'C#',
@@ -24253,19 +25421,670 @@ var LanguageNameUtils$1 = {
   getLanguageNameMap
 };
 
+/**
+ * Component: MetaRawResultUtils
+ * Block-UUID: 8a4d235b-a9d3-44b8-9c08-47b3678ba1c0
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Utility for parsing and extracting mappings from meta-raw-result messages
+ * Language: JavaScript
+ * Created-at: 2025-11-15T19:15:00.000Z
+ * Authors: GLM-4.6 (v1.0.0)
+ */
+
+const ChatUtils$1 = ChatUtils$2;
+
+/**
+ * Extracts and parses all meta-raw-result messages from a chat
+ * @param {Object} chat - The chat object containing messages
+ * @param {string} model - The model name (optional, for message filtering)
+ * @returns {Map<number, Object>} Map of chatId to file metadata
+ */
+function extractMetaRawResultMappings$1(chat, model = null) {
+    const mappings = new Map();
+    
+    try {
+        // Get all messages from the chat
+        const allMessages = ChatUtils$1.getChatMessages(chat, model);
+        
+        // Filter for meta-raw-result messages
+        const metaRawMessages = allMessages.filter(msg => isMetaRawResultMessage$1(msg));
+
+        // Parse each meta-raw-result message
+        for (const message of metaRawMessages) {
+            const messageMappings = parseMetaRawResultContent$1(message.message);
+            
+            // Merge mappings into the main map
+            for (const [chatId, fileInfo] of messageMappings) {
+                mappings.set(chatId, fileInfo);
+            }
+        }
+        
+        return mappings;
+    } catch (error) {
+        console.error('Error extracting meta-raw-result mappings:', error);
+        return mappings;
+    }
+}
+
+/**
+ * Validates if a message is a meta-raw-result message
+ * @param {Object} message - The message object to validate
+ * @returns {boolean} True if message is meta-raw-result type
+ */
+function isMetaRawResultMessage$1(message) {
+    if (!message || !message.message) {
+        return false;
+    }
+    
+    // Check if message type is meta-raw-result
+    if (message.type === 'meta-raw-result') {
+        return true;
+    }
+    
+    return false;
+}
+
+/**
+ * Parses a single meta-raw-result message content
+ * @param {string} messageContent - The message content to parse
+ * @returns {Map<number, Object>} Map of chatId to file metadata
+ */
+function parseMetaRawResultContent$1(messageContent) {
+    const mappings = new Map();
+    
+    try {
+        // Split content into lines
+        const lines = messageContent.split('\n');
+        
+        // Find the data section
+        let dataSectionStart = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].trimStart().startsWith('## Data ')) {
+                dataSectionStart = i;
+                break;
+            }
+        }
+
+        if (dataSectionStart === -1) {
+            return mappings; // No data section found
+        }
+        
+        // Find the table header (line with |)
+        let headerLine = -1;
+        for (let i = dataSectionStart; i < lines.length; i++) {
+            if (lines[i].includes('|') && lines[i].includes('Chat ID')) {
+                headerLine = i;
+                break;
+            }
+        }
+        
+        if (headerLine === -1) {
+            return mappings; // No table header found
+        }
+        
+        // Find the separator line (|---|---|...)
+        let separatorLine = -1;
+        for (let i = headerLine + 1; i < lines.length; i++) {
+            if (lines[i].match(/^\|[\s\-\|]*\|$/)) {
+                separatorLine = i;
+                break;
+            }
+        }
+        
+        if (separatorLine === -1) {
+            return mappings; // No separator found
+        }
+       
+        // Parse data rows (everything after the separator)
+        for (let i = separatorLine + 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+
+            // Skip empty lines or separator lines
+            if (!line || line.match(/^\|[\s\-\|]*\|$/) || !line.includes('|')) {
+                continue;
+            }
+            
+            // Parse the table row
+            const fileInfo = parseTableRow$1(line);
+            if (fileInfo && fileInfo.id) {
+                mappings.set(fileInfo.id, fileInfo);
+            }
+        }
+        
+        return mappings;
+    } catch (error) {
+        console.error('Error parsing meta-raw-result content:', error);
+        return mappings;
+    }
+}
+
+/**
+ * Parses a single table row from meta-raw-result content
+ * @param {string} rowLine - The table row line to parse
+ * @returns {Object|null} Parsed file information object or null if parsing failed
+ */
+function parseTableRow$1(rowLine) {
+    try {
+        // Split the row by | and clean up
+        const cells = rowLine.split('|').map(cell => cell.trim()).filter(cell => cell);
+        
+        if (cells.length < 6) {
+            return null; // Not enough columns
+        }
+        
+        // Extract basic information from the table cells
+        const repo = cells[0];
+        const branch = cells[1];
+        const filePath = cells[2];
+        const language = cells[3];
+        const chatId = parseInt(cells[4], 10);
+        
+        // Parse file path to extract name and path
+        const pathParts = filePath.split('/');
+        const name = pathParts[pathParts.length - 1];
+        const path = filePath;
+        
+        // Create full path
+        const fullPath = `${repo}/${path}`;
+        
+        return {
+            id: chatId,
+            name: name,
+            path: path,
+            repo: repo,
+            branch: branch,
+            language: language,
+            fullPath: fullPath
+        };
+    } catch (error) {
+        console.error('Error parsing table row:', error);
+        return null;
+    }
+}
+
+/**
+ * Parses size string to bytes
+ * @param {string} sizeStr - Size string (e.g., "1.2 KB", "500 B")
+ * @returns {number} Size in bytes
+ */
+function parseSize$1(sizeStr) {
+    if (!sizeStr || sizeStr === 'N/A') {
+        return 0;
+    }
+    
+    const match = sizeStr.match(/^([\d.]+)\s*(B|KB|MB|GB)?$/i);
+    if (!match) {
+        return 0;
+    }
+    
+    const value = parseFloat(match[1]);
+    const unit = (match[2] || 'B').toUpperCase();
+    
+    switch (unit) {
+        case 'B': return Math.round(value);
+        case 'KB': return Math.round(value * 1024);
+        case 'MB': return Math.round(value * 1024 * 1024);
+        case 'GB': return Math.round(value * 1024 * 1024 * 1024);
+        default: return 0;
+    }
+}
+
+/**
+ * Parses tokens string to number
+ * @param {string} tokensStr - Tokens string (e.g., "1.2k", "500")
+ * @returns {number} Token count
+ */
+function parseTokens$1(tokensStr) {
+    if (!tokensStr || tokensStr === 'N/A') {
+        return 0;
+    }
+    
+    const match = tokensStr.match(/^([\d.]+)(k|m|b)?$/i);
+    if (!match) {
+        return 0;
+    }
+    
+    const value = parseFloat(match[1]);
+    const suffix = (match[2] || '').toLowerCase();
+    
+    switch (suffix) {
+        case 'k': return Math.round(value * 1000);
+        case 'm': return Math.round(value * 1000000);
+        case 'b': return Math.round(value * 1000000000);
+        default: return Math.round(value);
+    }
+}
+
+var MetaRawResultUtils$1 = {
+    extractMetaRawResultMappings: extractMetaRawResultMappings$1,
+    isMetaRawResultMessage: isMetaRawResultMessage$1,
+    parseMetaRawResultContent: parseMetaRawResultContent$1,
+    parseTableRow: parseTableRow$1,
+    parseSize: parseSize$1,
+    parseTokens: parseTokens$1
+};
+
+/**
+ * Component: ReferenceMessageUtils
+ * Block-UUID: 2870551a-4311-4d64-9491-c9cc62f276e8
+ * Parent-UUID: N/A
+ * Description: Utility for parsing reference messages in the compact message workflow, extracting session data, metadata, and message sections.
+ * Language: JavaScript
+ * Created-at: 2025-12-07T00:08:42.573Z
+ * Authors: GLM-4.6 (v1.0.0)
+ */
+
+let ReferenceMessageUtils$1 = class ReferenceMessageUtils {
+    /**
+     * Extracts all data from a reference message including session data, metadata, and message sections
+     * @param {string} referenceMessage - The reference message content to parse
+     * @returns {Object} Parsed data with messages to compact and keep, metadata, and session information
+     */
+    static extractReferenceMessageData(referenceMessage) {
+        if (!referenceMessage) {
+            return {
+                messagesToCompact: [],
+                messagesToKeep: [],
+                originalChatUuid: null,
+                validationHash: null,
+                sessionId: null,
+                range: null,
+                from: null,
+                to: null
+            };
+        }
+
+        // Extract Original Chat UUID
+        const originalChatUuidMatch = referenceMessage.match(/Original Chat UUID:\s*([a-f0-9-]+)/i);
+        const originalChatUuid = originalChatUuidMatch ? originalChatUuidMatch[1] : null;
+
+        // Extract Validation Hash
+        const validationHashMatch = referenceMessage.match(/Validation Hash:\s*([a-f0-9]+)/i);
+        const validationHash = validationHashMatch ? validationHashMatch[1] : null;
+
+        // Extract Session ID
+        const sessionIdMatch = referenceMessage.match(/Session ID:\s*(\d+)/i);
+        const sessionId = sessionIdMatch ? sessionIdMatch[1] : null;
+
+        // Extract Range
+        const rangeMatch = referenceMessage.match(/Range:\s*(\d+-\d+)/i);
+        const range = rangeMatch ? rangeMatch[1] : null;
+
+        // Extract From and To values
+        const fromMatch = referenceMessage.match(/From:\s*(\d+)/i);
+        const from = fromMatch ? parseInt(fromMatch[1], 10) : null;
+
+        const toMatch = referenceMessage.match(/To:\s*(\d+)/i);
+        const to = toMatch ? parseInt(toMatch[1], 10) : null;
+
+        // If range is not found but from and to are available, construct the range
+        if (!range && from !== null && to !== null) {
+            range = `${from}-${to}`;
+        }
+
+        // Extract Messages to Compact section
+        const compactSectionMatch = referenceMessage.match(/# Messages to Compact\n([\s\S]*?)(?=\n# |\n$|$)/);
+        const compactSection = compactSectionMatch ? compactSectionMatch[1] : '';
+
+        // Extract Messages to Keep section
+        const keepSectionMatch = referenceMessage.match(/# Messages to Keep \(Context\)\n([\s\S]*?)(?=\n# |\n$|$)/);
+        const keepSection = keepSectionMatch ? keepSectionMatch[1] : '';
+
+        // Parse messages from each section
+        const messagesToCompact = this.parseMessageSection(compactSection);
+        const messagesToKeep = this.parseMessageSection(keepSection);
+
+        return {
+            messagesToCompact,
+            messagesToKeep,
+            originalChatUuid,
+            validationHash,
+            sessionId,
+            range,
+            from,
+            to
+        };
+    }
+
+    /**
+     * Parses a message section to extract individual messages
+     * @param {string} section - The section content to parse
+     * @returns {Array} Array of parsed message objects
+     */
+    static parseMessageSection(section) {
+        if (!section) return [];
+
+        const messages = [];
+        const messageRegex = /<(\w+) message number (\d+)>\n([\s\S]*?)\n<\/\1 message number \2>/g;
+        let match;
+
+        while ((match = messageRegex.exec(section)) !== null) {
+            const [, role, positionStr, content] = match;
+            const position = parseInt(positionStr, 10);
+
+            messages.push({
+                role,
+                position,
+                content: content.trim()
+            });
+        }
+
+        return messages;
+    }
+
+    /**
+     * Extracts just the metadata from a reference message without the message sections
+     * @param {string} referenceMessage - The reference message content to parse
+     * @returns {Object} Metadata object with original chat UUID, validation hash, session ID, and range information
+     */
+    static extractReferenceMessageMetadata(referenceMessage) {
+        const data = this.extractReferenceMessageData(referenceMessage);
+
+        return {
+            originalChatUuid: data.originalChatUuid,
+            validationHash: data.validationHash,
+            sessionId: data.sessionId,
+            range: data.range,
+            from: data.from,
+            to: data.to
+        };
+    }
+
+    /**
+     * Checks if a message is a reference message
+     * @param {string} message - The message content to check
+     * @returns {boolean} True if the message is a reference message
+     */
+    static isReferenceMessage(message) {
+        if (!message) return false;
+
+        // Check for key indicators of a reference message
+        return message.includes('# Compact Messages Reference') &&
+            message.includes('Original Chat UUID:') &&
+            message.includes('Session ID:');
+    }
+};
+
+var ReferenceMessageUtils_1 = { ReferenceMessageUtils: ReferenceMessageUtils$1 };
+
+/**
+ * Component: CompactedMessageUtils
+ * Block-UUID: b4111118-ec11-49d6-9a6e-402ca0b6df5b
+ * Parent-UUID: N/A
+ * Version: 1.0.1
+ * Description: Utility for formatting, parsing, and validating compacted messages with standardized metadata headers.
+ * Language: JavaScript
+ * Created-at: 2025-12-07T00:09:15.842Z
+ * Authors: GLM-4.6 (v1.0.0), GLM-4.6 (v1.0.1)
+ */
+
+let CompactedMessageUtils$1 = class CompactedMessageUtils {
+    /**
+     * Formats a compacted message with standardized metadata headers
+     * @param {string} content - The compacted message content
+     * @param {string} originalChatUuid - UUID of the original chat
+     * @param {string} messageRange - Message range that was compacted (e.g., "3-6")
+     * @param {Object} options - Additional options
+     * @param {Date} options.compactedAt - Custom timestamp for when the message was compacted
+     * @returns {string} Formatted compacted message with metadata
+     */
+    static formatCompactedMessage(content, originalChatUuid, messageRange, options = {}) {
+        if (!content) {
+            throw new Error('Content is required for formatting a compacted message');
+        }
+
+        if (!originalChatUuid) {
+            throw new Error('Original chat UUID is required for formatting a compacted message');
+        }
+
+        if (!messageRange) {
+            throw new Error('Message range is required for formatting a compacted message');
+        }
+
+        // Use provided timestamp or generate current one
+        const compactedAt = options.compactedAt || new Date().toISOString();
+
+        return `## Compacted Message
+
+- **Original Chat:** [${originalChatUuid}](/?chat=${originalChatUuid})
+- **Message Range:** ${messageRange}
+- **Compacted At:** ${compactedAt}
+
+${content}`;
+    }
+
+    /**
+     * Extracts metadata from a compacted message
+     * @param {string} compactedMessage - The compacted message to parse
+     * @returns {Object|null} Metadata object or null if format is invalid
+     */
+    static extractCompactedMessageMetadata(compactedMessage) {
+        if (!this.isCompactedMessage(compactedMessage)) {
+            return null;
+        }
+
+        // Extract Original Chat UUID
+        const originalChatMatch = compactedMessage.match(/\*\*Original Chat:\*\*\s*([a-f0-9-]+)/i);
+        const originalChatUuid = originalChatMatch ? originalChatMatch[1] : null;
+
+        // Extract Message Range
+        const rangeMatch = compactedMessage.match(/\*\*Message Range:\*\*\s*(\d+-\d+)/i);
+        const messageRange = rangeMatch ? rangeMatch[1] : null;
+
+        // Extract Compacted At timestamp
+        const compactedAtMatch = compactedMessage.match(/\*\*Compacted At:\*\*\s*([0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}Z)/i);
+        const compactedAt = compactedAtMatch ? compactedAtMatch[1] : null;
+
+        return {
+            originalChatUuid,
+            messageRange,
+            compactedAt
+        };
+    }
+
+    /**
+     * Extracts just the content portion from a compacted message (without metadata)
+     * @param {string} compactedMessage - The compacted message to parse
+     * @returns {string|null} Content portion or null if format is invalid
+     */
+    static extractCompactedMessageContent(compactedMessage) {
+        if (!this.isCompactedMessage(compactedMessage)) {
+            return null;
+        }
+
+        // Find the start and end boundaries
+        const startMarker = "## Compacted Message";
+        const endMarker = "## End Compacted Message";
+        
+        const startIndex = compactedMessage.indexOf(startMarker);
+        const endIndex = compactedMessage.indexOf(endMarker);
+        
+        // If start marker is not found, return null
+        if (startIndex === -1) {
+            return null;
+        }
+        
+        // If end marker is not found, extract everything after start marker
+        if (endIndex === -1) {
+            return compactedMessage.substring(startIndex + startMarker.length).trim();
+        }
+        
+        // Extract content between the markers
+        const contentStart = startIndex + startMarker.length;
+        return compactedMessage.substring(contentStart, endIndex).trim();
+    }
+
+    /**
+     * Validates that a compacted message follows the expected format
+     * @param {string} compactedMessage - The compacted message to validate
+     * @returns {Object} Validation result with isValid flag and any errors/warnings
+     */
+    static validateCompactedMessageFormat(compactedMessage) {
+        const result = {
+            isValid: true,
+            errors: [],
+            warnings: []
+        };
+
+        if (!compactedMessage) {
+            result.isValid = false;
+            result.errors.push('Compacted message is empty or null');
+            return result;
+        }
+
+        // Check for required header
+        if (!compactedMessage.includes('## Compacted Message')) {
+            result.isValid = false;
+            result.errors.push('Missing required "## Compacted Message" header');
+        }
+
+        // Check for required metadata fields
+        const metadata = this.extractCompactedMessageMetadata(compactedMessage);
+
+        if (!metadata) {
+            result.isValid = false;
+            result.errors.push('Could not extract metadata from compacted message');
+            return result;
+        }
+
+        if (!metadata.originalChatUuid) {
+            result.isValid = false;
+            result.errors.push('Missing or invalid Original Chat UUID');
+        }
+
+        if (!metadata.messageRange) {
+            result.isValid = false;
+            result.errors.push('Missing or invalid Message Range');
+        }
+
+        if (!metadata.compactedAt) {
+            result.warnings.push('Missing or invalid Compacted At timestamp');
+        }
+
+        // Validate UUID format
+        if (metadata.originalChatUuid && !this.isValidUUID(metadata.originalChatUuid)) {
+            result.isValid = false;
+            result.errors.push('Original Chat UUID is not in valid UUID format');
+        }
+
+        // Validate message range format
+        if (metadata.messageRange && !this.isValidMessageRange(metadata.messageRange)) {
+            result.isValid = false;
+            result.errors.push('Message Range is not in valid format (expected "X-Y")');
+        }
+
+        // Validate timestamp format
+        if (metadata.compactedAt && !this.isValidISOTimestamp(metadata.compactedAt)) {
+            result.warnings.push('Compacted At timestamp is not in valid ISO 8601 format');
+        }
+
+        return result;
+    }
+
+    /**
+     * Checks if a message is a compacted message
+     * @param {string} message - The message content to check
+     * @returns {boolean} True if the message is a compacted message
+     */
+    static isCompactedMessage(message) {
+        if (!message) return false;
+
+        // Check for the compacted message header
+        return message.includes('## Compacted Message');
+    }
+
+    /**
+     * Validates if a string is a valid UUID v4
+     * @param {string} uuid - The UUID string to validate
+     * @returns {boolean} True if valid UUID v4
+     */
+    static isValidUUID(uuid) {
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        return uuidRegex.test(uuid);
+    }
+
+    /**
+     * Validates if a string is a valid message range (e.g., "3-6")
+     * @param {string} range - The range string to validate
+     * @returns {boolean} True if valid range format
+     */
+    static isValidMessageRange(range) {
+        const rangeRegex = /^\d+-\d+$/;
+        if (!rangeRegex.test(range)) return false;
+
+        const [from, to] = range.split('-').map(Number);
+        return !isNaN(from) && !isNaN(to) && from <= to;
+    }
+
+    /**
+     * Validates if a string is a valid ISO 8601 timestamp
+     * @param {string} timestamp - The timestamp string to validate
+     * @returns {boolean} True if valid ISO 8601 timestamp
+     */
+    static isValidISOTimestamp(timestamp) {
+        if (!timestamp) return false;
+
+        const date = new Date(timestamp);
+        return !isNaN(date.getTime()) && timestamp === date.toISOString();
+    }
+};
+
+var CompactedMessageUtils_1 = { CompactedMessageUtils: CompactedMessageUtils$1 };
+
+/**
+ * Component: CompactChatUtils Index
+ * Block-UUID: cd0a6091-edb6-4e92-9439-63dd8f6a6796
+ * Parent-UUID: 5ffa0338-b4fb-4968-908c-f23a26d4923b
+ * Version: 2.0.0
+ * Description: Entry point for CompactChatUtils that exports both ReferenceMessageUtils and CompactedMessageUtils methods directly for easier access.
+ * Language: JavaScript
+ * Created-at: 2025-12-07T00:10:05.123Z
+ * Authors: GLM-4.6 (v1.0.0), GLM-4.6 (v2.0.0)
+ */
+
+const { ReferenceMessageUtils } = ReferenceMessageUtils_1;
+const { CompactedMessageUtils } = CompactedMessageUtils_1;
+
+/**
+ * CompactChatUtils provides utilities for working with compacted messages in GitSense Chat.
+ * It includes functionality for parsing reference messages and formatting/parsing compacted messages.
+ */
+var CompactChatUtils$1 = {
+    // Export the classes for those who want to access them directly
+    ReferenceMessageUtils,
+    CompactedMessageUtils,
+    
+    // Export all methods from ReferenceMessageUtils directly
+    extractReferenceMessageData: ReferenceMessageUtils.extractReferenceMessageData,
+    parseMessageSection: ReferenceMessageUtils.parseMessageSection,
+    extractReferenceMessageMetadata: ReferenceMessageUtils.extractReferenceMessageMetadata,
+    isReferenceMessage: ReferenceMessageUtils.isReferenceMessage,
+    
+    // Export all methods from CompactedMessageUtils directly
+    formatCompactedMessage: CompactedMessageUtils.formatCompactedMessage,
+    extractCompactedMessageMetadata: CompactedMessageUtils.extractCompactedMessageMetadata,
+    extractCompactedMessageContent: CompactedMessageUtils.extractCompactedMessageContent,
+    validateCompactedMessageFormat: CompactedMessageUtils.validateCompactedMessageFormat,
+    isCompactedMessage: CompactedMessageUtils.isCompactedMessage,
+    isValidUUID: CompactedMessageUtils.isValidUUID,
+    isValidMessageRange: CompactedMessageUtils.isValidMessageRange,
+    isValidISOTimestamp: CompactedMessageUtils.isValidISOTimestamp
+};
+
 /*
  * Component: GitSenseChatUtils
- * Block-UUID: 1793b3a8-4881-4306-bfdf-673eef503679
- * Parent-UUID: eaeabebb-04b6-4881-9b29-88798c7f21b6
- * Version: 2.4.0
- * Description: Interface class for GitSense Chat utilities providing a unified API for code block parsing (markdown), extraction, and patch operations. Integrates functionalities from CodeBlockUtils and PatchUtils modules, and now includes ConfigUtils, EnvUtils, and ObjectUtils.
+ * Block-UUID: c1b6c4d3-7959-4eb6-8022-6cd7aa59240d
+ * Parent-UUID: 1793b3a8-4881-4306-bfdf-673eef503679
+ * Version: 2.7.0
+ * Description: Interface class for GitSense Chat utilities providing a unified API for code block parsing (markdown), extraction, and patch operations. Integrates functionalities from CodeBlockUtils and PatchUtils modules, and now includes ConfigUtils, EnvUtils, ObjectUtils, MetaRawResultUtils, and CompactChatUtils.
  * Language: JavaScript
  * Created-at: 2025-10-17T17:13:04.663Z
- * Authors: Claude 3.7 Sonnet (v1.0.0), Gemini 2.5 Pro (v2.0.0), Gemini 2.5 Pro (v2.1.0), Gemini 2.5 Pro (v2.1.1), Gemini 2.5 Flash (v2.1.2), Gemini 2.5 Flash (v2.1.3), Gemini 2.5 Flash (v2.1.4), Qwen 3 Coder 480B - Cerebras (v2.1.5), Qwen 3 Coder 480B - Cerebras (v2.2.0), Qwen 3 Coder 480B - Cerebras (v2.2.1), Claude Haiku 4.5 (v2.3.0), Qwen 3 Coder 480B - Cerebras (v2.4.0)
+ * Authors: Claude 3.7 Sonnet (v1.0.0), Gemini 2.5 Pro (v2.0.0), Gemini 2.5 Pro (v2.1.0), Gemini 2.5 Pro (v2.1.1), Gemini 2.5 Flash (v2.1.2), Gemini 2.5 Flash (v2.1.3), Gemini 2.5 Flash (v2.1.4), Qwen 3 Coder 480B - Cerebras (v2.1.5), Qwen 3 Coder 480B - Cerebras (v2.2.0), Qwen 3 Coder 480B - Cerebras (v2.2.1), Claude Haiku 4.5 (v2.3.0), Qwen 3 Coder 480B - Cerebras (v2.4.0), Qwen 3 Coder 480B - Cerebras (v2.5.0), GLM-4.6 (v2.6.0), GLM-4.6 (v2.7.0)
  */
 
-const ChatUtils = ChatUtils$1;
-const CodeBlockUtils = CodeBlockUtils$5;
+const ChatUtils = ChatUtils$2;
+const CodeBlockUtils = CodeBlockUtils$7;
 const ContextUtils = ContextUtils$2;
 const MessageUtils = MessageUtils$3;
 const AnalysisBlockUtils = AnalysisBlockUtils$3;
@@ -24282,7 +26101,10 @@ const EnvUtils = EnvUtils$1;
 const DomUtils = DomUtils$1;
 const ObjectUtils = ObjectUtils$1;
 const SVGUtils = SVGUtils_1;
+const StringUtils = stringUtils;
 const LanguageNameUtils = LanguageNameUtils$1;
+const MetaRawResultUtils = MetaRawResultUtils$1;
+const CompactChatUtils = CompactChatUtils$1;
 
 const {
     normalizeLanguageName,
@@ -24368,6 +26190,7 @@ const {
     removeCodeBlockMarkers,
     updateCodeBlockByIndex,
     deleteCodeBlockByIndex,
+    getLineage,
 } = CodeBlockUtils;
 
 const {
@@ -24413,6 +26236,7 @@ const {
     parseContextSection,
     extractContextSections,
     extractContextItemsOverviewTableRows,
+    getContextFiles,
     formatContextContent,
 } = ContextUtils;
 
@@ -24420,6 +26244,28 @@ const {
     trimObjectStrings
 } = ObjectUtils;
 
+const {
+    splitWithLimit,
+    capitalize,
+    titleCase,
+    camelCase,
+    kebabCase,
+    snakeCase,
+    constantCase,
+    pascalCase,
+    trimWhitespace,
+    truncate,
+} = StringUtils;
+
+const {
+    extractMetaRawResultMappings,
+    isMetaRawResultMessage,
+    parseMetaRawResultContent,
+    parseTableRow,
+    parseSize,
+    parseTokens
+} = MetaRawResultUtils;
+
 
 /**
  * GitSenseChatUtils class provides a unified interface to code block and patch utilities.
@@ -24660,7 +26506,12 @@ var GitSenseChatUtils_1 = {
     EnvUtils,
     DomUtils,
     ObjectUtils,
+    StringUtils,
     SVGUtils,
+    MetaRawResultUtils,
+    CompactChatUtils,
+    ReferenceMessageUtils: CompactChatUtils.ReferenceMessageUtils,
+    CompactedMessageUtils: CompactChatUtils.CompactedMessageUtils,
 
     // --- Individual Function Exports (sourced correctly) ---
 
@@ -24753,6 +26604,18 @@ var GitSenseChatUtils_1 = {
     // Object Utils
     trimObjectStrings,
 
+    // String Utils
+    splitWithLimit,
+    capitalize,
+    titleCase,
+    camelCase,
+    kebabCase,
+    snakeCase,
+    constantCase,
+    pascalCase,
+    trimWhitespace,
+    truncate,
+
     // Markdown Utils
     createMarkdownRenderer,
     removeSignature,
@@ -24772,10 +26635,19 @@ var GitSenseChatUtils_1 = {
     getApiKey,
 
     // Context Utils
+    getContextFiles,
     parseContextSection,
     extractContextSections,
     extractContextItemsOverviewTableRows,
     formatContextContent,
+
+    // MetaRawResult Utils
+    extractMetaRawResultMappings,
+    isMetaRawResultMessage,
+    parseMetaRawResultContent,
+    parseTableRow,
+    parseSize,
+    parseTokens,
 };
 
 var GitSenseChatUtils$1 = /*@__PURE__*/getDefaultExportFromCjs(GitSenseChatUtils_1);