@gitsense/gsc-utils 0.2.24 → 0.2.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitsense/gsc-utils",
-  "version": "0.2.24",
+  "version": "0.2.27",
   "description": "Utilities for GitSense Chat (GSC)",
   "main": "dist/gsc-utils.cjs.js",
   "module": "dist/gsc-utils.esm.js",

package/src/AnalyzerUtils/cloner.js

@@ -0,0 +1,149 @@
+/*
+ * Component: AnalyzerUtils Cloner
+ * Block-UUID: 56b8c9f4-97ce-406c-a598-22a838ebefda
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Provides utility functions for cloning analyzer configurations.
+ * Language: JavaScript
+ * Created-at: 2025-12-26T16:59:39.782Z
+ * Authors: GLM-4.6 (v1.0.0)
+ */
+
+
+const fs = require('fs').promises;
+const path = require('path');
+const CodeBlockUtils = require('../CodeBlockUtils');
+const { preprocessJsonForValidation } = require('./jsonParser');
+const { isValidDirName } = require('./discovery');
+const { saveConfiguration } = require('./saver');
+const { getAnalyzers } = require('./discovery');
+
+/**
+ * Clones an existing analyzer with a new name.
+ *
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers.
+ * @param {string} originalAnalyzerId - The ID of the analyzer to clone (format: 'analyzer_name::content_type::instructions_type').
+ * @param {string} newAnalyzerName - The new name for the cloned analyzer.
+ * @param {object} [options={}] - Optional configuration options.
+ * @param {string} [options.label] - The new label for the cloned analyzer (optional, defaults to newAnalyzerName).
+ * @param {string} [options.description] - The new description for the cloned analyzer (optional, keeps original if not provided).
+ * @returns {Promise<{success: boolean, message: string, newAnalyzerId?: string}>} A promise that resolves with a result object.
+ */
+async function cloneAnalyzer(analyzersBasePath, originalAnalyzerId, newAnalyzerName, options = {}) {
+    // 1. Validate inputs
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        return { success: false, message: 'analyzersBasePath is required.' };
+    }
+    if (typeof originalAnalyzerId !== 'string' || originalAnalyzerId.trim() === '') {
+        return { success: false, message: 'originalAnalyzerId is required.' };
+    }
+    if (typeof newAnalyzerName !== 'string' || newAnalyzerName.trim() === '') {
+        return { success: false, message: 'newAnalyzerName is required.' };
+    }
+
+    // 2. Parse original analyzerId
+    const parts = originalAnalyzerId.split('::');
+    if (parts.length !== 3) {
+        return { success: false, message: `Invalid originalAnalyzerId format. Expected 'analyzer_name::content_type::instructions_type', but got '${originalAnalyzerId}'.` };
+    }
+    const [originalAnalyzerName, contentType, instructionsType] = parts;
+
+    // 3. Validate new analyzer name
+    if (!isValidDirName(newAnalyzerName)) {
+        return { success: false, message: `Invalid analyzer name '${newAnalyzerName}'. Names must be alphanumeric, dash, or underscore, cannot start with underscore, and cannot contain dots.` };
+    }
+
+    // 4. Check if new analyzer name already exists
+    try {
+        const existingAnalyzers = await getAnalyzers(analyzersBasePath);
+        const nameExists = existingAnalyzers.some(analyzer => analyzer.name === newAnalyzerName);
+        if (nameExists) {
+            return { success: false, message: `An analyzer with name '${newAnalyzerName}' already exists. Please choose a different name.` };
+        }
+    } catch (error) {
+        return { success: false, message: `Failed to check for existing analyzers: ${error.message}` };
+    }
+
+    // 5. Get original analyzer's instructions content
+    const { getAnalyzerInstructionsContent } = require('./instructionLoader');
+    let instructionsContent;
+    try {
+        instructionsContent = await getAnalyzerInstructionsContent(analyzersBasePath, originalAnalyzerId);
+        if (!instructionsContent) {
+            return { success: false, message: `Could not find original analyzer '${originalAnalyzerId}'.` };
+        }
+    } catch (error) {
+        return { success: false, message: `Failed to read original analyzer instructions: ${error.message}` };
+    }
+
+    // 6. Extract and update JSON block
+    const { blocks } = CodeBlockUtils.extractCodeBlocks(instructionsContent, { silent: true });
+    const jsonBlocks = blocks.filter((block, index) => {
+        if (block.language === 'json') {
+            block.index = index;
+            return block;
+        }
+    });
+    const jsonBlock = jsonBlocks[jsonBlocks.length - 1];
+    
+    if (!jsonBlock) {
+        return { success: false, message: 'No JSON block found in original analyzer instructions.' };
+    }
+
+    let jsonData;
+    try {
+        const preprocessedContent = preprocessJsonForValidation(jsonBlock.content);
+        jsonData = JSON.parse(preprocessedContent);
+    } catch (error) {
+        return { success: false, message: `Failed to parse JSON block: ${error.message}` };
+    }
+
+    // 7. Update JSON data with new values
+    if (options.label !== undefined) { 
+        jsonData.label = options.label;
+    } 
+    if (options.description !== undefined) {
+        jsonData.description = options.description;
+    }
+    // Reset version for cloned analyzer
+    jsonData.version = '1.0.0';
+
+    // 8. Rebuild the instructions content with updated JSON
+    let updatedInstructionsContent = CodeBlockUtils.updateCodeBlockByIndex(
+        instructionsContent,
+        jsonBlock.index,
+        JSON.stringify(jsonData, null, 2),
+        'json'
+    );
+
+    // 9. Create the new analyzer ID
+    const newAnalyzerId = `${newAnalyzerName}::${contentType}::${instructionsType}`;
+
+    // 10. Update the analyzer id in the instructions
+    updatedInstructionsContent = updatedInstructionsContent.replaceAll(originalAnalyzerId, newAnalyzerId);
+
+    // 11. Save the new analyzer
+    try {
+        const saveResult = await saveConfiguration(
+            analyzersBasePath,
+            newAnalyzerId,
+            updatedInstructionsContent
+        );
+        
+        if (saveResult.success) {
+            return { 
+                success: true, 
+                message: `Analyzer '${originalAnalyzerName}' cloned successfully as '${newAnalyzerName}'.`, 
+                newAnalyzerId 
+            };
+        } else {
+            return { success: false, error: saveResult.message };
+        }
+    } catch (error) {
+        return { success: false, message: `Failed to save cloned analyzer: ${error.message}` };
+    }
+}
+
+module.exports = {
+    cloneAnalyzer
+};

