@gitsense/gsc-utils 0.2.24 → 0.2.27

package/src/AnalyzerUtils/schemaLoader.js

@@ -1,18 +1,93 @@
-/*
+/**
  * 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)
+ */
+
+
+/**
+ * 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 = require('fs').promises;
 const path = require('path');
 const CodeBlockUtils = require('../CodeBlockUtils');
+const { preprocessJsonForValidation } = require('./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.
@@ -25,6 +100,15 @@ const CodeBlockUtils = require('../CodeBlockUtils');
  */
 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;
@@ -36,35 +120,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;
 }
@@ -75,14 +159,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(analyzeMessagesBasePath, analyzerId) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        console.error('Error: analyzeMessagesBasePath is required.');
+async function getAnalyzerSchema(analyzersBasePath, analyzerId) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        console.error('Error: analyzersBasePath is required.');
         return null;
     }
     if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
@@ -97,10 +181,13 @@ async function getAnalyzerSchema(analyzeMessagesBasePath, analyzerId) {
     }
     const [analyzerName, contentType, instructionsType] = parts;
 
-    const instructionsFilePath = path.join(analyzeMessagesBasePath, analyzerName, contentType, instructionsType, '1.md');
+    const instructionsFilePath = path.join(analyzersBasePath, analyzerName, contentType, instructionsType, '1.md');
 
     try {
         const fileContent = await fs.readFile(instructionsFilePath, 'utf8');
+        // New: Parse the structured definitions block first
+        const definedFields = parseMetadataDefinitions(fileContent);
+
         const { blocks } = CodeBlockUtils.extractCodeBlocks(fileContent, { silent: true });
         const jsonBlocks = blocks.filter(block => block.type === 'code' && block.language === 'json');
 
@@ -109,19 +196,24 @@ async function getAnalyzerSchema(analyzeMessagesBasePath, analyzerId) {
         }
 
         const jsonBlockContent = jsonBlocks[0].content;
+        const preprocessedContent = preprocessJsonForValidation(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;
@@ -129,9 +221,20 @@ async function getAnalyzerSchema(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,
@@ -145,7 +248,6 @@ async function getAnalyzerSchema(analyzeMessagesBasePath, analyzerId) {
         }
 
         return schema;
-
     } catch (error) {
         if (error.code === 'ENOENT') {
             console.warn(`Analyzer instructions file not found: ${instructionsFilePath}`);
@@ -157,7 +259,73 @@ async function getAnalyzerSchema(analyzeMessagesBasePath, analyzerId) {
     }
 }
 
+/**
+ * Retrieves the configuration metadata for a specific analyzer.
+ * Reads the corresponding '1.md' file and extracts the top-level properties
+ * from the JSON block (description, version, tags).
+ *
+ * @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').
+ * @returns {Promise<object|null>} A promise that resolves with an object containing the analyzer's configuration metadata (description, version, tags) or null if not found/invalid.
+ */
+async function getAnalyzerConfigMetadata(analyzersBasePath, analyzerId) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        console.error('Error: analyzersBasePath is required.');
+        return null;
+    }
+    if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
+        console.error('Error: analyzerId is required.');
+        return null;
+    }
+
+    const parts = analyzerId.split('::');
+    if (parts.length !== 3) {
+        console.error(`Error: Invalid analyzerId format. Expected 'analyzer_name::content_type::instructions_type', but got '${analyzerId}'.`);
+        return null;
+    }
+    const [analyzerName, contentType, instructionsType] = parts;
+
+    const instructionsFilePath = path.join(analyzersBasePath, analyzerName, contentType, instructionsType, '1.md');
+
+    try {
+        const fileContent = await fs.readFile(instructionsFilePath, 'utf8');
+        const { blocks } = CodeBlockUtils.extractCodeBlocks(fileContent, { silent: true });
+        const jsonBlocks = blocks.filter(block => block.type === 'code' && block.language === 'json');
+
+        if (jsonBlocks.length !== 1) {
+            throw new Error(`Expected exactly one JSON code block in ${instructionsFilePath}, but found ${jsonBlocks.length}.`);
+        }
+
+        const jsonBlockContent = jsonBlocks[0].content;
+        const preprocessedContent = preprocessJsonForValidation(jsonBlockContent);
+        let rawJson = null;
+        try {
+            rawJson = JSON.parse(preprocessedContent);
+        } catch (parseError) {
+            console.error(`Error parsing JSON content from ${instructionsFilePath}: ${parseError.message}`);
+            return null;
+        }
+
+        // Extract configuration metadata
+        return {
+            description: rawJson.description || null,
+            version: rawJson.version || null,
+            tags: rawJson.tags ? rawJson.tags.split(/\s*,\s*/) :  []
+        };
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            console.warn(`Analyzer instructions file not found: ${instructionsFilePath}`);
+        } else {
+            console.error(`Error retrieving configuration metadata for analyzer ${analyzerId}: ${error.message}`);
+        }
+        return null;
+    }
+}
+
 module.exports = {
     getAnalyzerSchema,
-    deduceSchemaType
+    getAnalyzerConfigMetadata,
+    deduceSchemaType,
+    parseMetadataDefinitions,
+    mapSimpleTypeToSchema
 };

