codereview-aia 0.1.3 → 0.1.4

package/dist/formatters/utils/IssueFormatters.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * @fileoverview Formatters for review issues in different formats.
+ *
+ * This module provides functions to format review issues in different formats,
+ * including structured issues and schema-based issues.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSchemaIssue = formatSchemaIssue;
+exports.formatIssue = formatIssue;
+/**
+ * Format a single issue from the schema format
+ * @param issue Issue object from schema
+ * @param index Issue number
+ * @returns Formatted issue string
+ */
+function formatSchemaIssue(issue, index) {
+    let issueMarkdown = `### ${index}. ${issue.description}\n\n`;
+    if (issue.filePath) {
+        issueMarkdown += `**File**: \`${issue.filePath}\`\n`;
+    }
+    if (issue.location) {
+        issueMarkdown += `**Location**: Lines ${issue.location.startLine}-${issue.location.endLine}\n\n`;
+    }
+    if (issue.currentCode) {
+        issueMarkdown += `**Current Code**:\n\`\`\`\n${issue.currentCode}\n\`\`\`\n\n`;
+    }
+    if (issue.suggestedCode) {
+        issueMarkdown += `**Suggested Fix**:\n\`\`\`\n${issue.suggestedCode}\n\`\`\`\n\n`;
+    }
+    if (issue.explanation) {
+        issueMarkdown += `**Explanation**: ${issue.explanation}\n\n`;
+    }
+    issueMarkdown += `---\n\n`;
+    return issueMarkdown;
+}
+/**
+ * Format a single issue as Markdown
+ * @param issue Review issue
+ * @returns Markdown string
+ */
+function formatIssue(issue) {
+    // Guard against null or undefined issues
+    if (!issue) {
+        return '#### [Error: Issue data missing]';
+    }
+    const { title, type, filePath, lineNumbers, description, codeSnippet, suggestedFix, impact } = issue;
+    let issueMarkdown = `#### ${title || '[Untitled Issue]'}\n`;
+    if (filePath) {
+        issueMarkdown += `- **Location**: \`${filePath}${lineNumbers ? `:${lineNumbers}` : ''}\`\n`;
+    }
+    if (type) {
+        issueMarkdown += `- **Type**: ${type}\n`;
+    }
+    issueMarkdown += `- **Description**: ${description || 'No description provided'}\n`;
+    if (codeSnippet) {
+        issueMarkdown += `- **Code**:\n\`\`\`\n${codeSnippet}\n\`\`\`\n`;
+    }
+    if (suggestedFix) {
+        issueMarkdown += `- **Suggested Fix**:\n\`\`\`\n${suggestedFix}\n\`\`\`\n`;
+    }
+    if (impact) {
+        issueMarkdown += `- **Impact**: ${impact}\n`;
+    }
+    return issueMarkdown;
+}
+//# sourceMappingURL=IssueFormatters.js.map

