@gitsense/gsc-utils 0.2.0 → 0.2.2

package/src/AnalyzerUtils/dataValidator.js

@@ -0,0 +1,81 @@
+/*
+ * Component: AnalyzerUtils Data Validator
+ * Block-UUID: 1317cc51-fca0-49b7-9e4b-b3e1a06ab93f
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Validates extracted analysis data against chat context and expected schema.
+ * Language: JavaScript
+ * Created-at: 2025-08-28T15:56:40.319Z
+ * Authors: Gemini 2.5 Flash (v1.0.0)
+ */
+
+
+const AnalysisBlockUtils = require('../AnalysisBlockUtils');
+
+/**
+ * Validates the extracted analysis blocks and their metadata.
+ * Checks for valid chat IDs/paths and uses AnalysisBlockUtils for further metadata validation.
+ * This function is adapted from the original `analysisValidation.js` in `gsc-conversation-view`.
+ *
+ * @param {Array<Object>} analysisBlocks - Array of extracted analysis code blocks (Markdown overviews).
+ * @param {Array<Object|null>} analysisMetadataBlocks - Array of extracted analysis metadata blocks (JSON).
+ * @param {Map<number, string>} chatIdToPathMap - Map of chat IDs to file paths from context messages.
+ * @returns {{validAnalysisData: Array<Object>, invalidAnalysisBlocks: Array<string|Object>}}
+ *          An object containing arrays of valid analysis data and invalid analysis blocks.
+ */
+function validateLLMAnalysisData(analysisBlocks, analysisMetadataBlocks, chatIdToPathMap) {
+    const validAnalysisData = []; // Store data for the "Save All" button
+    const invalidAnalysisBlocks = []; // Store invalid analysis blocks
+
+    analysisBlocks.forEach((block, index) => {
+        // Ensure metadata is parsed from the block's content for initial checks
+        const overviewMetadata = AnalysisBlockUtils.parseOverviewMetadata(block.content);
+        const metadataBlock = analysisMetadataBlocks[index];
+        const isDone = metadataBlock ? true : false; // Check if metadata block was successfully processed
+
+        // Skip if metadata block is missing (still streaming or error)
+        if (!overviewMetadata || !isDone) {
+            // If metadata block is missing but streaming stopped, it's an error handled in responseProcessor
+            // If overviewMetadata is missing, it's an error handled in responseProcessor
+            return;
+        }
+
+        const chatId = overviewMetadata['Chat ID'];
+        const path = overviewMetadata['Path'];
+
+        // Is this a valid chat id and path id? Some LLMs will actually hallucinate this
+        if (!chatId || !path || !chatIdToPathMap.has(chatId)) {
+            invalidAnalysisBlocks.push(`<li>#${chatId || 'N/A'} => ${path || 'N/A'} (Invalid Chat ID or Path)</li>`);
+            return;
+        }
+
+        // Perform detailed metadata validation using AnalysisBlockUtils
+        const validation = AnalysisBlockUtils.validateAnalysisMetadata(overviewMetadata);
+
+        if (validation.isValid) {
+            // Prepare data for API call (map keys if necessary)
+            const analysisData = {
+                chatId: overviewMetadata['Chat ID'],
+                // The original analyzeHandler used 'Message ID', 'Repository', 'Summarized At', 'Analyze At',
+                // 'Summary', 'Key Functionality', 'Keywords' from overviewMetadata.
+                // For batch processing, we primarily need chatId, content, and the full JSON metadata.
+                // The other fields can be derived from the full JSON metadata if needed.
+                path: overviewMetadata['Path'],
+                content: block.content, // The full Markdown overview
+                type: AnalysisBlockUtils.getAnalysisBlockType(block.content), // e.g., 'tiny-overview::file-content::default'
+                // We know metadataBlock.content is a valid JSON from responseProcessor
+                metadata: JSON.parse(metadataBlock.content) // The full JSON metadata object
+            };
+            validAnalysisData.push(analysisData); // Add to list for saving
+        } else {
+            // Add invalid analysis block with validation details
+            invalidAnalysisBlocks.push({ block, validation });
+        }
+    });
+
+    return { validAnalysisData, invalidAnalysisBlocks };
+}
+
+module.exports = {
+    validateLLMAnalysisData
+};

package/src/AnalyzerUtils/index.js