package/src/AnalyzerUtils/updater.js

@@ -0,0 +1,187 @@
+/*
+ * Component: AnalyzerUtils Updater
+ * Block-UUID: 8a7b6c5d-4e3f-2a1b-9c8d-7e6f5a4b3c2d
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions for updating analyzer configurations, including renaming and metadata updates.
+ * Language: JavaScript
+ * Created-at: 2025-12-25T19:55:00.000Z
+ * Authors: GLM-4.6 (v1.0.0)
+ */
+
+
+const fs = require('fs').promises;
+const path = require('path');
+const CodeBlockUtils = require('../CodeBlockUtils');
+const { preprocessJsonForValidation } = require('./jsonParser');
+const { isValidDirName } = require('./discovery');
+const { readConfig } = require('./discovery');
+
+/**
+ * Updates an analyzer configuration, including renaming the analyzer if needed.
+ *
+ * @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.
+ */
+async function updateAnalyzer(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(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.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.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(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.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.readFile(configPath, 'utf8');
+                await fs.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.readFile(contentConfigPath, 'utf8');
+                await fs.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.readFile(instructionsConfigPath, 'utf8');
+                await fs.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.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.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 } = require('./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 
+    };
+}
+
+module.exports = {
+    updateAnalyzer
+};

package/src/CodeBlockUtils/blockProcessor.js

@@ -2,17 +2,17 @@
  * 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, matchFencesAndExtractBlocks } = require('./blockExtractor');
 const { parseHeader } = require('./headerUtils');
-const { validateUUID, generateUUID } = require('./uuidUtils');
+const { validateUUID } = require('./uuidUtils');
 const AnalysisBlockUtils = require('../AnalysisBlockUtils');
 const PatchUtils = require('../PatchUtils');
 const GSToolBlockUtils = require('../GSToolBlockUtils');
@@ -131,7 +131,7 @@ function processBlockContent(content, language, position, incomplete, options =
     if (PatchUtils.isPatchBlock(content)) {
         const patchFormat = PatchUtils.determinePatchFormat(content);
         const metadata = PatchUtils.extractPatchMetadata(content); // Extract metadata regardless of validation
-        const patchContent = PatchUtils.extractPatchContent(content); // Extract raw patch content
+        const patchContent = PatchUtils.extractPatchContent(content, patchFormat); // Extract raw patch content
 
         let patchValidationResult = { valid: true, errors: [], patches: null }; // Default valid state
 
@@ -148,36 +148,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.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,
@@ -371,8 +351,10 @@ function processBlockContents(text, completeBlocks, incompleteBlocks, options) {
  * @returns {Object} { blocks: Array, warnings: Array, hasIncompleteBlocks: boolean, lastIncompleteBlock: Object|null }
  */
 function processCodeBlocks(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.' }],

package/src/CodeBlockUtils/constants.js

@@ -2,11 +2,11 @@
  * Component: CodeBlockUtils Constants
  * Block-UUID: 01b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d
  * Parent-UUID: 144d19a5-139a-4e80-8abe-84965583e35e
- * Version: 1.0.1
+ * Version: 1.0.2
  * Description: Defines constants used across the CodeBlockUtils modules, such as comment styles for various languages.
  * Language: JavaScript
  * Created-at: 2025-04-15T15:51:16.973Z
- * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Flash Thinking (v1.0.1)
+ * Authors: Gemini 2.5 Pro (v1.0.0), Gemini 2.5 Flash Thinking (v1.0.1), Qwen 3 Coder 480B - Cerebras (v1.0.2)
  */
 
 
@@ -40,6 +40,12 @@ const COMMENT_STYLES = {
     'r': { type: 'hash' },
     'julia': { type: 'hash' },
 
+    // HTML/XML/SVG/Markdown comment style
+    'html': { type: 'html' },
+    'xml': { type: 'html' },
+    'svg': { type: 'html' },
+    'markdown': { type: 'html' }, // For metadata in Markdown files
+
     // Other language styles
     'lisp': { type: 'semicolon' },
     'clojure': { type: 'semicolon' },
@@ -58,5 +64,3 @@ const COMMENT_STYLES = {
 module.exports = {
     COMMENT_STYLES
 };
-
-