@gitsense/gsc-utils 0.2.3 → 0.2.5

package/dist/gsc-utils.cjs.js

@@ -18,8 +18,8 @@ function getDefaultExportFromCjs (x) {
  * 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 = require$$0;
-const path = require$$1;
+const fs$6 = require$$0;
+const path$4 = require$$1;
 const ANALYZE_MESSAGE_REGEXP = /^# Analyze - `([^`]+)`\n/;
 
 /**
@@ -53,12 +53,12 @@ function unescapeCodeBlocks(content) {
  * @returns {Array} An array of message objects with role and content properties
  */
 function getChatTemplateMessages$1(dirname, messageType) {
-    const messagesDir = path.join(dirname, messageType);
+    const messagesDir = path$4.join(dirname, messageType);
     const messages = [];
 
     try {
         // Read all files in the directory
-        const files = fs.readdirSync(messagesDir);
+        const files = fs$6.readdirSync(messagesDir);
 
         // Sort files numerically (1.md, 2.md, etc.)
         const sortedFiles = files.sort((a, b) => {
@@ -69,9 +69,9 @@ function getChatTemplateMessages$1(dirname, messageType) {
 
         // Process each file
         for (const file of sortedFiles) {
-            if (path.extname(file) === '.md') {
-                const filePath = path.join(messagesDir, file);
-                const fileContent = fs.readFileSync(filePath, 'utf8');
+            if (path$4.extname(file) === '.md') {
+                const filePath = path$4.join(messagesDir, file);
+                const fileContent = fs$6.readFileSync(filePath, 'utf8');
 
                 // Split by triple newline to separate metadata from content
                 const parts = fileContent.split('\n\n\n');
@@ -8790,7 +8790,7 @@ var GSToolBlockUtils$3 = {
     formatToolBlock
 };
 
-/**
+/*
  * Component: CodeBlockUtils Continuation Utilities
  * Block-UUID: 6fdf5c7d-4def-42a1-bc88-0312f6002cfc
  * Parent-UUID: 6322afcd-2e5e-425a-9a43-4c72c887f668
@@ -8956,8 +8956,8 @@ Example of the START of your response:
 \`\`\`${language}
 /**
  * Component: ${componentName}
-* Block-UUID: 01147ddf-320f-498a-a744-198d42a9d2ee
-* Parent-UUID: e4c0d839-ea17-467d-a0cc-d269d1dbc404
+ * Block-UUID: 01147ddf-320f-498a-a744-198d42a9d2ee
+ * Parent-UUID: e4c0d839-ea17-467d-a0cc-d269d1dbc404
  * Version: ${nextVersion}
  * Description: ${description}
  * Language: ${language}
@@ -10399,7 +10399,7 @@ const { updateCodeBlockByIndex: updateCodeBlockByIndex$1, updateCodeBlockByUUID,
 const { formatWithLineNumbers: formatWithLineNumbers$1, formatBlockWithLineNumbers: formatBlockWithLineNumbers$1, formatBlocksWithLineNumbers: formatBlocksWithLineNumbers$1, removeLineNumbers: removeLineNumbers$1 } = lineNumberFormatter;
 
 // Export all imported items
-var CodeBlockUtils$3 = {
+var CodeBlockUtils$4 = {
     // Constants
     COMMENT_STYLES: COMMENT_STYLES$1,
 
@@ -10466,7 +10466,7 @@ var CodeBlockUtils$3 = {
  * Authors: Gemini 2.5 Flash Thinking (v1.0.0)
  */
 
-const CodeBlockUtils$2 = CodeBlockUtils$3;
+const CodeBlockUtils$3 = CodeBlockUtils$4;
 const MessageUtils$2 = MessageUtils$3;
 
 /**
@@ -10523,7 +10523,7 @@ function parseContextSection(sectionText) {
         }
     });
 
-    const { blocks, warnings } = CodeBlockUtils$2.extractCodeBlocks(sectionText, { silent: true });
+    const { blocks, warnings } = CodeBlockUtils$3.extractCodeBlocks(sectionText, { silent: true });
     const codeBlocks = blocks.filter(block => block.type === 'code');
 
     if (codeBlocks.length === 0) {
@@ -10656,7 +10656,7 @@ const ContextUtils$1  = ContextUtils$2;
  * @param {Array<Object>} allMessages - An array of all message objects in the chat.
  * @returns {Map<number, string>} A Map where keys are chat IDs (numbers) and values are file paths (strings).
  */
-function buildChatIdToPathMap$1(allMessages) {
+function buildChatIdToPathMap$2(allMessages) {
     const chatIdToPathMap = new Map();
 
     for (const msg of allMessages) {
@@ -10683,7 +10683,7 @@ function buildChatIdToPathMap$1(allMessages) {
 }
 
 var contextMapper = {
-    buildChatIdToPathMap: buildChatIdToPathMap$1
+    buildChatIdToPathMap: buildChatIdToPathMap$2
 };
 
 /*
@@ -10714,7 +10714,7 @@ var constants = {
  * Authors: Gemini 2.5 Flash (v1.0.0)
  */
 
-const CodeBlockUtils$1 = CodeBlockUtils$3;
+const CodeBlockUtils$2 = CodeBlockUtils$4;
 const GSToolBlockUtils$1 = GSToolBlockUtils$3;
 const JsonUtils$1 = JsonUtils$2;
 const { ANALYZE_HEADER_PREFIX } = constants;
@@ -10729,9 +10729,9 @@ const { ANALYZE_HEADER_PREFIX } = constants;
  * @returns {{analysisBlocks: Array<Object>, analysisMetadataBlocks: Array<Object|null>, error: string|null}}
  *          An object containing the extracted blocks and any processing error.
  */
-function processLLMAnalysisResponse$1(messageContent, stoppedStreaming) {
+function processLLMAnalysisResponse$2(messageContent, stoppedStreaming) {
     const silent = { silent: true };
-    const { blocks, warnings } = CodeBlockUtils$1.extractCodeBlocks(messageContent, silent);
+    const { blocks, warnings } = CodeBlockUtils$2.extractCodeBlocks(messageContent, silent);
 
     const analysisBlocks = [];
     const analysisMetadataBlocks = [];
@@ -10830,7 +10830,7 @@ function processLLMAnalysisResponse$1(messageContent, stoppedStreaming) {
 }
 
 var responseProcessor = {
-    processLLMAnalysisResponse: processLLMAnalysisResponse$1
+    processLLMAnalysisResponse: processLLMAnalysisResponse$2
 };
 
 /*
@@ -10857,7 +10857,7 @@ const AnalysisBlockUtils$1 = AnalysisBlockUtils$3;
  * @returns {{validAnalysisData: Array<Object>, invalidAnalysisBlocks: Array<string|Object>}}
  *          An object containing arrays of valid analysis data and invalid analysis blocks.
  */
-function validateLLMAnalysisData$1(analysisBlocks, analysisMetadataBlocks, chatIdToPathMap) {
+function validateLLMAnalysisData$2(analysisBlocks, analysisMetadataBlocks, chatIdToPathMap) {
     const validAnalysisData = []; // Store data for the "Save All" button
     const invalidAnalysisBlocks = []; // Store invalid analysis blocks
 
@@ -10911,28 +10911,521 @@ function validateLLMAnalysisData$1(analysisBlocks, analysisMetadataBlocks, chatI
 }
 
 var dataValidator = {
-    validateLLMAnalysisData: validateLLMAnalysisData$1
+    validateLLMAnalysisData: validateLLMAnalysisData$2
+};
+
+/*
+ * Component: AnalyzerUtils Discovery
+ * Block-UUID: 0b1c2d3e-4f5a-6b7c-8d9e-0f1a2b3c4d5f
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions for discovering available analyzers.
+ * Language: JavaScript
+ * Created-at: 2025-08-28T23:48:00.000Z
+ * Authors: Gemini 2.5 Flash (v1.0.0)
+ */
+
+const fs$5 = require$$0.promises;
+const path$3 = require$$1;
+
+/**
+ * Reads and parses the config.json file in a directory.
+ * @param {string} dirPath - The path to the directory.
+ * @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$3.join(dirPath, 'config.json');
+    try {
+        const fileContent = await fs$5.readFile(configPath, 'utf8');
+        return JSON.parse(fileContent);
+    } catch (error) {
+        if (error.code !== 'ENOENT') {
+            // Log a warning if config.json exists but is malformed
+            console.warn(`Warning: Failed to parse config.json in ${dirPath}: ${error.message}`);
+        }
+        return null; // Return null if file not found or parsing failed
+    }
+}
+
+/**
+ * Checks if a directory name is valid based on the rules in messages/analyze/README.md.
+ * 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) {
+    // Exclude names starting with underscore or containing dots
+    if (name.startsWith('_') || name.includes('.')) {
+        return false;
+    }
+    // Check for allowed characters
+    return /^[a-zA-Z0-9_-]+$/.test(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').
+ * @returns {Promise<Array<{id: string, label: string}>>} A promise that resolves to an array of analyzer objects.
+ */
+async function getAnalyzers$2(analyzeMessagesBasePath) {
+    const analyzers = [];
+
+    try {
+        const analyzerEntries = await fs$5.readdir(analyzeMessagesBasePath, { withFileTypes: true });
+
+        for (const analyzerEntry of analyzerEntries) {
+            if (analyzerEntry.isDirectory() && isValidDirName(analyzerEntry.name)) {
+                const analyzerName = analyzerEntry.name;
+                const analyzerPath = path$3.join(analyzeMessagesBasePath, analyzerName);
+                const analyzerConfig = await readConfig$1(analyzerPath);
+                const analyzerLabel = analyzerConfig?.label || analyzerName;
+
+                const contentEntries = await fs$5.readdir(analyzerPath, { withFileTypes: true });
+
+                for (const contentEntry of contentEntries) {
+                    if (contentEntry.isDirectory() && isValidDirName(contentEntry.name)) {
+                        const contentType = contentEntry.name;
+                        const contentPath = path$3.join(analyzerPath, contentType);
+                        const contentConfig = await readConfig$1(contentPath);
+                        const contentLabel = contentConfig?.label || contentType;
+
+                        const instructionsEntries = await fs$5.readdir(contentPath, { withFileTypes: true });
+
+                        for (const instructionsEntry of instructionsEntries) {
+                            if (instructionsEntry.isDirectory() && isValidDirName(instructionsEntry.name)) {
+                                const instructionsType = instructionsEntry.name;
+                                const instructionsPath = path$3.join(contentPath, instructionsType);
+                                const instructionsConfig = await readConfig$1(instructionsPath);
+                                const instructionsLabel = instructionsConfig?.label || instructionsType;
+
+                                // Check for the existence of 1.md to confirm a valid analyzer configuration
+                                const instructionsFilePath = path$3.join(instructionsPath, '1.md');
+                                try {
+                                    await fs$5.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$5.stat(instructionsFilePath);
+                                        const lastModified = stats.mtime.getTime(); // Get timestamp in milliseconds
+                                        const sixtyMinutesAgo = Date.now() - (60 * 60 * 1000); // Current time - 60 minutes in ms
+
+                                        if (lastModified < sixtyMinutesAgo) {
+                                            // This tutorial analyzer has expired, skip it.
+                                            continue;
+                                        }
+                                    }
+                                    // Construct the analyzer ID and label
+                                    const analyzerId = `${analyzerName}::${contentType}::${instructionsType}`;
+                                    const analyzerFullLabel = `${analyzerLabel} (${contentLabel} - ${instructionsLabel})`;
+
+                                    analyzers.push({
+                                        id: analyzerId,
+                                        label: analyzerFullLabel,
+                                        protected: analyzerConfig?.protected || false
+                                    });
+                                } catch (error) {
+                                    // If 1.md doesn't exist, this is not a complete analyzer configuration, skip.
+                                    if (error.code !== 'ENOENT') {
+                                        console.warn(`Warning: Error accessing 1.md for ${analyzerId}: ${error.message}`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    } catch (error) {
+        console.error(`Error traversing analyze messages directory ${analyzeMessagesBasePath}: ${error.message}`);
+        // Depending on requirements, you might want to throw the error or return an empty array
+        throw error; // Re-throw to indicate failure
+    }
+
+    return analyzers;
+}
+
+var discovery = {
+    getAnalyzers: getAnalyzers$2,
+    readConfig: readConfig$1};
+
+/*
+ * Component: AnalyzerUtils Schema Loader
+ * Block-UUID: 0c1d2e3f-4a5b-6c7d-8e9f-0a1b2c3d4e5f
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * 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)
+ */
+
+const fs$4 = require$$0.promises;
+const path$2 = require$$1;
+const CodeBlockUtils$1 = CodeBlockUtils$4;
+
+/**
+ * Deduces the JSON schema type and format/items from a string value pattern.
+ * Handles patterns like "[string: ...]", "[number: ...]", "[datetime: ...]", "[<string>: ...]",
+ * and boolean instructions. Defaults to 'string' for unknown patterns.
+ *
+ * @param {any} value - The value from the raw JSON (expected to be a string pattern).
+ * @param {string} fieldName - The name of the field (for logging warnings).
+ * @returns {{type: string, format?: string, items?: object}} An object describing the schema type and format/items.
+ */
+function deduceSchemaType(value, fieldName) {
+    const defaultSchema = { type: 'string' }; // Default fallback
+
+    if (typeof value !== 'string') {
+        const jsType = typeof value;
+        if (jsType === 'object' && value !== null) {
+            console.warn(`Warning: Unexpected non-string, non-null object/array value for field "${fieldName}". Defaulting to type 'string'. Value:`, value);
+            return defaultSchema;
+        }
+        return { type: jsType };
+    }
+
+    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;
+}
+
+
+/**
+ * Retrieves the JSON schema for a specific analyzer.
+ * 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} 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.');
+        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$2.join(analyzeMessagesBasePath, analyzerName, contentType, instructionsType, '1.md');
+
+    try {
+        const fileContent = await fs$4.readFile(instructionsFilePath, 'utf8');
+        const { blocks } = CodeBlockUtils$1.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;
+        let rawJson = null;
+        try {
+            rawJson = JSON.parse(jsonBlockContent);
+        } catch (parseError) {
+            console.error(`Error parsing JSON content from ${instructionsFilePath}: ${parseError.message}`);
+            return null;
+        }
+
+        const schema = {
+            type: 'object',
+            description: rawJson.description,
+            properties: {},
+            required: []
+        };
+
+        const metadataProperties = rawJson?.extracted_metadata;
+
+        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] || '';
+
+                    schema.properties[fieldName] = {
+                        ...fieldSchema,
+                        description,
+                        title: fieldName.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase())
+                    };
+                }
+            }
+        } else {
+            console.warn(`Warning: Could not find 'extracted_metadata' object in JSON block from ${instructionsFilePath}. Schema will be empty.`);
+        }
+
+        return schema;
+
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            console.warn(`Analyzer instructions file not found: ${instructionsFilePath}`);
+            return null;
+        } else {
+            console.error(`Error retrieving or processing schema for analyzer ${analyzerId}: ${error.message}`);
+            throw error;
+        }
+    }
+}
+
+var schemaLoader = {
+    getAnalyzerSchema: getAnalyzerSchema$2};
+
+/*
+ * Component: AnalyzerUtils Management
+ * Block-UUID: 0d1e2f3a-4b5c-6d7e-8f9a-0b1c2d3e4f5a
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions for managing (deleting) analyzer configurations.
+ * Language: JavaScript
+ * Created-at: 2025-08-28T23:48:00.000Z
+ * 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
+
+/**
+ * Checks if a directory is empty or only contains a config.json.
+ * @param {string} dirPath - The path to the directory.
+ * @returns {Promise<boolean>} True if the directory is empty or only contains config.json, false otherwise.
+ */
+async function isDirectoryEmpty(dirPath) {
+    try {
+        const files = await fs$3.readdir(dirPath);
+        return files.length === 0 || (files.length === 1 && files[0] === 'config.json');
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            return true; // Directory doesn't exist, so it's "empty" for our purpose
+        }
+        throw error; // Re-throw other errors
+    }
+}
+
+/**
+ * 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} 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.' };
+    }
+    if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
+        return { success: false, message: 'analyzerId is required.' };
+    }
+
+    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;
+
+    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');
+
+    try {
+        // 1. Check for protection at all levels
+        const analyzerConfig = await readConfig(analyzerDir);
+        if (analyzerConfig?.protected) {
+            return { success: false, message: `Analyzer '${analyzerName}' is protected and cannot be deleted.` };
+        }
+
+        const contentConfig = await readConfig(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);
+        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);
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                return { success: false, message: `Analyzer instructions file not found: ${instructionsFilePath}. It may have already been deleted.` };
+            }
+            throw error; // Re-throw other errors
+        }
+
+        // 3. Intelligently delete empty directories, cascading upwards
+        let deletedDirs = [];
+
+        // Check and delete instructions directory
+        if (await isDirectoryEmpty(instructionsDir)) {
+            try {
+                await fs$3.rmdir(instructionsDir);
+                deletedDirs.push(instructionsDir);
+            } catch (error) {
+                console.warn(`Warning: Could not remove empty instructions directory ${instructionsDir}: ${error.message}`);
+            }
+        }
+
+        // Check and delete content directory
+        if (await isDirectoryEmpty(contentDir)) {
+            try {
+                await fs$3.rmdir(contentDir);
+                deletedDirs.push(contentDir);
+            } catch (error) {
+                console.warn(`Warning: Could not remove empty content directory ${contentDir}: ${error.message}`);
+            }
+        }
+
+        // Check and delete analyzer directory
+        if (await isDirectoryEmpty(analyzerDir)) {
+            try {
+                await fs$3.rmdir(analyzerDir);
+                deletedDirs.push(analyzerDir);
+            } catch (error) {
+                console.warn(`Warning: Could not remove empty analyzer directory ${analyzerDir}: ${error.message}`);
+            }
+        }
+
+        return { success: true, message: `Analyzer '${analyzerId}' deleted successfully. Cleaned up directories: ${deletedDirs.join(', ') || 'None'}.` };
+
+    } catch (error) {
+        console.error(`Error deleting analyzer '${analyzerId}': ${error.message}`);
+        return { success: false, message: `Failed to delete analyzer: ${error.message}` };
+    }
+}
+
+var management = {
+    deleteAnalyzer: deleteAnalyzer$2};
+
+/*
+ * Component: AnalyzerUtils Instruction Loader
+ * Block-UUID: 0a1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5e
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions for loading raw analyzer instruction content.
+ * Language: JavaScript
+ * Created-at: 2025-08-28T23:48:00.000Z
+ * Authors: Gemini 2.5 Flash (v1.0.0)
+ */
+
+const fs$2 = require$$0.promises;
+const path = 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} 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$2(analyzeMessagesBasePath, analyzerId) {
+    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
+        console.error('Error: analyzeMessagesBasePath 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(analyzeMessagesBasePath, analyzerName, contentType, instructionsType, '1.md');
+
+    try {
+        const fileContent = await fs$2.readFile(instructionsFilePath, 'utf8');
+        return fileContent;
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            console.warn(`Analyzer instructions file not found: ${instructionsFilePath}`);
+            return null;
+        } else {
+            console.error(`Error reading analyzer instructions file ${instructionsFilePath}: ${error.message}`);
+            throw error;
+        }
+    }
+}
+
+var instructionLoader = {
+    getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$2
 };
 
 /*
  * Component: AnalyzerUtils Index
  * Block-UUID: b403b6a1-230b-4247-8cd6-2a3d068f4bbf
  * Parent-UUID: N/A
- * Version: 1.0.0
+ * Version: 1.1.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)
+ * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Flash (v1.1.0)
  */
 
-const { buildChatIdToPathMap } = contextMapper;
-const { processLLMAnalysisResponse } = responseProcessor;
-const { validateLLMAnalysisData } = dataValidator;
+const { buildChatIdToPathMap: buildChatIdToPathMap$1 } = contextMapper;
+const { processLLMAnalysisResponse: processLLMAnalysisResponse$1 } = responseProcessor;
+const { validateLLMAnalysisData: validateLLMAnalysisData$1 } = dataValidator;
+const { getAnalyzers: getAnalyzers$1 } = discovery;
+const { getAnalyzerSchema: getAnalyzerSchema$1 } = schemaLoader;
+const { deleteAnalyzer: deleteAnalyzer$1 } = management;
+const { getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$1 } = instructionLoader;
 
 var AnalyzerUtils$1 = {
-    buildChatIdToPathMap,
-    processLLMAnalysisResponse,
-    validateLLMAnalysisData
+    buildChatIdToPathMap: buildChatIdToPathMap$1,
+    processLLMAnalysisResponse: processLLMAnalysisResponse$1,
+    validateLLMAnalysisData: validateLLMAnalysisData$1,
+    getAnalyzers: getAnalyzers$1,
+    getAnalyzerSchema: getAnalyzerSchema$1,
+    deleteAnalyzer: deleteAnalyzer$1,
+    getAnalyzerInstructionsContent: getAnalyzerInstructionsContent$1,
 };
 
 /**
@@ -10966,34 +11459,209 @@ var LLMUtils$1 = {
     estimateTokens: estimateTokens$1,
 };
 
+/*
+ * Component: Config Utilities
+ * Block-UUID: 89016e46-9898-42f0-bef4-564e442cfaf3
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions for loading and accessing application configuration from data/chats.json.
+ * Language: JavaScript
+ * Created-at: 2025-08-28T17:46:26.948Z
+ * Authors: Gemini 2.5 Flash (v1.0.0)
+ */
+
+const fs$1 = require$$0.promises;
+
+/**
+ * Loads and parses the application configuration from the specified JSON file.
+ *
+ * @param {string} filePath - The absolute path to the data/chats.json file.
+ * @returns {Promise<Object>} A promise that resolves with the parsed configuration object.
+ * @throws {Error} If the file cannot be read or parsed.
+ */
+async function loadConfig$1(filePath) {
+    try {
+        const fileContent = await fs$1.readFile(filePath, 'utf8');
+        return JSON.parse(fileContent);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Configuration file not found at: ${filePath}`);
+        }
+        throw new Error(`Failed to load or parse configuration from ${filePath}: ${error.message}`);
+    }
+}
+
 /**
+ * Retrieves the configuration details for a specific LLM provider.
+ *
+ * @param {Object} config - The loaded configuration object.
+ * @param {string} providerName - The name of the LLM provider (e.g., "Google", "Anthropic").
+ * @returns {Object|null} The provider's configuration object or null if not found.
+ */
+function getProviderConfig$1(config, providerName) {
+    if (!config || !config.providers || !Array.isArray(config.providers)) {
+        return null;
+    }
+    return config.providers.find(p => p.name === providerName) || null;
+}
+
+/**
+ * Finds the specific modelId and other details for a given user-friendly modelName and providerName.
+ *
+ * @param {Object} config - The loaded configuration object.
+ * @param {string} modelName - The user-friendly name of the model (e.g., "Gemini 2.5 Flash").
+ * @param {string} providerName - The name of the provider associated with that model.
+ * @returns {Object|null} An object containing modelId, maxOutputTokens, and other provider-specific model details, or null if not found.
+ */
+function getModelProviderDetails$1(config, modelName, providerName) {
+    if (!config || !config.models || !Array.isArray(config.models)) {
+        return null;
+    }
+
+    const modelEntry = config.models.find(m => m.name === modelName);
+    if (!modelEntry || !modelEntry.providers || !Array.isArray(modelEntry.providers)) {
+        return null;
+    }
+
+    return modelEntry.providers.find(p => p.name === providerName) || null;
+}
+
+/**
+ * Retrieves the environment variable name (e.g., "GEMINI_API_KEY") for the API key of a specific provider.
+ *
+ * @param {Object} config - The loaded configuration object.
+ * @param {string} providerName - The name of the LLM provider.
+ * @returns {string|null} The name of the environment variable that holds the API key, or null if not found.
+ */
+function getApiKeyName$1(config, providerName) {
+    const providerConfig = getProviderConfig$1(config, providerName);
+    return providerConfig ? providerConfig.apiKeyName : null;
+}
+
+var ConfigUtils$1 = {
+    loadConfig: loadConfig$1,
+    getProviderConfig: getProviderConfig$1,
+    getModelProviderDetails: getModelProviderDetails$1,
+    getApiKeyName: getApiKeyName$1
+};
+
+/*
+ * Component: Environment Utilities
+ * Block-UUID: a4f78a41-3054-45f1-a839-778a3bd598f2
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions for loading and accessing environment variables from a .env file.
+ * Language: JavaScript
+ * Created-at: 2025-08-28T17:46:26.948Z
+ * Authors: Gemini 2.5 Flash (v1.0.0)
+ */
+
+const fs = require$$0.promises;
+
+// Simple .env parser, as dotenv is not explicitly a dependency
+// This handles basic KEY=VALUE pairs, ignores comments and empty lines.
+async function parseEnvFile(filePath) {
+    const env = {};
+    try {
+        const fileContent = await fs.readFile(filePath, 'utf8');
+        fileContent.split('\n').forEach(line => {
+            const trimmedLine = line.trim();
+            if (trimmedLine.length === 0 || trimmedLine.startsWith('#')) {
+                return; // Skip empty lines and comments
+            }
+            const parts = trimmedLine.split('=');
+            if (parts.length >= 2) {
+                const key = parts[0].trim();
+                const value = parts.slice(1).join('=').trim(); // Handle values with '='
+                env[key] = value;
+            }
+        });
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            console.warn(`EnvUtils: .env file not found at ${filePath}. Proceeding without loading.`);
+        } else {
+            throw new Error(`EnvUtils: Failed to read or parse .env file at ${filePath}: ${error.message}`);
+        }
+    }
+    return env;
+}
+
+/**
+ * Loads environment variables from the specified .env file path into process.env.
+ * This function will only load the .env file once per process.
+ *
+ * @param {string} filePath - The absolute path to the .env file.
+ * @returns {Promise<void>} A promise that resolves when the .env file has been processed.
+ * @throws {Error} If the file exists but cannot be read or parsed.
+ */
+let envLoaded = false;
+async function loadEnv$1(filePath) {
+    if (envLoaded) {
+        return; // Only load once
+    }
+
+    const envVars = await parseEnvFile(filePath);
+    for (const key in envVars) {
+        if (Object.hasOwnProperty.call(envVars, key)) {
+            // Only set if not already set in process.env (e.g., by system environment)
+            if (process.env[key] === undefined) {
+                process.env[key] = envVars[key];
+            }
+        }
+    }
+    envLoaded = true;
+}
+
+/**
+ * Retrieves the value of a specific API key from process.env.
+ * Assumes loadEnv has been called previously.
+ *
+ * @param {string} keyName - The name of the environment variable holding the API key (e.g., "GEMINI_API_KEY").
+ * @returns {string|null} The API key string, or null if the environment variable is not set.
+ */
+function getApiKey$1(keyName) {
+    if (typeof keyName !== 'string' || keyName.trim() === '') {
+        console.warn('EnvUtils: Attempted to get API key with an invalid keyName.');
+        return null;
+    }
+    return process.env[keyName] || null;
+}
+
+var EnvUtils$1 = {
+    loadEnv: loadEnv$1,
+    getApiKey: getApiKey$1
+};
+
+/*
  * Component: GitSenseChatUtils
  * Block-UUID: 5e8d1a9c-0b3f-4e1a-8c7d-9f0b2e1d3a4b
  * Parent-UUID: 7a9b1c8e-f1a4-4b2d-9e8f-6f7a0b1c2d3f
- * Version: 2.1.1
- * 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.
+ * Version: 2.1.3
+ * 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 and EnvUtils.
  * Language: JavaScript
  * Created-at: 2025-04-15T16:04:26.780Z
- * 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)
+ * 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)
  */
 
 const ChatUtils = ChatUtils$1;
-const CodeBlockUtils = CodeBlockUtils$3;
+const CodeBlockUtils = CodeBlockUtils$4;
 const ContextUtils = ContextUtils$2;
 const MessageUtils = MessageUtils$3;
 const AnalysisBlockUtils = AnalysisBlockUtils$3;
-const AnalyzerUtils = AnalyzerUtils$1;
+const AnalyzerUtils = AnalyzerUtils$1; // Updated import
 const PatchUtils = PatchUtils$2;
 const GSToolBlockUtils = GSToolBlockUtils$3;
 const LLMUtils = LLMUtils$1;
 const JsonUtils = JsonUtils$2;
+const ConfigUtils = ConfigUtils$1;
+const EnvUtils = EnvUtils$1;
 
 const {
     estimateTokens
 } = LLMUtils;
 
-const { 
-    detectJsonComments 
+const {
+    detectJsonComments
 } = JsonUtils;
 
 const {
@@ -11020,6 +11688,16 @@ const {
     validateOverviewMetadata,
 } = AnalysisBlockUtils;
 
+const { // Updated AnalyzerUtils destructuring
+    buildChatIdToPathMap,
+    processLLMAnalysisResponse,
+    validateLLMAnalysisData,
+    getAnalyzers,
+    getAnalyzerSchema,
+    deleteAnalyzer,
+    getAnalyzerInstructionsContent,
+} = AnalyzerUtils;
+
 const {
     COMMENT_STYLES,
     generateUUID,
@@ -11059,11 +11737,24 @@ const {
     verifyAndCorrectLineNumbers,
 } = PatchUtils;
 
-const { 
+const {
     isToolBlock,
     parseToolBlock
 } = GSToolBlockUtils;
 
+const {
+    loadConfig,
+    getProviderConfig,
+    getModelProviderDetails,
+    getApiKeyName
+} = ConfigUtils;
+
+const {
+    loadEnv,
+    getApiKey
+} = EnvUtils;
+
+
 /**
  * GitSenseChatUtils class provides a unified interface to code block and patch utilities.
  * Focuses on markdown code block extraction and processing.
@@ -11208,8 +11899,8 @@ class GitSenseChatUtils {
     extractDiffContent(patchText) {
         // Uses function from PatchUtils (assuming it's named extractPatchContent or similar)
         // If PatchUtils.extractDiffContent exists, use it. Otherwise, use extractPatchContent.
-        return PatchUtils.extractDiffContent 
-            ? PatchUtils.extractDiffContent(patchText) 
+        return PatchUtils.extractDiffContent
+            ? PatchUtils.extractDiffContent(patchText)
             : PatchUtils.extractPatchContent(patchText);
     }
 
@@ -11284,6 +11975,8 @@ var GitSenseChatUtils_1 = {
     ChatUtils,
     GSToolBlockUtils,
     JsonUtils,
+    ConfigUtils,
+    EnvUtils,
 
     // --- Individual Function Exports (sourced correctly) ---
 
@@ -11316,26 +12009,30 @@ var GitSenseChatUtils_1 = {
     formatBlockWithLineNumbers,
     formatBlocksWithLineNumbers,
     removeLineNumbers,
-     
+
     // Other Utilities (from CodeBlockUtils)
     removeCodeBlockMarkers,
     parseCommentDelimitedBlocks,
     updateCodeBlockByIndex,
     deleteCodeBlockByIndex,
 
-    // Analysis Block Utilities 
+    // Analysis Block Utilities
     isOverviewBlock,
     getOverviewType,
     parseOverviewMetadata,
     validateOverviewMetadata,
 
     // Analyzer Utilities
-    buildChatIdToPathMap: AnalyzerUtils.buildChatIdToPathMap,
-    processLLMAnalysisResponse: AnalyzerUtils.processLLMAnalysisResponse,
-    validateLLMAnalysisData: AnalyzerUtils.validateLLMAnalysisData,
+    buildChatIdToPathMap,
+    processLLMAnalysisResponse,
+    validateLLMAnalysisData,
+    getAnalyzers,
+    getAnalyzerSchema,
+    deleteAnalyzer,
+    getAnalyzerInstructionsContent,
 
     // ChatUtils
-    getChatMessages, 
+    getChatMessages,
 
     // Message Utils
     getChatTemplateMessages,
@@ -11355,6 +12052,16 @@ var GitSenseChatUtils_1 = {
     isToolBlock,
     parseToolBlock,
 
+    // Config Utils
+    loadConfig,
+    getProviderConfig,
+    getModelProviderDetails,
+    getApiKeyName,
+
+    // EnvUtils
+    loadEnv,
+    getApiKey,
+
     // Note: Internal helpers like findAllCodeFences, matchFencesAndExtractBlocks are
     // typically not exported directly from the facade but are available via CodeBlockUtils object.
 };