@gitsense/gsc-utils 0.2.4 → 0.2.6

package/dist/gsc-utils.esm.js

@@ -16,8 +16,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$2 = require$$0;
-const path = require$$1;
+const fs$6 = require$$0;
+const path$4 = require$$1;
 const ANALYZE_MESSAGE_REGEXP = /^# Analyze - `([^`]+)`\n/;
 
 /**
@@ -51,12 +51,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$2.readdirSync(messagesDir);
+        const files = fs$6.readdirSync(messagesDir);
 
         // Sort files numerically (1.md, 2.md, etc.)
         const sortedFiles = files.sort((a, b) => {
@@ -67,9 +67,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$2.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');
@@ -10397,7 +10397,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,
 
@@ -10464,7 +10464,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;
 
 /**
@@ -10521,7 +10521,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) {
@@ -10654,7 +10654,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) {
@@ -10681,7 +10681,7 @@ function buildChatIdToPathMap$1(allMessages) {
 }
 
 var contextMapper = {
-    buildChatIdToPathMap: buildChatIdToPathMap$1
+    buildChatIdToPathMap: buildChatIdToPathMap$2
 };
 
 /*
@@ -10712,7 +10712,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;
@@ -10727,9 +10727,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 = [];
@@ -10828,7 +10828,7 @@ function processLLMAnalysisResponse$1(messageContent, stoppedStreaming) {
 }
 
 var responseProcessor = {
-    processLLMAnalysisResponse: processLLMAnalysisResponse$1
+    processLLMAnalysisResponse: processLLMAnalysisResponse$2
 };
 
 /*
@@ -10855,7 +10855,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
 
@@ -10909,28 +10909,540 @@ 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: Analyzer Saver Utility
+ * Block-UUID: a373f4ba-89ce-465f-8624-24258c923e61
+ * Parent-UUID: N/A
+ * Version: 1.1.0
+ * Description: Utility function to save or update an analyzer configuration based on its ID and content.
+ * Language: JavaScript
+ * Created-at: 2025-07-12T04:12:33.454Z
+ * Authors: Gemini 2.5 Flash Thinking (v1.0.0), Gemini 2.5 Flash Thinking (v1.1.0)
+ */
+
+require$$0.promises;
+
+
+var saver = {
+    };
+
+/*
+ * 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 { saveConfiguration } = saver;
+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,
+    saveConfiguration,
 };
 
 /**
@@ -11141,15 +11653,15 @@ var EnvUtils$1 = {
  * Component: GitSenseChatUtils
  * Block-UUID: 5e8d1a9c-0b3f-4e1a-8c7d-9f0b2e1d3a4b
  * Parent-UUID: 7a9b1c8e-f1a4-4b2d-9e8f-6f7a0b1c2d3f
- * Version: 2.1.2
+ * 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), Gemini 2.5 Flash (v2.1.2)
+ * 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;
@@ -11193,6 +11705,17 @@ const {
     validateOverviewMetadata,
 } = AnalysisBlockUtils;
 
+const {
+    buildChatIdToPathMap,
+    processLLMAnalysisResponse,
+    validateLLMAnalysisData,
+    getAnalyzers,
+    getAnalyzerSchema,
+    deleteAnalyzer,
+    getAnalyzerInstructionsContent,
+    saveAnalyzerConfiguration,
+} = AnalyzerUtils;
+
 const {
     COMMENT_STYLES,
     generateUUID,
@@ -11518,9 +12041,13 @@ var GitSenseChatUtils_1 = {
     validateOverviewMetadata,
 
     // Analyzer Utilities
-    buildChatIdToPathMap: AnalyzerUtils.buildChatIdToPathMap,
-    processLLMAnalysisResponse: AnalyzerUtils.processLLMAnalysisResponse,
-    validateLLMAnalysisData: AnalyzerUtils.validateLLMAnalysisData,
+    buildChatIdToPathMap,
+    processLLMAnalysisResponse,
+    validateLLMAnalysisData,
+    getAnalyzers,
+    getAnalyzerSchema,
+    deleteAnalyzer,
+    getAnalyzerInstructionsContent,
 
     // ChatUtils
     getChatMessages,