package/dist/formatters/utils/IssueFormatters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IssueFormatters.js","sourceRoot":"","sources":["../../../src/formatters/utils/IssueFormatters.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAUH,8CA0BC;AAOD,kCAkCC;AAzED;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,KAAU,EAAE,KAAa;IACzD,IAAI,aAAa,GAAG,OAAO,KAAK,KAAK,KAAK,CAAC,WAAW,MAAM,CAAC;IAE7D,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QACnB,aAAa,IAAI,eAAe,KAAK,CAAC,QAAQ,MAAM,CAAC;IACvD,CAAC;IAED,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;QACnB,aAAa,IAAI,uBAAuB,KAAK,CAAC,QAAQ,CAAC,SAAS,IAAI,KAAK,CAAC,QAAQ,CAAC,OAAO,MAAM,CAAC;IACnG,CAAC;IAED,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;QACtB,aAAa,IAAI,8BAA8B,KAAK,CAAC,WAAW,cAAc,CAAC;IACjF,CAAC;IAED,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;QACxB,aAAa,IAAI,+BAA+B,KAAK,CAAC,aAAa,cAAc,CAAC;IACpF,CAAC;IAED,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;QACtB,aAAa,IAAI,oBAAoB,KAAK,CAAC,WAAW,MAAM,CAAC;IAC/D,CAAC;IAED,aAAa,IAAI,SAAS,CAAC;IAE3B,OAAO,aAAa,CAAC;AACvB,CAAC;AAED;;;;GAIG;AACH,SAAgB,WAAW,CAAC,KAAkB;IAC5C,yCAAyC;IACzC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,kCAAkC,CAAC;IAC5C,CAAC;IAED,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,GAC1F,KAAK,CAAC;IAER,IAAI,aAAa,GAAG,QAAQ,KAAK,IAAI,kBAAkB,IAAI,CAAC;IAE5D,IAAI,QAAQ,EAAE,CAAC;QACb,aAAa,IAAI,qBAAqB,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IAC9F,CAAC;IAED,IAAI,IAAI,EAAE,CAAC;QACT,aAAa,IAAI,eAAe,IAAI,IAAI,CAAC;IAC3C,CAAC;IAED,aAAa,IAAI,sBAAsB,WAAW,IAAI,yBAAyB,IAAI,CAAC;IAEpF,IAAI,WAAW,EAAE,CAAC;QAChB,aAAa,IAAI,wBAAwB,WAAW,YAAY,CAAC;IACnE,CAAC;IAED,IAAI,YAAY,EAAE,CAAC;QACjB,aAAa,IAAI,iCAAiC,YAAY,YAAY,CAAC;IAC7E,CAAC;IAED,IAAI,MAAM,EAAE,CAAC;QACX,aAAa,IAAI,iBAAiB,MAAM,IAAI,CAAC;IAC/C,CAAC;IAED,OAAO,aAAa,CAAC;AACvB,CAAC"}

package/dist/formatters/utils/JsonFormatter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Formatter for JSON output of code reviews.
+ *
+ * This module provides functions to format code review results as JSON,
+ * including metadata, structured data, and content.
+ */
+import type { ReviewResult } from '../../types/review';
+/**
+ * Format the review as JSON
+ * @param review Review result to format
+ * @returns JSON string
+ */
+export declare function formatAsJson(review: ReviewResult): string;

package/dist/formatters/utils/JsonFormatter.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * @fileoverview Formatter for JSON output of code reviews.
+ *
+ * This module provides functions to format code review results as JSON,
+ * including metadata, structured data, and content.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAsJson = formatAsJson;
+const sanitizer_1 = require("../../utils/sanitizer");
+const MetadataFormatter_1 = require("./MetadataFormatter");
+const ModelInfoExtractor_1 = require("./ModelInfoExtractor");
+/**
+ * Format the review as JSON
+ * @param review Review result to format
+ * @returns JSON string
+ */
+function formatAsJson(review) {
+    // Extract model information
+    const { modelVendor, modelName, modelInfo } = (0, ModelInfoExtractor_1.extractModelInfo)(review.modelUsed);
+    // Sanitize the content to prevent XSS attacks
+    const sanitizedContent = (0, sanitizer_1.sanitizeContent)(review.content);
+    // Parse structured data if available
+    let parsedStructuredData = review.structuredData;
+    if (typeof review.structuredData === 'string') {
+        try {
+            parsedStructuredData = JSON.parse(review.structuredData);
+        }
+        catch (error) {
+            console.error('Error parsing structured review data:', error);
+        }
+    }
+    // Parse additional metadata if available
+    const additionalMetadata = (0, MetadataFormatter_1.parseMetadata)(review.metadata);
+    // Format path for display
+    let displayPath = review.filePath || '';
+    if (!displayPath || displayPath === review.reviewType || displayPath === 'consolidated') {
+        displayPath = `${process.cwd()} (Current Directory)`;
+    }
+    // Create enhanced metadata with detection info
+    const enhancedMetadata = (0, MetadataFormatter_1.createEnhancedMetadata)(modelVendor, modelName, modelInfo, review.reviewType, displayPath, review.timestamp, review.costInfo || review.cost, review.toolVersion, review.commandOptions, additionalMetadata, review.detectedLanguage, review.detectedFramework, review.frameworkVersion, review.cssFrameworks);
+    // Create a copy of the review with enhanced metadata
+    const reviewWithMeta = {
+        ...review,
+        content: sanitizedContent,
+        structuredData: parsedStructuredData,
+        meta: enhancedMetadata,
+        // Legacy metadata field for backward compatibility
+        metadata: {
+            model: modelInfo,
+            generatedAt: new Date(review.timestamp).toISOString(),
+            costEstimation: review.cost,
+        },
+    };
+    return JSON.stringify(reviewWithMeta, null, 2);
+}
+//# sourceMappingURL=JsonFormatter.js.map