@@ -0,0 +1,21 @@
+/*
+ * Component: AnalyzerUtils Index
+ * Block-UUID: b403b6a1-230b-4247-8cd6-2a3d068f4bbf
+ * Parent-UUID: N/A
+ * Version: 1.0.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)
+ */
+
+
+const { buildChatIdToPathMap } = require('./contextMapper');
+const { processLLMAnalysisResponse } = require('./responseProcessor');
+const { validateLLMAnalysisData } = require('./dataValidator');
+
+module.exports = {
+    buildChatIdToPathMap,
+    processLLMAnalysisResponse,
+    validateLLMAnalysisData
+};

package/src/AnalyzerUtils/responseProcessor.js

@@ -0,0 +1,131 @@
+/*
+ * Component: AnalyzerUtils Response Processor
+ * Block-UUID: 2a3b4c5d-6e7f-4a8b-9c0d-1e2f3a4b5c6d
+ * Parent-UUID: N/A
+ * Version: 1.0.0
+ * Description: Extracts and performs initial validation of analysis and metadata code blocks from raw LLM message content.
+ * Language: JavaScript
+ * Created-at: 2025-08-28T15:56:40.319Z
+ * Authors: Gemini 2.5 Flash (v1.0.0)
+ */
+
+
+const CodeBlockUtils = require('../CodeBlockUtils');
+const AnalysisBlockUtils = require('../AnalysisBlockUtils');
+const GSToolBlockUtils = require('../GSToolBlockUtils');
+const JsonUtils = require('../JsonUtils');
+const { ANALYZE_HEADER_PREFIX } = require('./constants');
+
+/**
+ * Extracts code blocks from the message content, identifies analysis and metadata blocks,
+ * and performs initial validation (block type, metadata presence, JSON format).
+ * This function is adapted from the original `blockProcessing.js` in `gsc-conversation-view`.
+ *
+ * @param {string} messageContent - The full content of the message.
+ * @param {boolean} stoppedStreaming - Flag indicating if the message streaming has stopped.
+ * @returns {{analysisBlocks: Array<Object>, analysisMetadataBlocks: Array<Object|null>, error: string|null}}
+ *          An object containing the extracted blocks and any processing error.
+ */
+function processLLMAnalysisResponse(messageContent, stoppedStreaming) {
+    const silent = { silent: true };
+    const { blocks, warnings } = CodeBlockUtils.extractCodeBlocks(messageContent, silent);
+
+    const analysisBlocks = [];
+    const analysisMetadataBlocks = [];
+    let error = null;
+
+    for (let i = 0; i < blocks.length; i += 2) {
+        const analysisBlock = blocks[i];
+
+        // Make sure this is an analysis block by checking its content
+        if (!analysisBlock.content.trimStart().startsWith(ANALYZE_HEADER_PREFIX)) {
+            // Also check if it's a GitSense Tool Block, which should be ignored by this analyzer
+            if (GSToolBlockUtils.isToolBlock(analysisBlock.content)) {
+                // If it's a tool block, it's not an analysis block, so skip it and don't treat as error
+                // Adjust index to skip this block and its potential "metadata" if it was paired
+                if (blocks[i+1] && blocks[i+1].language === 'json') {
+                    i += 1; // Skip the next block too if it's a JSON block (likely tool config)
+                }
+                continue;
+            }
+
+            if (stoppedStreaming) {
+                error = `Analysis block #${i} does not start with the "${ANALYZE_HEADER_PREFIX}" header.`;
+            }
+            // If we are still streaming, we may not have enough information to tell what type
+            // of block this is, so stop looking
+            break;
+        }
+
+        // Add the analysis block (Markdown overview)
+        analysisBlocks.push(analysisBlock);
+
+        // Make sure there is an analysis metadata block (JSON)
+        const analysisMetadataBlock = blocks[i + 1];
+
+        if (!analysisMetadataBlock) {
+            if (stoppedStreaming) {
+                error = `No analysis metadata found for analysis block (index ${i}).`;
+            } else {
+                // Add a null metadata block to let use know we are still streaming
+                analysisMetadataBlocks.push(null);
+            }
+            break;
+        }
+
+        // We found a code block but we don't know if it is valid or not
+        // 1. First make sure the code block is a JSON type
+        // 2. Try to parse the JSON
+        if (analysisMetadataBlock.language !== 'json') {
+            if (stoppedStreaming) {
+                error = `Analysis metadata block for "${analysisBlock.overviewMetadata?.Path || 'Unknown Path'}" has invalid language "${analysisMetadataBlock.language}". Expected "json".`;
+            } else {
+                // Add a null metadata block to let use know we are still streaming
+                analysisMetadataBlocks.push(null);
+            }
+            break;
+        }
+
+        try {
+            // Check for comments within JSON, which would make it invalid for direct parsing
+            const comments = JsonUtils.detectJsonComments(analysisMetadataBlock.content);
+            if (comments.length > 0) {
+                error = `The analysis metadata block for "${analysisBlock.overviewMetadata?.Path || 'Unknown Path'}" contains comments, which makes it invalid JSON.`;
+                if (stoppedStreaming || blocks[i + 2]) { // If streaming stopped or not the last block
+                    break;
+                } else {
+                    analysisMetadataBlocks.push(null); // Add null to keep arrays aligned
+                    return { analysisBlocks, analysisMetadataBlocks, error: null };
+                }
+            }
+
+            JSON.parse(analysisMetadataBlock.content.trim());
+            analysisMetadataBlocks.push(analysisMetadataBlock);
+        } catch (err) {
+            const path = analysisBlock.overviewMetadata?.Path || 'Unknown Path';
+            error = `The analysis metadata block for "${path}" contains an invalid JSON: ${err.message}`;
+
+            // If streaming has stopped or if this is not the last block, set error and break.
+            // Remember to increment by two since every second block is the meta block.
+            if (stoppedStreaming || blocks[i + 2]) {
+                break;
+            } else {
+                // Do nothing since the error is most certaintly due to the fact that we are still
+                // streaming the JSON
+                analysisMetadataBlocks.push(null); // Add null to keep arrays aligned
+                return { analysisBlocks, analysisMetadataBlocks, error: null };
+            }
+        }
+    }
+
+    // If streaming stopped and no overview blocks were found, set an error
+    if (stoppedStreaming && analysisBlocks.length === 0) {
+        error = 'Analysis stopped without producing any data.';
+    }
+
+    return { analysisBlocks, analysisMetadataBlocks, error };
+}
+
+module.exports = {
+    processLLMAnalysisResponse
+};