package/src/AnalyzerUtils/constants.js

@@ -1,6 +1,6 @@
 /*
  * Component: AnalyzerUtils Constants
- * Block-UUID: 01b2c3d4-5e6f-4a7b-8c9d-0e1f2a3b4c5d
+ * Block-UUID: fec5dcc4-a1d0-4ef7-8828-3e44a75892c4
  * Parent-UUID: N/A
  * Version: 1.0.0
  * Description: Defines constants specific to the AnalyzerUtils module.

package/src/AnalyzerUtils/defaultPromptLoader.js

@@ -16,16 +16,16 @@ const path = require('path');
 /**
  * Retrieves the raw Markdown content of the shared system message ('_shared/system/1.md').
  *
- * @param {string} analyzeMessagesBasePath - The absolute path to the base directory containing analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers (e.g., 'analyzers/analyzer-1').
  * @returns {Promise<string|null>} A promise that resolves with the full Markdown content, or null if not found/invalid.
  */
-async function getSystemMessageContent(analyzeMessagesBasePath) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        console.error('Error: analyzeMessagesBasePath is required for getSystemMessageContent.');
+async function getSystemMessageContent(analyzersBasePath) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        console.error('Error: analyzersBasePath is required for getSystemMessageContent.');
         return null;
     }
 