package/dist/formatters/utils/JsonFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonFormatter.js","sourceRoot":"","sources":["../../../src/formatters/utils/JsonFormatter.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AAYH,oCA2DC;AApED,qDAAwD;AACxD,2DAA4E;AAC5E,6DAAwD;AAExD;;;;GAIG;AACH,SAAgB,YAAY,CAAC,MAAoB;IAC/C,4BAA4B;IAC5B,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,IAAA,qCAAgB,EAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAEjF,8CAA8C;IAC9C,MAAM,gBAAgB,GAAG,IAAA,2BAAe,EAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAEzD,qCAAqC;IACrC,IAAI,oBAAoB,GAAG,MAAM,CAAC,cAAc,CAAC;IACjD,IAAI,OAAO,MAAM,CAAC,cAAc,KAAK,QAAQ,EAAE,CAAC;QAC9C,IAAI,CAAC;YACH,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QAC3D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,uCAAuC,EAAE,KAAK,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAED,yCAAyC;IACzC,MAAM,kBAAkB,GAAG,IAAA,iCAAa,EAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE1D,0BAA0B;IAC1B,IAAI,WAAW,GAAG,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC;IACxC,IAAI,CAAC,WAAW,IAAI,WAAW,KAAK,MAAM,CAAC,UAAU,IAAI,WAAW,KAAK,cAAc,EAAE,CAAC;QACxF,WAAW,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,sBAAsB,CAAC;IACvD,CAAC;IAED,+CAA+C;IAC/C,MAAM,gBAAgB,GAAG,IAAA,0CAAsB,EAC7C,WAAW,EACX,SAAS,EACT,SAAS,EACT,MAAM,CAAC,UAAU,EACjB,WAAW,EACX,MAAM,CAAC,SAAS,EAChB,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,IAAI,EAC9B,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,cAAc,EACrB,kBAAkB,EAClB,MAAM,CAAC,gBAAgB,EACvB,MAAM,CAAC,iBAAiB,EACxB,MAAM,CAAC,gBAAgB,EACvB,MAAM,CAAC,aAAa,CACrB,CAAC;IAEF,qDAAqD;IACrD,MAAM,cAAc,GAAG;QACrB,GAAG,MAAM;QACT,OAAO,EAAE,gBAAgB;QACzB,cAAc,EAAE,oBAAoB;QACpC,IAAI,EAAE,gBAAgB;QACtB,mDAAmD;QACnD,QAAQ,EAAE;YACR,KAAK,EAAE,SAAS;YAChB,WAAW,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE;YACrD,cAAc,EAAE,MAAM,CAAC,IAAI;SAC5B;KACF,CAAC;IAEF,OAAO,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;AACjD,CAAC"}

package/dist/formatters/utils/MarkdownFormatters.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Formatters for Markdown output of code reviews.
+ *
+ * This module provides functions to format code review results as Markdown,
+ * including different formats for structured and unstructured reviews.
+ */
+import type { ReviewResult } from '../../types/review';
+import type { StructuredReview } from '../../types/structuredReview';
+/**
+ * Format the review as Markdown
+ * @param review Review result to format
+ * @returns Markdown string
+ */
+export declare function formatAsMarkdown(review: ReviewResult): string;
+/**
+ * Format a structured review as Markdown
+ * @param structuredReview Structured review data
+ * @param filePath Path to the reviewed file
+ * @param reviewType Type of review performed
+ * @param timestamp Timestamp of when the review was generated
+ * @param costInfo Cost information formatted as Markdown
+ * @param modelInfo Model information
+ * @param metadataSection Optional metadata section to include
+ * @returns Markdown string
+ */
+export declare function formatStructuredReviewAsMarkdown(structuredReview: StructuredReview, filePath: string, reviewType: string, timestamp: string, costInfo: string, modelInfo: string, metadataSection?: string): string;
+/**
+ * Format a simple markdown document with just the content
+ * Used as fallback when structured data isn't available
+ * @param content Content to include in the document
+ * @param filePath Path to the reviewed file
+ * @param reviewType Type of review performed
+ * @param timestamp Timestamp of when the review was generated
+ * @param costInfo Cost information formatted as Markdown
+ * @param modelInfo Model information
+ * @param metadataSection Optional metadata section to include
+ * @returns Markdown string
+ */
+export declare function formatSimpleMarkdown(content: string, filePath: string, reviewType: string, timestamp: string, costInfo: string, modelInfo: string, metadataSection?: string): string;
+/**
+ * Format a schema-based review (with 'review' property) as Markdown
+ * @param schemaReview Schema-based review object
+ * @param filePath Path to the reviewed file
+ * @param reviewType Type of review
+ * @param timestamp Timestamp of the review
+ * @param costInfo Cost information string
+ * @param modelInfo Model information string
+ * @param metadataSection Optional metadata section
+ * @returns Formatted markdown string
+ */
+export declare function formatSchemaBasedReviewAsMarkdown(schemaReview: any, filePath: string, reviewType: string, timestamp: string, costInfo: string, modelInfo: string, metadataSection?: string): string;