package/src/ChatUtils.js

@@ -62,13 +62,21 @@ function isNewAnalyzerChat(chat, model) {
 /**
  * Determines if the current chat session appears to be an "Analyze" session.
  * @param {object} chat - The chat object.
- * @param {string} model - Optional model.
  * @returns {boolean} True if the chat matches the Overview Builder pattern, false otherwise.
  */
-function isAnalyzeChat(chat, model) {
+function isAnalyzeChat(chat) {
     return chat.type === 'analyze';
 }
 
+/**
+ * Determines if the current chat session appears to be an "Analyze Builder" session.
+ * @param {object} chat - The chat object.
+ * @returns {boolean} True if the chat matches the Overview Builder pattern, false otherwise.
+ */
+function isAnalyzeBuilderChat(chat) {
+    return chat.type === 'analyze-builder';
+}
+
 /**
  * Determines if the current chat session appears to be an "Ask" session.
  * @param {object} chat - The chat object.
@@ -120,6 +128,7 @@ module.exports = {
     isAskChat,
     isNewAnalyzerChat,
     isAnalyzeChat,
+    isAnalyzeBuilderChat,
     isPlanChat,
     isCodeChat,
     getChatMessages

package/src/GitSenseChatUtils.js

@@ -15,6 +15,7 @@ const CodeBlockUtils = require('./CodeBlockUtils');
 const ContextUtils = require('./ContextUtils');
 const MessageUtils = require('./MessageUtils');
 const AnalysisBlockUtils = require('./AnalysisBlockUtils');
+const AnalyzerUtils = require('./AnalyzerUtils');
 const PatchUtils = require('./PatchUtils');
 const GSToolBlockUtils = require('./GSToolBlockUtils');
 const LLMUtils = require('./LLMUtils');
@@ -360,6 +361,11 @@ module.exports = {
     parseOverviewMetadata,
     validateOverviewMetadata,
 
+    // Analyzer Utilities
+    buildChatIdToPathMap: AnalyzerUtils.buildChatIdToPathMap,
+    processLLMAnalysisResponse: AnalyzerUtils.processLLMAnalysisResponse,
+    validateLLMAnalysisData: AnalyzerUtils.validateLLMAnalysisData,
+
     // ChatUtils
     getChatMessages,