-    const systemMessageFilePath = path.join(analyzeMessagesBasePath, '_shared', 'system', '1.md');
+    const systemMessageFilePath = path.join(analyzersBasePath, '_shared', 'system', '1.md');
 
     try {
         const fileContent = await fs.readFile(systemMessageFilePath, 'utf8');
@@ -46,16 +46,16 @@ async function getSystemMessageContent(analyzeMessagesBasePath) {
 /**
  * Retrieves the raw Markdown content of the shared start message ('_shared/start/1.md').
  *
- * @param {string} analyzeMessagesBasePath - The absolute path to the base directory containing analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers (e.g., 'analyzers/analyzer-1').
  * @returns {Promise<string|null>} A promise that resolves with the full Markdown content, or null if not found/invalid.
  */
-async function getStartMessageContent(analyzeMessagesBasePath) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        console.error('Error: analyzeMessagesBasePath is required for getStartMessageContent.');
+async function getStartMessageContent(analyzersBasePath) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        console.error('Error: analyzersBasePath is required for getStartMessageContent.');
         return null;
     }
 
-    const startMessageFilePath = path.join(analyzeMessagesBasePath, '_shared', 'start', '1.md');
+    const startMessageFilePath = path.join(analyzersBasePath, '_shared', 'start', '1.md');
 
     try {
         const fileContent = await fs.readFile(startMessageFilePath, 'utf8');

package/src/AnalyzerUtils/discovery.js

@@ -1,18 +1,19 @@
-/*
+/**
  * Component: AnalyzerUtils Discovery
- * Block-UUID: a87a86c4-69fc-4cbb-80a8-857f56122395
- * Parent-UUID: 0b1c2d3e-4f5a-6b7c-8d9e-0f1a2b3c4d5f
- * Version: 1.1.0
- * Description: Provides utility functions for discovering available analyzers.
+ * Block-UUID: 26a7df9b-ef29-4dcd-aab2-9cdc3a11133c
+ * Parent-UUID: aa999515-84fb-43f6-91a7-cf79248d7286
+ * Version: 1.3.1
+ * Description: Provides utility functions for discovering available analyzers. Updated to include version and tags in analyzer objects.
  * Language: JavaScript
- * Created-at: 2025-08-28T23:48:00.000Z
- * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Flash (v1.1.0)
+ * Created-at: 2025-11-27T14:45:30.978Z
+ * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Flash (v1.1.0), Qwen 3 Coder 480B - Cerebras (v1.2.0), GLM-4.6 (v1.2.1), GLM-4.6 (v1.3.0), GLM-4.6 (v1.3.1)
  */
 
 
 const fs = require('fs').promises;
 const path = require('path');
 const { getAnalyzerInstructionsContent } = require('./instructionLoader');
+const { preprocessJsonForValidation } = require('./jsonParser');
 const CodeBlockUtils = require('../CodeBlockUtils');
 
 /**
@@ -36,7 +37,7 @@ async function readConfig(dirPath) {
 }
 
 /**
- * Checks if a directory name is valid based on the rules in messages/analyze/README.md.
+ * Checks if a directory name is valid
  * Allowed: a-z, A-Z, 0-9, dash (-), underscore (_). Cannot start with underscore or contain dots.
  * @param {string} name - The directory name to check.
  * @returns {boolean} True if the name is valid, false otherwise.
@@ -54,22 +55,21 @@ function isValidDirName(name) {
  * Discovers and lists all available analyzers by traversing the directory structure.
  * An analyzer is considered valid if a '1.md' file exists in the instructions directory.
  *
- * @param {string} analyzeMessagesBasePath - The absolute or relative path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers (e.g., 'analyzers/analyzer-1').
  * @param {object} [options={}] - Optional configuration.
- * @param {boolean} [options.includeDescription=false] - Whether to include the description of the analyzer.
- * @returns {Promise<Array<{id: string, label: string, name: string, protected: boolean, description?: string}>>} A promise that resolves to an array of analyzer objects.
+ * @returns {Promise<Array<{id: string, label: string, name: string, protected: boolean, description?: string, version?: string, tags?: Array<string>}>>} A promise that resolves to an array of analyzer objects.
  */
-async function getAnalyzers(analyzeMessagesBasePath, options = {}) {
-    const { includeDescription = false } = options;
+async function getAnalyzers(analyzersBasePath, options = {}) {
     const analyzers = [];
+    const demoAnalyzerPattern = /^demo-.+-\w{6}$/;
 
     try {
-        const analyzerEntries = await fs.readdir(analyzeMessagesBasePath, { withFileTypes: true });
+        const analyzerEntries = await fs.readdir(analyzersBasePath, { withFileTypes: true });
 
         for (const analyzerEntry of analyzerEntries) {
             if (analyzerEntry.isDirectory() && isValidDirName(analyzerEntry.name)) {
                 const analyzerName = analyzerEntry.name;
-                const analyzerPath = path.join(analyzeMessagesBasePath, analyzerName);
+                const analyzerPath = path.join(analyzersBasePath, analyzerName);
                 const analyzerConfig = await readConfig(analyzerPath);
                 const analyzerLabel = analyzerConfig?.label || analyzerName;
 
@@ -91,13 +91,16 @@ async function getAnalyzers(analyzeMessagesBasePath, options = {}) {
                                 const instructionsConfig = await readConfig(instructionsPath);
                                 const instructionsLabel = instructionsConfig?.label || instructionsType;
 
+                                // Construct the analyzer ID and label
+                                const analyzerId = `${analyzerName}::${contentType}::${instructionsType}`;
+
                                 // Check for the existence of 1.md to confirm a valid analyzer configuration
                                 const instructionsFilePath = path.join(instructionsPath, '1.md');
                                 try {
                                     await fs.access(instructionsFilePath); // Check if file exists and is accessible
 
                                     // If analyzerName starts with 'tutorial-', check its last modified time.
-                                    if (analyzerName.startsWith('tutorial-')) {
+                                    if (analyzerName.startsWith('tutorial-') || demoAnalyzerPattern.test(analyzerName)) {
                                         const stats = await fs.stat(instructionsFilePath);
                                         const lastModified = stats.mtime.getTime(); // Get timestamp in milliseconds
                                         const sixtyMinutesAgo = Date.now() - (60 * 60 * 1000); // Current time - 60 minutes in ms
@@ -107,37 +110,43 @@ async function getAnalyzers(analyzeMessagesBasePath, options = {}) {
                                             continue;
                                         }
                                     }
-                                    // Construct the analyzer ID and label
-                                    const analyzerId = `${analyzerName}::${contentType}::${instructionsType}`;
-                                    const analyzerFullLabel = `${analyzerLabel} (${contentLabel} - ${instructionsLabel})`;
+                                    // TODO: Decide if we should show the contentLabel and instructionsLabel. For now we will ignore them.
+                                    const analyzerFullLabel = `${analyzerLabel}`; // (${contentLabel} - ${instructionsLabel})`;
 
+                                    // Extract description, version, and tags from the JSON block in 1.md
                                     let description = null;
-                                    if (includeDescription) {
-                                        try {
-                                            const content = await getAnalyzerInstructionsContent(analyzeMessagesBasePath, analyzerId);
-                                            const { blocks, warnings } = CodeBlockUtils.extractCodeBlocks(content, { silent: true });
-                                            const jsonBlock = blocks.find(block => block.language === 'json');
-
-                                            if (jsonBlock && jsonBlock.content) {
-                                                try {
-                                                    const json = JSON.parse(jsonBlock.content);
-                                                    description = json.description;
-                                                } catch(error) {
-                                                    console.warn(`${analyzerId} contains an invalid JSON`);
-                                                }
-                                            }
-                                        } catch (descError) {
-                                            console.warn(`Warning: Could not load description for ${analyzerId}: ${descError.message}`);
-                                            descriptionContent = null;
+                                    let version = null;
+                                    let tags = [];
+                                    let label = null;
+                                    let requires_reference_files = null;
+                                    
+                                    try {
+                                        const content = await getAnalyzerInstructionsContent(analyzersBasePath, analyzerId);
+                                        const { blocks, warnings } = CodeBlockUtils.extractCodeBlocks(content, { silent: true });
+                                        const jsonBlock = blocks.find(block => block.language === 'json');
+
+                                        if (jsonBlock && jsonBlock.content) {
+                                            const preprocessedContent = preprocessJsonForValidation(jsonBlock.content);
+                                            const json = JSON.parse(preprocessedContent);
+                                            description = json.description || null;
+                                            label = json.label || null;
+                                            requires_reference_files = json.requires_reference_files || false;
+                                            version = json.version || null;
+                                            tags = Array.isArray(json.tags) ? json.tags : [];
                                         }
+                                    } catch (descError) {
+                                        console.warn(`Warning: Could not load metadata for ${analyzerId}: ${descError.message}`);
                                     }
 
                                     analyzers.push({
                                         id: analyzerId,
-                                        label: analyzerFullLabel,
                                         name: analyzerName,
+                                        description,
+                                        label: label || analyzerFullLabel,
+                                        requires_reference_files,
                                         protected: analyzerConfig?.protected || false,
-                                        description
+                                        version,
+                                        tags
                                      });
                                 } catch (error) {
                                     // If 1.md doesn't exist, this is not a complete analyzer configuration, skip.
@@ -152,7 +161,7 @@ async function getAnalyzers(analyzeMessagesBasePath, options = {}) {
             }
         }
     } catch (error) {
-        console.error(`Error traversing analyze messages directory ${analyzeMessagesBasePath}: ${error.message}`);
+        console.error(`Error traversing analyzers directory ${analyzersBasePath}: ${error.message}`);
         // Depending on requirements, you might want to throw the error or return an empty array
         throw error; // Re-throw to indicate failure
     }

package/src/AnalyzerUtils/index.js

@@ -1,12 +1,12 @@
 /*
  * Component: AnalyzerUtils Index
- * Block-UUID: b403b6a1-230b-4247-8cd6-2a3d068f4bbf
- * Parent-UUID: N/A
- * Version: 1.2.0
- * Description: Aggregates and exports all utility functions from the AnalyzerUtils module.
+ * Block-UUID: 780e17b0-0c1e-4d77-bf6e-302951b341bf
+ * Parent-UUID: b403b6a1-230b-4247-8cd6-2a3d068f4bbf
+ * Version: 1.5.0
+ * Description: Aggregates and exports all utility functions from the AnalyzerUtils module. Added cloneAnalyzer method.
  * Language: JavaScript
  * Created-at: 2025-08-28T15:56:40.319Z
- * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Flash (v1.1.0), Gemini 2.5 Flash (v1.2.0)
+ * Authors: Gemini 2.5 Flash (v1.0.0), Gemini 2.5 Flash (v1.1.0), Gemini 2.5 Flash (v1.2.0), GLM-4.6 (v1.3.0), GLM-4.6 (v1.4.0), GLM-4.6 (v1.5.0)
  */
 
 
@@ -18,7 +18,10 @@ const { saveConfiguration } = require('./saver');
 const { getAnalyzerSchema } = require('./schemaLoader');
 const { deleteAnalyzer } = require('./management');
 const { getAnalyzerInstructionsContent } = require('./instructionLoader');
-const { getSystemMessageContent, getStartMessageContent } = require('./defaultPromptLoader'); // NEW: Import default prompt loaders
+const { getSystemMessageContent, getStartMessageContent } = require('./defaultPromptLoader');
+const { preprocessJsonForValidation } = require('./jsonParser');
+const { updateAnalyzer } = require('./updater');
+const { cloneAnalyzer } = require('./cloner');
 
 module.exports = {
     buildChatIdToPathMap,
@@ -30,5 +33,8 @@ module.exports = {
     getAnalyzerInstructionsContent,
     saveConfiguration,
     getSystemMessageContent,
-    getStartMessageContent
+    getStartMessageContent,
+    preprocessJsonForValidation,
+    updateAnalyzer,
+    cloneAnalyzer
 };

package/src/AnalyzerUtils/instructionLoader.js

@@ -1,6 +1,6 @@
 /*
  * Component: AnalyzerUtils Instruction Loader
- * Block-UUID: 0a1b2c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5e
+ * Block-UUID: 3ecd422e-1dd8-482d-ae3f-90a5eae3ae44
  * Parent-UUID: N/A
  * Version: 1.0.0
  * Description: Provides utility functions for loading raw analyzer instruction content.
@@ -16,13 +16,13 @@ const path = require('path');
 /**
  * Retrieves the raw Markdown content of the analyzer's '1.md' instruction file.
  *
- * @param {string} analyzeMessagesBasePath - The absolute path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
  * @param {string} analyzerId - The unique ID of the analyzer (format: 'analyzer_name::content_type::instructions_type').
  * @returns {Promise<string|null>} A promise that resolves with the full Markdown content of the '1.md' file, or null if not found/invalid.
  */
-async function getAnalyzerInstructionsContent(analyzeMessagesBasePath, analyzerId) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        console.error('Error: analyzeMessagesBasePath is required.');
+async function getAnalyzerInstructionsContent(analyzersBasePath, analyzerId) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        console.error('Error: analyzersBasePath is required.');
         return null;
     }
     if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
@@ -37,7 +37,7 @@ async function getAnalyzerInstructionsContent(analyzeMessagesBasePath, analyzerI
     }
     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');

package/src/AnalyzerUtils/jsonParser.js

@@ -0,0 +1,35 @@
+/*
+ * Component: AnalyzerUtils JSON Parser
+ * Block-UUID: 4dd21efd-3ad3-43e1-adf0-d52d7c560970
+ * Version: 1.0.0
+ * Description: Provides utility functions for pre-processing JSON content from analyzer instructions.
+ * Language: JavaScript
+ * Created-at: 2025-11-23T05:38:15.725Z
+ * Authors: GLM-4.6 (v1.0.0)
+ */
+
+
+/**
+ * Pre-processes JSON content to quote unquoted template strings before parsing.
+ * This handles cases where {{SYSTEM: ...}} and {{ANALYZER: ...}} placeholders
+ * are not properly quoted in the JSON.
+ *
+ * @param {string} jsonString - The raw JSON string content.
+ * @returns {string} The processed JSON string with template strings quoted.
+ */
+function preprocessJsonForValidation(jsonString) {
+    // Find all unquoted template strings and quote them with proper escaping
+    // This regex looks for template strings that aren't already quoted
+    return jsonString.replace(
+        /(?<!")(\{\{(SYSTEM|ANALYZER):[^}]+\}\})(?!")/g,
+        (match, template) => {
+            // Escape any double quotes within the template string
+            const escapedTemplate = template.replace(/"/g, '\\"');
+            return `"${escapedTemplate}"`;
+        }
+    );
+}
+
+module.exports = {
+    preprocessJsonForValidation
+};

package/src/AnalyzerUtils/management.js

@@ -1,6 +1,6 @@
 /*
  * Component: AnalyzerUtils Management
- * Block-UUID: 0d1e2f3a-4b5c-6d7e-8f9a-0b1c2d3e4f5a
+ * Block-UUID: 6241f381-512b-48a7-b70e-6b45683831fe
  * Parent-UUID: N/A
  * Version: 1.0.0
  * Description: Provides utility functions for managing (deleting) analyzer configurations.
@@ -34,13 +34,13 @@ async function isDirectoryEmpty(dirPath) {
 /**
  * Deletes a specific analyzer configuration and intelligently cleans up empty directories.
  *
- * @param {string} analyzeMessagesBasePath - The absolute or relative path to the base directory containing the analyzer message files (e.g., 'messages/analyze').
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers (e.g., 'analyzers/analyzer-1').
  * @param {string} analyzerId - The unique ID of the analyzer to delete (format: 'analyzer_name::content_type::instructions_type').
  * @returns {Promise<{success: boolean, message: string}>} A promise that resolves with a result object indicating success or failure.
  */
-async function deleteAnalyzer(analyzeMessagesBasePath, analyzerId) {
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        return { success: false, message: 'analyzeMessagesBasePath is required.' };
+async function deleteAnalyzer(analyzersBasePath, analyzerId) {
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        return { success: false, message: 'analyzersBasePath is required.' };
     }
     if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
         return { success: false, message: 'analyzerId is required.' };
@@ -52,7 +52,7 @@ async function deleteAnalyzer(analyzeMessagesBasePath, analyzerId) {
     }
     const [analyzerName, contentType, instructionsType] = parts;
 
-    const analyzerDir = path.join(analyzeMessagesBasePath, analyzerName);
+    const analyzerDir = path.join(analyzersBasePath, analyzerName);
     const contentDir = path.join(analyzerDir, contentType);
     const instructionsDir = path.join(contentDir, instructionsType);
     const instructionsFilePath = path.join(instructionsDir, '1.md');

package/src/AnalyzerUtils/saver.js

@@ -21,19 +21,19 @@ const path = require('path');
  * if necessary, saves the instructions to '1.md'. Optionally, it can
  * ensure config.json files exist with labels derived from directory names.
  *
- * @param {string} analyzeMessagesBasePath - The absolute or relative path to the 'messages/analyze' directory.
+ * @param {string} analyzersBasePath - The absolute path to the base directory containing the analyzers (e.g., 'analyzers/analyzer-1').
  * @param {string} analyzerId - The unique ID of the analyzer (format: 'analyzer_name::content_type::instructions_type').
  * @param {string} instructionsContent - The full content of the analyzer instructions message to be saved in '1.md'.
  * @param {object} [options={}] - Optional configuration options.
  * @param {boolean} [options.ensureConfigs=false] - If true, ensures config.json files exist in the analyzer, content, and instructions directories. Defaults to false.
  * @returns {Promise<{success: boolean, message?: string}>} A promise that resolves with a result object.
  */
-async function saveConfiguration(analyzeMessagesBasePath, analyzerId, instructionsContent, options = {}) {
+async function saveConfiguration(analyzersBasePath, analyzerId, instructionsContent, options = {}) {
     const { ensureConfigs = false } = options;
 
     // 1. Validate inputs
-    if (typeof analyzeMessagesBasePath !== 'string' || analyzeMessagesBasePath.trim() === '') {
-        return { success: false, message: 'analyzeMessagesBasePath is required.' };
+    if (typeof analyzersBasePath !== 'string' || analyzersBasePath.trim() === '') {
+        return { success: false, message: 'analyzersBasePath is required.' };
     }
     if (typeof analyzerId !== 'string' || analyzerId.trim() === '') {
         return { success: false, message: 'analyzerId is required.' };
@@ -66,7 +66,7 @@ async function saveConfiguration(analyzeMessagesBasePath, analyzerId, instructio
     }
 
     // 3. Construct directory paths
-    const analyzerDir = path.join(analyzeMessagesBasePath, analyzerName);
+    const analyzerDir = path.join(analyzersBasePath, analyzerName);
     const contentDir = path.join(analyzerDir, contentType);
     const instructionsDir = path.join(contentDir, instructionsType);
     const instructionsFilePath = path.join(instructionsDir, '1.md');