package/dist/formatters/utils/MarkdownFormatters.js

@@ -0,0 +1,456 @@
+"use strict";
+/**
+ * @fileoverview Formatters for Markdown output of code reviews.
+ *
+ * This module provides functions to format code review results as Markdown,
+ * including different formats for structured and unstructured reviews.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAsMarkdown = formatAsMarkdown;
+exports.formatStructuredReviewAsMarkdown = formatStructuredReviewAsMarkdown;
+exports.formatSimpleMarkdown = formatSimpleMarkdown;
+exports.formatSchemaBasedReviewAsMarkdown = formatSchemaBasedReviewAsMarkdown;
+const logger_1 = __importDefault(require("../../utils/logger"));
+const sanitizer_1 = require("../../utils/sanitizer");
+const IssueFormatters_1 = require("./IssueFormatters");
+const MetadataFormatter_1 = require("./MetadataFormatter");
+const ModelInfoExtractor_1 = require("./ModelInfoExtractor");
+/**
+ * Format the review as Markdown
+ * @param review Review result to format
+ * @returns Markdown string
+ */
+function formatAsMarkdown(review) {
+    const { filePath, reviewType, content, timestamp, structuredData } = review;
+    // Use costInfo if available, fallback to cost
+    const cost = review.costInfo || review.cost;
+    // Extract model information
+    const { modelInfo } = (0, ModelInfoExtractor_1.extractModelInfo)(review.modelUsed);
+    // Format cost information if available
+    const costInfo = (0, MetadataFormatter_1.formatCostInfo)(cost);
+    // Check if the content is JSON that should be formatted as structured data
+    let actualStructuredData = structuredData;
+    // For architectural reviews with diagrams, always prefer Markdown format
+    const forceMarkdown = reviewType === 'architectural' && review.metadata?.diagramRequested;
+    if (!actualStructuredData && content && typeof content === 'string' && !forceMarkdown) {
+        // Improved JSON detection - check for both raw JSON and code blocks
+        const trimmedContent = content.trim();
+        // First, check if this looks like truncated/incomplete JSON
+        if (trimmedContent.startsWith('{') && !trimmedContent.includes('}')) {
+            logger_1.default.warn('Content appears to be truncated JSON - missing closing brace');
+            // Don't try to parse incomplete JSON, just return it as plain text with a warning
+            const warningMessage = '⚠️ **Warning**: The AI response appears to be incomplete or truncated. ' +
+                'This may be due to token limits or API issues. Please try again or use a different model.\n\n' +
+                '**Partial response received:**\n\n';
+            return formatSimpleMarkdown(`${warningMessage}\`\`\`json\n${content}\n\`\`\``, filePath || '', reviewType, timestamp, costInfo, modelInfo);
+        }
+        // Try to extract JSON from code blocks with improved regex
+        // This regex matches code blocks with or without the json language specifier
+        const jsonBlockRegex = /```(?:json)?\s*([\s\S]*?)\s*```/g;
+        const jsonBlocks = [...trimmedContent.matchAll(jsonBlockRegex)];
+        if (jsonBlocks.length > 0) {
+            // Try each code block until we find valid JSON
+            for (const match of jsonBlocks) {
+                try {
+                    const jsonContent = match[1].trim();
+                    if (jsonContent) {
+                        actualStructuredData = JSON.parse(jsonContent);
+                        logger_1.default.debug('Successfully parsed JSON from code block');
+                        break;
+                    }
+                }
+                catch (e) {
+                    logger_1.default.debug(`Failed to parse JSON from code block: ${e instanceof Error ? e.message : String(e)}`);
+                    // Continue to next block
+                }
+            }
+        }
+        // If no valid JSON found in code blocks, try the entire content if it looks like JSON
+        if (!actualStructuredData && trimmedContent.startsWith('{') && trimmedContent.endsWith('}')) {
+            try {
+                actualStructuredData = JSON.parse(trimmedContent);
+                logger_1.default.debug('Successfully parsed JSON from full content');
+            }
+            catch (e) {
+                logger_1.default.debug(`Failed to parse content as JSON: ${e instanceof Error ? e.message : String(e)}`);
+                // Not valid JSON, continue with regular formatting
+            }
+        }
+    }
+    // If we have structured data, format it as Markdown
+    // But skip JSON parsing for architectural reviews with diagrams - keep original Markdown
+    if (actualStructuredData && !forceMarkdown) {
+        try {
+            let structuredReview;
+            if (typeof actualStructuredData === 'string') {
+                try {
+                    structuredReview = JSON.parse(actualStructuredData);
+                    logger_1.default.debug('Successfully parsed structured data string as JSON');
+                }
+                catch (parseError) {
+                    logger_1.default.warn(`Failed to parse structured data as JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                    // If it's not valid JSON, treat it as plain text
+                    return formatSimpleMarkdown(content, filePath || '', reviewType, timestamp, costInfo, modelInfo);
+                }
+            }
+            else {
+                structuredReview = actualStructuredData;
+            }
+            // Check if the data has a 'review' property (our JSON structure)
+            if (structuredReview?.review) {
+                return formatSchemaBasedReviewAsMarkdown(structuredReview, filePath || '', reviewType, timestamp, costInfo, modelInfo);
+            }
+            // Validate the parsed data has expected structure
+            if (typeof structuredReview === 'object' && structuredReview !== null) {
+                return formatStructuredReviewAsMarkdown(structuredReview, filePath || '', reviewType, timestamp, costInfo, modelInfo);
+            }
+            logger_1.default.warn('Structured data is not an object:', typeof structuredReview);
+            // If the data doesn't have the right structure, fall back to plain text
+            return formatSimpleMarkdown(content, filePath || '', reviewType, timestamp, costInfo, modelInfo);
+        }
+        catch (error) {
+            logger_1.default.error(`Error processing structured review data: ${error instanceof Error ? error.message : String(error)}`);
+            // Fall back to unstructured format
+            return formatSimpleMarkdown(content, filePath || '', reviewType, timestamp, costInfo, modelInfo);
+        }
+    }
+    // Sanitize the content to prevent XSS attacks
+    const sanitizedContent = (0, sanitizer_1.sanitizeContent)(content);
+    // Use the actual file path for the review title and the reviewed field
+    // If filePath is the same as reviewType, is 'consolidated', or is undefined/empty, show the current directory path
+    let displayPath = filePath || '';
+    if (!displayPath || displayPath === reviewType || displayPath === 'consolidated') {
+        // For consolidated reviews, show the full target directory path
+        displayPath = `${process.cwd()} (Current Directory)`;
+    }
+    // Extract model vendor and name from modelInfo (currently unused but may be needed for future features)
+    // const { modelVendor, modelName } = extractModelInfoFromString(modelInfo);
+    // Create metadata section
+    const metadataSection = (0, MetadataFormatter_1.formatMetadataSection)(reviewType, timestamp, modelInfo, cost, review.toolVersion, review.commandOptions, review.detectedLanguage, review.detectedFramework, review.frameworkVersion, review.cssFrameworks);
+    return `# Code Review: ${displayPath}
+
+> **Review Type**: ${reviewType}
+> **Model**: ${modelInfo}
+> **Generated**: ${new Date(timestamp).toLocaleString()}
+
+---
+
+${metadataSection}
+
+${sanitizedContent}
+
+---${costInfo}
+
+*Generated by [cr-aia](https://github.com/filipkustec/cr-aia) using ${modelInfo}*`;
+}
+/**
+ * Format a structured review as Markdown
+ * @param structuredReview Structured review data
+ * @param filePath Path to the reviewed file
+ * @param reviewType Type of review performed
+ * @param timestamp Timestamp of when the review was generated
+ * @param costInfo Cost information formatted as Markdown
+ * @param modelInfo Model information
+ * @param metadataSection Optional metadata section to include
+ * @returns Markdown string
+ */
+function formatStructuredReviewAsMarkdown(structuredReview, filePath, reviewType, timestamp, costInfo, modelInfo, metadataSection) {
+    // Check if the structuredReview has required properties
+    if (!structuredReview || typeof structuredReview !== 'object') {
+        console.warn('Invalid structured review data, falling back to simple format');
+        return formatSimpleMarkdown('No structured data available. The review may be in an unsupported format.', filePath, reviewType, timestamp, costInfo, modelInfo, metadataSection);
+    }
+    // Extract properties with fallbacks for missing properties
+    const summary = structuredReview.summary || 'No summary provided';
+    const issues = Array.isArray(structuredReview.issues) ? structuredReview.issues : [];
+    const recommendations = Array.isArray(structuredReview.recommendations)
+        ? structuredReview.recommendations
+        : [];
+    const positiveAspects = Array.isArray(structuredReview.positiveAspects)
+        ? structuredReview.positiveAspects
+        : [];
+    // Extract grade information if available
+    const grade = structuredReview.grade;
+    const gradeCategories = structuredReview.gradeCategories;
+    // Group issues by priority
+    const highPriorityIssues = issues.filter((issue) => issue && issue.priority === 'high');
+    const mediumPriorityIssues = issues.filter((issue) => issue && issue.priority === 'medium');
+    const lowPriorityIssues = issues.filter((issue) => issue && issue.priority === 'low');
+    // Format issues by priority
+    let issuesMarkdown = '';
+    if (highPriorityIssues.length > 0) {
+        issuesMarkdown += '### High Priority\n\n';
+        issuesMarkdown += highPriorityIssues.map((issue) => (0, IssueFormatters_1.formatIssue)(issue)).join('\n\n');
+        issuesMarkdown += '\n\n';
+    }
+    if (mediumPriorityIssues.length > 0) {
+        issuesMarkdown += '### Medium Priority\n\n';
+        issuesMarkdown += mediumPriorityIssues.map((issue) => (0, IssueFormatters_1.formatIssue)(issue)).join('\n\n');
+        issuesMarkdown += '\n\n';
+    }
+    if (lowPriorityIssues.length > 0) {
+        issuesMarkdown += '### Low Priority\n\n';
+        issuesMarkdown += lowPriorityIssues.map((issue) => (0, IssueFormatters_1.formatIssue)(issue)).join('\n\n');
+        issuesMarkdown += '\n\n';
+    }
+    // Format recommendations
+    let recommendationsMarkdown = '';
+    if (recommendations && recommendations.length > 0) {
+        recommendationsMarkdown = '## General Recommendations\n\n';
+        recommendationsMarkdown += recommendations.map((rec) => `- ${rec}`).join('\n');
+        recommendationsMarkdown += '\n\n';
+    }
+    // Format positive aspects
+    let positiveAspectsMarkdown = '';
+    if (positiveAspects && positiveAspects.length > 0) {
+        positiveAspectsMarkdown = '## Positive Aspects\n\n';
+        positiveAspectsMarkdown += positiveAspects.map((aspect) => `- ${aspect}`).join('\n');
+        positiveAspectsMarkdown += '\n\n';
+    }
+    // Use the actual file path for the review title and the reviewed field
+    // If filePath is the same as reviewType, is 'consolidated', or is undefined/empty, show the current directory path
+    let displayPath = filePath || '';
+    if (!displayPath || displayPath === reviewType || displayPath === 'consolidated') {
+        // For consolidated reviews, show the full target directory path
+        displayPath = `${process.cwd()} (Current Directory)`;
+    }
+    // Include metadata section if available
+    const metadataContent = metadataSection ? `${metadataSection}\n` : '';
+    // Format grade section if available
+    let gradeMarkdown = '';
+    if (grade) {
+        gradeMarkdown = `## Grade: ${grade}\n\n`;
+        // Add grade categories if available
+        if (gradeCategories) {
+            if (gradeCategories.functionality)
+                gradeMarkdown += `- **Functionality**: ${gradeCategories.functionality}\n`;
+            if (gradeCategories.codeQuality)
+                gradeMarkdown += `- **Code Quality**: ${gradeCategories.codeQuality}\n`;
+            if (gradeCategories.documentation)
+                gradeMarkdown += `- **Documentation**: ${gradeCategories.documentation}\n`;
+            if (gradeCategories.testing)
+                gradeMarkdown += `- **Testing**: ${gradeCategories.testing}\n`;
+            if (gradeCategories.maintainability)
+                gradeMarkdown += `- **Maintainability**: ${gradeCategories.maintainability}\n`;
+            if (gradeCategories.security)
+                gradeMarkdown += `- **Security**: ${gradeCategories.security}\n`;
+            if (gradeCategories.performance)
+                gradeMarkdown += `- **Performance**: ${gradeCategories.performance}\n`;
+            gradeMarkdown += '\n';
+        }
+    }
+    return `# Code Review: ${displayPath}
+
+> **Review Type**: ${reviewType}
+> **Model**: ${modelInfo}
+> **Generated**: ${new Date(timestamp).toLocaleString()}
+
+---
+
+${metadataContent}${gradeMarkdown}## Summary
+
+${summary}
+
+## Issues
+
+${issuesMarkdown}
+${recommendationsMarkdown}${positiveAspectsMarkdown}---${costInfo}
+
+*Generated by [cr-aia](https://github.com/filipkustec/cr-aia) using ${modelInfo}*`;
+}
+/**
+ * Format a simple markdown document with just the content
+ * Used as fallback when structured data isn't available
+ * @param content Content to include in the document
+ * @param filePath Path to the reviewed file
+ * @param reviewType Type of review performed
+ * @param timestamp Timestamp of when the review was generated
+ * @param costInfo Cost information formatted as Markdown
+ * @param modelInfo Model information
+ * @param metadataSection Optional metadata section to include
+ * @returns Markdown string
+ */
+function formatSimpleMarkdown(content, filePath, reviewType, timestamp, costInfo, modelInfo, metadataSection) {
+    // Sanitize the content
+    const sanitizedContent = (0, sanitizer_1.sanitizeContent)(content);
+    // Use the actual file path for the review title and the reviewed field
+    let displayPath = filePath || '';
+    if (!displayPath || displayPath === reviewType || displayPath === 'consolidated') {
+        // For consolidated reviews, show the full target directory path
+        displayPath = `${process.cwd()} (Current Directory)`;
+    }
+    // Extract model vendor and name from modelInfo
+    const { modelVendor, modelName } = (0, ModelInfoExtractor_1.extractModelInfoFromString)(modelInfo);
+    // Parse cost information if it's available in string form
+    const cost = (0, MetadataFormatter_1.parseCostInfo)(costInfo);
+    // Include metadata section if available
+    const metadataContent = metadataSection ? `${metadataSection}\n` : '';
+    // Generate a metadata section with model information if not provided
+    const modelMetadata = !metadataSection
+        ? `## Metadata
+| Property | Value |
+|----------|-------|
+| Review Type | ${reviewType} |
+| Generated At | ${new Date(timestamp).toLocaleString(undefined, {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            timeZoneName: 'short',
+        })} |
+| Model Provider | ${modelVendor} |
+| Model Name | ${modelName} |${cost
+            ? `
+| Input Tokens | ${cost.inputTokens.toLocaleString()} |
+| Output Tokens | ${cost.outputTokens.toLocaleString()} |
+| Total Tokens | ${cost.totalTokens.toLocaleString()} |
+| Estimated Cost | ${cost.formattedCost} |`
+            : ''}${cost?.passCount
+            ? `
+| Multi-pass Review | ${cost.passCount} passes |`
+            : ''}
+`
+        : '';
+    // Include this metadata section in all formats for consistency
+    const fullMetadataContent = metadataContent || modelMetadata;
+    return `# Code Review: ${displayPath}
+
+> **Review Type**: ${reviewType}
+> **Model**: ${modelInfo}
+> **Generated**: ${new Date(timestamp).toLocaleString()}
+
+---
+
+${fullMetadataContent}
+
+${sanitizedContent}
+
+---${costInfo}
+
+*Generated by [cr-aia](https://github.com/filipkustec/cr-aia) using ${modelInfo}*`;
+}
+/**
+ * Format a schema-based review (with 'review' property) as Markdown
+ * @param schemaReview Schema-based review object
+ * @param filePath Path to the reviewed file
+ * @param reviewType Type of review
+ * @param timestamp Timestamp of the review
+ * @param costInfo Cost information string
+ * @param modelInfo Model information string
+ * @param metadataSection Optional metadata section
+ * @returns Formatted markdown string
+ */
+function formatSchemaBasedReviewAsMarkdown(schemaReview, filePath, reviewType, timestamp, costInfo, modelInfo, metadataSection) {
+    // Extract the review object
+    const review = schemaReview.review;
+    if (!review || typeof review !== 'object') {
+        return formatSimpleMarkdown(JSON.stringify(schemaReview, null, 2), filePath, reviewType, timestamp, costInfo, modelInfo, metadataSection);
+    }
+    // Extract files and issues
+    const files = review.files || [];
+    const summary = review.summary || {};
+    // Create issues sections by priority
+    const highPriorityIssues = [];
+    const mediumPriorityIssues = [];
+    const lowPriorityIssues = [];
+    // Collect all issues from all files
+    files.forEach((file) => {
+        const issues = file.issues || [];
+        issues.forEach((issue) => {
+            // Add file path to issue for context
+            const issueWithFile = { ...issue, filePath: file.filePath };
+            if (issue.priority === 'HIGH') {
+                highPriorityIssues.push(issueWithFile);
+            }
+            else if (issue.priority === 'MEDIUM') {
+                mediumPriorityIssues.push(issueWithFile);
+            }
+            else if (issue.priority === 'LOW') {
+                lowPriorityIssues.push(issueWithFile);
+            }
+        });
+    });
+    // Format the metadata section
+    let displayPath = filePath || '';
+    if (!displayPath || displayPath === reviewType || displayPath === 'consolidated') {
+        displayPath = `${process.cwd()} (Current Directory)`;
+    }
+    // Extract model vendor and name from modelInfo
+    const { modelVendor, modelName } = (0, ModelInfoExtractor_1.extractModelInfoFromString)(modelInfo);
+    // Build the metadata section if not provided
+    if (!metadataSection) {
+        const formattedDate = new Date(timestamp).toLocaleString(undefined, {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            timeZoneName: 'short',
+        });
+        metadataSection = `## Metadata
+| Property | Value |
+|----------|-------|
+| Review Type | ${reviewType} |
+| Generated At | ${formattedDate} |
+| Model Provider | ${modelVendor} |
+| Model Name | ${modelName} |`;
+    }
+    let output = `# Code Review: ${displayPath}
+
+> **Review Type**: ${reviewType}
+> **Model**: ${modelInfo}
+> **Generated**: ${new Date(timestamp).toLocaleString()}
+
+---
+
+${metadataSection}
+
+## Review Summary
+
+`;
+    // Add summary counts
+    if (summary.totalIssues > 0) {
+        output += `Total issues found: **${summary.totalIssues}**
+- High Priority: ${summary.highPriorityIssues || 0}
+- Medium Priority: ${summary.mediumPriorityIssues || 0}
+- Low Priority: ${summary.lowPriorityIssues || 0}
+
+`;
+    }
+    else {
+        output += `No issues found. The code looks good!\n\n`;
+    }
+    // Add issues by priority
+    if (highPriorityIssues.length > 0) {
+        output += `## High Priority Issues\n\n`;
+        highPriorityIssues.forEach((issue, index) => {
+            output += (0, IssueFormatters_1.formatSchemaIssue)(issue, index + 1);
+        });
+    }
+    if (mediumPriorityIssues.length > 0) {
+        output += `## Medium Priority Issues\n\n`;
+        mediumPriorityIssues.forEach((issue, index) => {
+            output += (0, IssueFormatters_1.formatSchemaIssue)(issue, index + 1);
+        });
+    }
+    if (lowPriorityIssues.length > 0) {
+        output += `## Low Priority Issues\n\n`;
+        lowPriorityIssues.forEach((issue, index) => {
+            output += (0, IssueFormatters_1.formatSchemaIssue)(issue, index + 1);
+        });
+    }
+    // Add cost information at the end
+    if (costInfo) {
+        output += `\n${costInfo}\n`;
+    }
+    // Add footer with tool information
+    output += `\n*Generated by [cr-aia](https://github.com/filipkustec/cr-aia) using ${modelInfo}*`;
+    return output;
+}
+//# sourceMappingURL=MarkdownFormatters.js.map