mcp-adr-analysis-server 1.1.0

package/dist/src/utils/research-questions.js

@@ -0,0 +1,319 @@
+/**
+ * Research question generation utilities using prompt-driven AI analysis
+ * Implements intelligent research question generation and task tracking
+ */
+import { McpAdrError } from '../types/index.js';
+/**
+ * Correlate problems with knowledge graph
+ */
+export async function correlateProblemKnowledge(problems, knowledgeGraph) {
+    try {
+        const { generateProblemKnowledgeCorrelationPrompt } = await import('../prompts/research-question-prompts.js');
+        const correlationPrompt = generateProblemKnowledgeCorrelationPrompt(problems, knowledgeGraph);
+        const instructions = `
+# Problem-Knowledge Correlation Instructions
+
+This analysis will correlate identified problems with the architectural knowledge graph to identify research opportunities.
+
+## Correlation Analysis
+- **Problems**: ${problems.length} problems identified
+- **Technologies**: ${knowledgeGraph.technologies.length} technologies in knowledge graph
+- **Patterns**: ${knowledgeGraph.patterns.length} patterns in knowledge graph
+- **ADRs**: ${knowledgeGraph.adrs.length} ADRs in knowledge graph
+- **Relationships**: ${knowledgeGraph.relationships.length} relationships mapped
+
+## Next Steps
+1. **Submit the correlation prompt** to an AI agent for comprehensive analysis
+2. **Parse the JSON response** to get correlation analysis and research opportunities
+3. **Review knowledge gaps** and prioritize research areas
+4. **Use findings** to generate targeted research questions
+
+## Expected AI Response Format
+The AI will return a JSON object with:
+- \`correlationAnalysis\`: Overall correlation statistics and confidence
+- \`problemCorrelations\`: Detailed problem-knowledge correlations
+- \`knowledgeGaps\`: Identified gaps in the knowledge graph
+- \`researchOpportunities\`: Prioritized research opportunities
+- \`recommendations\`: Actionable recommendations for research planning
+
+## Usage Example
+\`\`\`typescript
+const result = await correlateProblemKnowledge(problems, knowledgeGraph);
+// Submit result.correlationPrompt to AI agent
+// Parse AI response for correlation analysis
+\`\`\`
+`;
+        return {
+            correlationPrompt,
+            instructions,
+        };
+    }
+    catch (error) {
+        throw new McpAdrError(`Failed to correlate problems with knowledge: ${error instanceof Error ? error.message : String(error)}`, 'CORRELATION_ERROR');
+    }
+}
+/**
+ * Find relevant ADRs and patterns for research context
+ */
+export async function findRelevantAdrPatterns(researchContext, adrDirectory = 'docs/adrs') {
+    try {
+        const { findFiles } = await import('./file-system.js');
+        const { generateRelevantAdrPatternPrompt } = await import('../prompts/research-question-prompts.js');
+        // Find all ADR files
+        const adrFiles = await findFiles(process.cwd(), [`${adrDirectory}/**/*.md`], {
+            includeContent: true,
+        });
+        // Prepare ADR data
+        const availableAdrs = adrFiles.map(file => {
+            const titleMatch = file.content?.match(/^#\s+(.+)$/m);
+            const statusMatch = file.content?.match(/##\s+Status\s*\n\s*(.+)/i);
+            return {
+                id: file.name.replace(/\.md$/, ''),
+                title: titleMatch?.[1] || file.name.replace(/\.md$/, ''),
+                content: file.content || '',
+                status: statusMatch?.[1] || 'Unknown',
+            };
+        });
+        // Extract patterns from project (simplified for this implementation)
+        const availablePatterns = extractArchitecturalPatterns();
+        const relevancePrompt = generateRelevantAdrPatternPrompt(researchContext, availableAdrs, availablePatterns);
+        const instructions = `
+# Relevant ADR and Pattern Discovery Instructions
+
+This analysis will identify ADRs and patterns relevant to the research context.
+
+## Discovery Scope
+- **Research Topic**: ${researchContext.topic}
+- **Research Category**: ${researchContext.category}
+- **Available ADRs**: ${availableAdrs.length} ADRs
+- **Available Patterns**: ${availablePatterns.length} patterns
+- **Research Objectives**: ${researchContext.objectives.length} objectives
+
+## Next Steps
+1. **Submit the relevance prompt** to an AI agent for analysis
+2. **Parse the JSON response** to get relevant ADRs and patterns
+3. **Review research implications** and constraints
+4. **Use findings** to inform research question generation
+
+## Expected AI Response Format
+The AI will return a JSON object with:
+- \`relevanceAnalysis\`: Overall relevance statistics and confidence
+- \`relevantAdrs\`: ADRs relevant to the research context
+- \`relevantPatterns\`: Patterns applicable to the research
+- \`researchImplications\`: Constraints, opportunities, dependencies, conflicts
+- \`researchGuidance\`: Specific guidance for research approach
+
+## Usage Example
+\`\`\`typescript
+const result = await findRelevantAdrPatterns(researchContext, adrDirectory);
+// Submit result.relevancePrompt to AI agent
+// Parse AI response for relevant knowledge
+\`\`\`
+`;
+        return {
+            relevancePrompt,
+            instructions,
+        };
+    }
+    catch (error) {
+        throw new McpAdrError(`Failed to find relevant ADRs and patterns: ${error instanceof Error ? error.message : String(error)}`, 'RELEVANCE_ANALYSIS_ERROR');
+    }
+}
+/**
+ * Generate context-aware research questions
+ */
+export async function generateContextAwareQuestions(researchContext, relevantKnowledge, projectPath = process.cwd()) {
+    try {
+        const { analyzeProjectStructure } = await import('./file-system.js');
+        const { generateContextAwareResearchQuestionsPrompt } = await import('../prompts/research-question-prompts.js');
+        // Analyze project context
+        const projectStructure = await analyzeProjectStructure(projectPath);
+        const projectContext = {
+            technologies: projectStructure.detectedTechnologies || [],
+            architecture: inferArchitectureType(projectStructure),
+            domain: inferDomainType(projectStructure),
+            scale: inferProjectScale(projectStructure),
+        };
+        const questionPrompt = generateContextAwareResearchQuestionsPrompt({
+            ...researchContext,
+            constraints: researchContext.constraints || [],
+            timeline: researchContext.timeline || 'Not specified',
+        }, relevantKnowledge, projectContext);
+        const instructions = `
+# Context-Aware Research Question Generation Instructions
+
+This analysis will generate specific, actionable research questions based on comprehensive context analysis.
+
+## Question Generation Context
+- **Research Topic**: ${researchContext.topic}
+- **Project Technologies**: ${projectContext.technologies.join(', ')}
+- **Architecture Type**: ${projectContext.architecture}
+- **Domain**: ${projectContext.domain}
+- **Project Scale**: ${projectContext.scale}
+- **Relevant ADRs**: ${relevantKnowledge.adrs.length}
+- **Relevant Patterns**: ${relevantKnowledge.patterns.length}
+- **Knowledge Gaps**: ${relevantKnowledge.gaps.length}
+- **Research Opportunities**: ${relevantKnowledge.opportunities.length}
+
+## Next Steps
+1. **Submit the question prompt** to an AI agent for comprehensive question generation
+2. **Parse the JSON response** to get structured research questions
+3. **Review research plan** and prioritize questions
+4. **Create research tasks** using the task tracking system
+
+## Expected AI Response Format
+The AI will return a JSON object with:
+- \`researchQuestionGeneration\`: Generation metadata and quality metrics
+- \`primaryQuestions\`: Core research questions with detailed specifications
+- \`secondaryQuestions\`: Supporting questions for comprehensive coverage
+- \`methodologicalQuestions\`: Questions about research approach and methodology
+- \`researchPlan\`: Phased research plan with timelines and dependencies
+- \`qualityAssurance\`: Quality assurance and validation approach
+- \`expectedImpact\`: Expected impact and benefits of the research
+
+## Usage Example
+\`\`\`typescript
+const result = await generateContextAwareQuestions(context, knowledge, projectPath);
+// Submit result.questionPrompt to AI agent
+// Parse AI response for research questions and plan
+\`\`\`
+`;
+        return {
+            questionPrompt,
+            instructions,
+        };
+    }
+    catch (error) {
+        throw new McpAdrError(`Failed to generate context-aware questions: ${error instanceof Error ? error.message : String(error)}`, 'QUESTION_GENERATION_ERROR');
+    }
+}
+/**
+ * Create research task tracking system
+ */
+export async function createResearchTaskTracking(researchQuestions, currentProgress) {
+    try {
+        const { generateResearchTaskTrackingPrompt } = await import('../prompts/research-question-prompts.js');
+        const trackingPrompt = generateResearchTaskTrackingPrompt(researchQuestions, currentProgress);
+        const instructions = `
+# Research Task Tracking Instructions
+
+This analysis will create a comprehensive task tracking and management system for research execution.
+
+## Tracking Scope
+- **Research Questions**: ${researchQuestions.length} questions to track
+- **Current Progress**: ${currentProgress?.length || 0} progress entries
+- **Question Types**: ${Array.from(new Set(researchQuestions.map(q => q.type))).join(', ')}
+- **Priority Levels**: ${Array.from(new Set(researchQuestions.map(q => q.priority))).join(', ')}
+
+## Next Steps
+1. **Submit the tracking prompt** to an AI agent for system creation
+2. **Parse the JSON response** to get comprehensive tracking system
+3. **Implement tracking** in project management tools
+4. **Begin research execution** with regular progress updates
+
+## Expected AI Response Format
+The AI will return a JSON object with:
+- \`researchTaskTracking\`: Overall tracking metadata and configuration
+- \`researchTasks\`: Detailed tasks with progress tracking and dependencies
+- \`milestones\`: Key milestones and checkpoints
+- \`riskManagement\`: Risk identification and mitigation strategies
+- \`progressMetrics\`: Quantitative progress measurements
+- \`communicationPlan\`: Stakeholder communication and reporting
+- \`qualityAssurance\`: Quality control and validation processes
+- \`recommendations\`: Process and management recommendations
+
+## Usage Example
+\`\`\`typescript
+const result = await createResearchTaskTracking(questions, progress);
+// Submit result.trackingPrompt to AI agent
+// Parse AI response for task tracking system
+\`\`\`
+`;
+        return {
+            trackingPrompt,
+            instructions,
+        };
+    }
+    catch (error) {
+        throw new McpAdrError(`Failed to create research task tracking: ${error instanceof Error ? error.message : String(error)}`, 'TASK_TRACKING_ERROR');
+    }
+}
+/**
+ * Extract architectural patterns from project structure
+ */
+function extractArchitecturalPatterns() {
+    // Simplified pattern extraction - in a real implementation, this would be more sophisticated
+    return [
+        {
+            name: 'Microservices Architecture',
+            description: 'Distributed architecture with independent services',
+            category: 'architectural',
+        },
+        {
+            name: 'Layered Architecture',
+            description: 'Hierarchical organization of components',
+            category: 'architectural',
+        },
+        {
+            name: 'Event-Driven Architecture',
+            description: 'Asynchronous communication through events',
+            category: 'architectural',
+        },
+        {
+            name: 'Repository Pattern',
+            description: 'Data access abstraction pattern',
+            category: 'design',
+        },
+        {
+            name: 'Factory Pattern',
+            description: 'Object creation abstraction pattern',
+            category: 'design',
+        },
+    ];
+}
+/**
+ * Infer architecture type from project structure
+ */
+function inferArchitectureType(projectStructure) {
+    if (projectStructure.directories?.some((dir) => dir.includes('service'))) {
+        return 'microservices';
+    }
+    if (projectStructure.directories?.some((dir) => dir.includes('layer'))) {
+        return 'layered';
+    }
+    if (projectStructure.detectedTechnologies?.includes('kubernetes')) {
+        return 'cloud-native';
+    }
+    return 'monolithic';
+}
+/**
+ * Infer domain type from project structure
+ */
+function inferDomainType(projectStructure) {
+    const technologies = projectStructure.detectedTechnologies || [];
+    if (technologies.some((tech) => tech.includes('react') || tech.includes('vue') || tech.includes('angular'))) {
+        return 'web-application';
+    }
+    if (technologies.some((tech) => tech.includes('api') || tech.includes('rest'))) {
+        return 'api-service';
+    }
+    if (technologies.some((tech) => tech.includes('data') || tech.includes('analytics'))) {
+        return 'data-platform';
+    }
+    return 'general-software';
+}
+/**
+ * Infer project scale from project structure
+ */
+function inferProjectScale(projectStructure) {
+    const fileCount = projectStructure.totalFiles || 0;
+    const dirCount = projectStructure.totalDirectories || 0;
+    if (fileCount > 1000 || dirCount > 100) {
+        return 'enterprise';
+    }
+    if (fileCount > 100 || dirCount > 20) {
+        return 'medium';
+    }
+    return 'small';
+}
+//# sourceMappingURL=research-questions.js.map

package/dist/src/utils/research-questions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"research-questions.js","sourceRoot":"","sources":["../../../src/utils/research-questions.ts"],"names":[],"mappings":"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"}

package/dist/src/utils/rule-format.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Machine-readable rule format utilities
+ * Implements JSON/YAML rule serialization and validation
+ */
+import { ArchitecturalRule, ValidationResult } from './rule-generation.js';
+export interface RuleSet {
+    metadata: {
+        version: string;
+        name: string;
+        description: string;
+        created: string;
+        lastModified: string;
+        author: string;
+        tags: string[];
+    };
+    rules: ArchitecturalRule[];
+    categories: Array<{
+        name: string;
+        description: string;
+        priority: 'low' | 'medium' | 'high' | 'critical';
+        ruleCount: number;
+    }>;
+    dependencies: Array<{
+        ruleId: string;
+        dependsOn: string[];
+        conflictsWith: string[];
+        relationship: 'requires' | 'enhances' | 'conflicts' | 'supersedes';
+    }>;
+}
+export interface ComplianceReport {
+    metadata: {
+        reportId: string;
+        generatedAt: string;
+        projectName: string;
+        ruleSetVersion: string;
+        scope: string;
+    };
+    summary: {
+        overallCompliance: number;
+        totalFiles: number;
+        totalRules: number;
+        totalViolations: number;
+        riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    };
+    results: ValidationResult[];
+    trends: Array<{
+        date: string;
+        compliance: number;
+        violations: number;
+    }>;
+}
+/**
+ * Create a new rule set with metadata
+ */
+export declare function createRuleSet(name: string, description: string, rules: ArchitecturalRule[], author?: string): RuleSet;
+/**
+ * Serialize rule set to JSON
+ */
+export declare function serializeRuleSetToJson(ruleSet: RuleSet): string;
+/**
+ * Serialize rule set to YAML
+ */
+export declare function serializeRuleSetToYaml(ruleSet: RuleSet): string;
+/**
+ * Parse rule set from JSON
+ */
+export declare function parseRuleSetFromJson(jsonContent: string): RuleSet;
+/**
+ * Create compliance report
+ */
+export declare function createComplianceReport(projectName: string, ruleSetVersion: string, validationResults: ValidationResult[], scope?: string): ComplianceReport;
+/**
+ * Serialize compliance report to JSON
+ */
+export declare function serializeComplianceReportToJson(report: ComplianceReport): string;
+//# sourceMappingURL=rule-format.d.ts.map

package/dist/src/utils/rule-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-format.d.ts","sourceRoot":"","sources":["../../../src/utils/rule-format.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE3E,MAAM,WAAW,OAAO;IACtB,QAAQ,EAAE;QACR,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,EAAE,MAAM,CAAC;QACrB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,EAAE,CAAC;KAChB,CAAC;IACF,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,UAAU,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;QACjD,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC,CAAC;IACH,YAAY,EAAE,KAAK,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,YAAY,EAAE,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,YAAY,CAAC;KACpE,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE;QACR,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,OAAO,EAAE;QACP,iBAAiB,EAAE,MAAM,CAAC;QAC1B,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,eAAe,EAAE,MAAM,CAAC;QACxB,SAAS,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;KACnD,CAAC;IACF,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B,MAAM,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,iBAAiB,EAAE,EAC1B,MAAM,GAAE,MAAkC,GACzC,OAAO,CAsCT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAS/D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAqE/D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAWjE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,iBAAiB,EAAE,gBAAgB,EAAE,EACrC,KAAK,GAAE,MAAuB,GAC7B,gBAAgB,CAgDlB;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAShF"}

package/dist/src/utils/rule-format.js

@@ -0,0 +1,257 @@
+/**
+ * Machine-readable rule format utilities
+ * Implements JSON/YAML rule serialization and validation
+ */
+import { McpAdrError } from '../types/index.js';
+/**
+ * Create a new rule set with metadata
+ */
+export function createRuleSet(name, description, rules, author = 'MCP ADR Analysis Server') {
+    const now = new Date().toISOString();
+    // Group rules by category
+    const categoryMap = new Map();
+    rules.forEach(rule => {
+        const category = rule.category;
+        if (!categoryMap.has(category)) {
+            categoryMap.set(category, []);
+        }
+        categoryMap.get(category).push(rule);
+    });
+    // Create category summaries
+    const categories = Array.from(categoryMap.entries()).map(([name, categoryRules]) => ({
+        name,
+        description: getCategoryDescription(name),
+        priority: getCategoryPriority(name),
+        ruleCount: categoryRules.length,
+    }));
+    // Extract rule dependencies
+    const dependencies = extractRuleDependencies(rules);
+    return {
+        metadata: {
+            version: '1.0.0',
+            name,
+            description,
+            created: now,
+            lastModified: now,
+            author,
+            tags: extractRuleTags(rules),
+        },
+        rules,
+        categories,
+        dependencies,
+    };
+}
+/**
+ * Serialize rule set to JSON
+ */
+export function serializeRuleSetToJson(ruleSet) {
+    try {
+        return JSON.stringify(ruleSet, null, 2);
+    }
+    catch (error) {
+        throw new McpAdrError(`Failed to serialize rule set to JSON: ${error instanceof Error ? error.message : String(error)}`, 'SERIALIZATION_ERROR');
+    }
+}
+/**
+ * Serialize rule set to YAML
+ */
+export function serializeRuleSetToYaml(ruleSet) {
+    try {
+        // Simple YAML serialization (for complex cases, use a proper YAML library)
+        const yamlLines = [];
+        // Metadata section
+        yamlLines.push('metadata:');
+        yamlLines.push(`  version: "${ruleSet.metadata.version}"`);
+        yamlLines.push(`  name: "${ruleSet.metadata.name}"`);
+        yamlLines.push(`  description: "${ruleSet.metadata.description}"`);
+        yamlLines.push(`  created: "${ruleSet.metadata.created}"`);
+        yamlLines.push(`  lastModified: "${ruleSet.metadata.lastModified}"`);
+        yamlLines.push(`  author: "${ruleSet.metadata.author}"`);
+        yamlLines.push('  tags:');
+        ruleSet.metadata.tags.forEach(tag => {
+            yamlLines.push(`    - "${tag}"`);
+        });
+        // Categories section
+        yamlLines.push('');
+        yamlLines.push('categories:');
+        ruleSet.categories.forEach(category => {
+            yamlLines.push(`  - name: "${category.name}"`);
+            yamlLines.push(`    description: "${category.description}"`);
+            yamlLines.push(`    priority: "${category.priority}"`);
+            yamlLines.push(`    ruleCount: ${category.ruleCount}`);
+        });
+        // Rules section
+        yamlLines.push('');
+        yamlLines.push('rules:');
+        ruleSet.rules.forEach(rule => {
+            yamlLines.push(`  - id: "${rule.id}"`);
+            yamlLines.push(`    name: "${rule.name}"`);
+            yamlLines.push(`    description: "${rule.description}"`);
+            yamlLines.push(`    category: "${rule.category}"`);
+            yamlLines.push(`    type: "${rule.type}"`);
+            yamlLines.push(`    severity: "${rule.severity}"`);
+            yamlLines.push(`    scope: "${rule.scope}"`);
+            yamlLines.push(`    pattern: "${rule.pattern}"`);
+            yamlLines.push(`    message: "${rule.message}"`);
+            yamlLines.push(`    automatable: ${rule.automatable}`);
+            yamlLines.push(`    confidence: ${rule.confidence}`);
+            yamlLines.push('    examples:');
+            yamlLines.push('      valid:');
+            rule.examples.valid.forEach(example => {
+                yamlLines.push(`        - "${example}"`);
+            });
+            yamlLines.push('      invalid:');
+            rule.examples.invalid.forEach(example => {
+                yamlLines.push(`        - "${example}"`);
+            });
+            yamlLines.push('    sourceAdrs:');
+            rule.sourceAdrs.forEach(adr => {
+                yamlLines.push(`      - "${adr}"`);
+            });
+            yamlLines.push('    tags:');
+            rule.tags.forEach(tag => {
+                yamlLines.push(`      - "${tag}"`);
+            });
+        });
+        return yamlLines.join('\n');
+    }
+    catch (error) {
+        throw new McpAdrError(`Failed to serialize rule set to YAML: ${error instanceof Error ? error.message : String(error)}`, 'SERIALIZATION_ERROR');
+    }
+}
+/**
+ * Parse rule set from JSON
+ */
+export function parseRuleSetFromJson(jsonContent) {
+    try {
+        const ruleSet = JSON.parse(jsonContent);
+        validateRuleSet(ruleSet);
+        return ruleSet;
+    }
+    catch (error) {
+        throw new McpAdrError(`Failed to parse rule set from JSON: ${error instanceof Error ? error.message : String(error)}`, 'PARSING_ERROR');
+    }
+}
+/**
+ * Create compliance report
+ */
+export function createComplianceReport(projectName, ruleSetVersion, validationResults, scope = 'full_project') {
+    const now = new Date().toISOString();
+    const reportId = `compliance-${Date.now()}`;
+    // Calculate summary metrics
+    const totalFiles = validationResults.length;
+    const totalViolations = validationResults.reduce((sum, result) => sum + result.violations.length, 0);
+    const totalRules = validationResults.reduce((sum, result) => sum + result.totalRulesChecked, 0) / totalFiles;
+    const overallCompliance = validationResults.reduce((sum, result) => sum + result.overallCompliance, 0) / totalFiles;
+    // Determine risk level
+    const criticalViolations = validationResults.reduce((sum, result) => sum + result.violations.filter(v => v.severity === 'critical').length, 0);
+    const errorViolations = validationResults.reduce((sum, result) => sum + result.violations.filter(v => v.severity === 'error').length, 0);
+    let riskLevel = 'low';
+    if (criticalViolations > 0)
+        riskLevel = 'critical';
+    else if (errorViolations > 5)
+        riskLevel = 'high';
+    else if (overallCompliance < 0.8)
+        riskLevel = 'medium';
+    return {
+        metadata: {
+            reportId,
+            generatedAt: now,
+            projectName,
+            ruleSetVersion,
+            scope,
+        },
+        summary: {
+            overallCompliance,
+            totalFiles,
+            totalRules: Math.round(totalRules),
+            totalViolations,
+            riskLevel,
+        },
+        results: validationResults,
+        trends: [], // Would be populated with historical data
+    };
+}
+/**
+ * Serialize compliance report to JSON
+ */
+export function serializeComplianceReportToJson(report) {
+    try {
+        return JSON.stringify(report, null, 2);
+    }
+    catch (error) {
+        throw new McpAdrError(`Failed to serialize compliance report: ${error instanceof Error ? error.message : String(error)}`, 'SERIALIZATION_ERROR');
+    }
+}
+/**
+ * Validate rule set structure
+ */
+function validateRuleSet(ruleSet) {
+    if (!ruleSet.metadata || !ruleSet.rules || !Array.isArray(ruleSet.rules)) {
+        throw new Error('Invalid rule set structure: missing metadata or rules');
+    }
+    if (!ruleSet.metadata.version || !ruleSet.metadata.name) {
+        throw new Error('Invalid rule set metadata: missing version or name');
+    }
+    // Validate each rule
+    ruleSet.rules.forEach((rule, index) => {
+        if (!rule.id || !rule.name || !rule.description) {
+            throw new Error(`Invalid rule at index ${index}: missing required fields`);
+        }
+        if (!['must', 'should', 'may', 'must_not', 'should_not'].includes(rule.type)) {
+            throw new Error(`Invalid rule type at index ${index}: ${rule.type}`);
+        }
+        if (!['info', 'warning', 'error', 'critical'].includes(rule.severity)) {
+            throw new Error(`Invalid rule severity at index ${index}: ${rule.severity}`);
+        }
+    });
+}
+/**
+ * Get category description
+ */
+function getCategoryDescription(category) {
+    const descriptions = {
+        architectural: 'Rules governing overall system architecture and design patterns',
+        technology: 'Rules about technology choices, frameworks, and libraries',
+        coding: 'Rules for code style, organization, and implementation practices',
+        process: 'Rules for development processes and workflows',
+        security: 'Rules for security implementation and best practices',
+        performance: 'Rules for performance optimization and efficiency',
+    };
+    return descriptions[category] || 'General architectural rules';
+}
+/**
+ * Get category priority
+ */
+function getCategoryPriority(category) {
+    const priorities = {
+        security: 'critical',
+        architectural: 'high',
+        performance: 'high',
+        technology: 'medium',
+        coding: 'medium',
+        process: 'low',
+    };
+    return priorities[category] || 'medium';
+}
+/**
+ * Extract rule dependencies
+ */
+function extractRuleDependencies(rules) {
+    // Simple dependency extraction based on rule content
+    // In a real implementation, this would be more sophisticated
+    return rules.map(rule => ({
+        ruleId: rule.id,
+        dependsOn: [],
+        conflictsWith: [],
+        relationship: 'enhances',
+    }));
+}
+/**
+ * Extract tags from rules
+ */
+function extractRuleTags(rules) {
+    const allTags = rules.flatMap(rule => rule.tags);
+    return Array.from(new Set(allTags));
+}
+//# sourceMappingURL=rule-format.js.map