framework-mcp 1.3.0 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framework-mcp",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Dual-architecture server (MCP + HTTP API) for determining vendor tool capability roles against CIS Controls Framework with intelligent domain validation. Supports Microsoft Copilot custom connectors and DigitalOcean App Services deployment.",
   "main": "dist/interfaces/http/http-server.js",
   "type": "module",

package/scripts/analyze-data-structure.cjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+
+/**
+ * Data Structure Analysis Script
+ * Compares original CIS_SAFEGUARDS with current SafeguardManager interface
+ */
+
+const fs = require('fs');
+
+console.log('📊 CIS Safeguards Data Structure Analysis\n');
+
+// Read original data
+const originalData = fs.readFileSync('/tmp/complete_cis_safeguards.ts', 'utf8');
+console.log('✅ Original data loaded:', originalData.split('\n').length, 'lines');
+
+// Extract safeguard structure from first entry (1.1)
+const match = originalData.match(/"1\.1":\s*{([^}]+(?:{[^}]*}[^}]*)*)/);
+if (match) {
+  console.log('✅ Successfully parsed safeguard 1.1 structure\n');
+  
+  // Extract field names from original data
+  const fieldPattern = /(\w+):/g;
+  const originalFields = new Set();
+  let fieldMatch;
+  
+  while ((fieldMatch = fieldPattern.exec(match[1])) !== null) {
+    originalFields.add(fieldMatch[1]);
+  }
+  
+  console.log('📋 Original fields found:');
+  Array.from(originalFields).sort().forEach(field => {
+    console.log(`  - ${field}`);
+  });
+  
+  // Required fields for SafeguardElement interface
+  const requiredFields = [
+    'id',
+    'title', 
+    'description',
+    'implementationGroup',
+    'assetType',
+    'securityFunction',
+    'governanceElements',
+    'coreRequirements',
+    'subTaxonomicalElements', 
+    'implementationSuggestions',
+    'relatedSafeguards',
+    'keywords'
+  ];
+  
+  console.log('\n📋 Required SafeguardElement fields:');
+  requiredFields.forEach(field => {
+    const present = originalFields.has(field);
+    console.log(`  ${present ? '✅' : '❌'} ${field}`);
+  });
+  
+  // Check for extra fields
+  const extraFields = Array.from(originalFields).filter(f => !requiredFields.includes(f));
+  if (extraFields.length > 0) {
+    console.log('\n⚠️  Extra fields in original data:');
+    extraFields.forEach(field => console.log(`  - ${field}`));
+  }
+  
+  console.log('\n📊 Compatibility Analysis:');
+  const missingFields = requiredFields.filter(f => !originalFields.has(f));
+  if (missingFields.length === 0) {
+    console.log('✅ Perfect compatibility - all required fields present');
+  } else {
+    console.log('❌ Missing fields:', missingFields);
+  }
+  
+} else {
+  console.log('❌ Failed to parse safeguard structure');
+}

package/scripts/clean-safeguards-data.cjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * Clean and format CIS Safeguards data for SafeguardManager compatibility
+ */
+
+const fs = require('fs');
+
+console.log('🧹 Cleaning and Formatting CIS Safeguards Data\n');
+
+// Read original data
+const originalData = fs.readFileSync('/tmp/complete_cis_safeguards.ts', 'utf8');
+
+// Extract just the object content (without const declaration and type annotation)
+const objectMatch = originalData.match(/= {([\s\S]*)};\s*$/);
+if (!objectMatch) {
+  console.log('❌ Failed to extract object content');
+  process.exit(1);
+}
+
+let objectContent = objectMatch[1];
+
+console.log('✅ Extracted object content');
+
+// Clean up the data:
+// 1. Remove TypeScript comments that might break parsing
+objectContent = objectContent.replace(/\/\/ [^\n\r]*/g, '');
+
+// 2. Ensure consistent formatting
+objectContent = objectContent.replace(/\s+/g, ' ').replace(/\s*,\s*/g, ',').replace(/\s*:\s*/g, ':');
+
+// 3. Add proper indentation for readability
+const lines = objectContent.split('\n');
+const indentedLines = lines.map((line, index) => {
+  if (index === 0) return line; // First line stays as is
+  return '    ' + line.trim(); // Indent other lines
+});
+
+objectContent = indentedLines.join('\n');
+
+// Create the properly formatted safeguards object content
+const cleanedContent = `    this.safeguards = {${objectContent}
+    };`;
+
+console.log('✅ Formatted for SafeguardManager integration');
+
+// Write cleaned data to temporary file
+fs.writeFileSync('/tmp/cleaned_safeguards_content.ts', cleanedContent);
+
+console.log('✅ Cleaned data saved to /tmp/cleaned_safeguards_content.ts');
+
+// Show a sample of the cleaned data
+const preview = cleanedContent.substring(0, 500);
+console.log('\n📄 Preview of cleaned data:');
+console.log(preview + '...\n');
+
+console.log('📊 Data Statistics:');
+console.log('  Original size:', originalData.length, 'characters');
+console.log('  Cleaned size:', cleanedContent.length, 'characters');
+console.log('  Ready for SafeguardManager integration ✅');

package/scripts/comprehensive-validation.cjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+/**
+ * Comprehensive Validation Script for CIS Safeguards Migration
+ * This script will be used to validate data integrity during and after migration
+ */
+
+const fs = require('fs');
+
+class SafeguardsValidator {
+  constructor() {
+    this.expectedCount = 153;
+    this.expectedControls = 18;
+    this.requiredFields = [
+      'id', 'title', 'description', 'implementationGroup', 
+      'assetType', 'securityFunction', 'governanceElements',
+      'coreRequirements', 'subTaxonomicalElements', 
+      'implementationSuggestions', 'relatedSafeguards', 'keywords'
+    ];
+  }
+
+  validateFile(filePath) {
+    console.log(`🔍 Validating: ${filePath}\n`);
+    
+    if (!fs.existsSync(filePath)) {
+      console.log('❌ File not found');
+      return false;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    return this.validateContent(content);
+  }
+
+  validateContent(content) {
+    const results = {
+      countTest: false,
+      duplicateTest: false,
+      formatTest: false,
+      syntaxTest: false,
+      fieldsTest: false,
+      controlsTest: false
+    };
+
+    try {
+      // Extract safeguards data
+      let safeguardsData;
+      
+      if (content.includes('this.safeguards = ')) {
+        // SafeguardManager format
+        const match = content.match(/this\.safeguards = ({[\s\S]*});/);
+        safeguardsData = match ? match[1] : null;
+      } else {
+        // Raw CIS_SAFEGUARDS format
+        const match = content.match(/= ({[\s\S]*});/);
+        safeguardsData = match ? match[1] : null;
+      }
+
+      if (!safeguardsData) {
+        console.log('❌ Could not extract safeguards data');
+        return false;
+      }
+
+      // Parse the data
+      const safeguards = eval(`(${safeguardsData})`);
+      const safeguardIds = Object.keys(safeguards);
+
+      // Test 1: Count validation
+      console.log('📊 Count Validation:');
+      console.log(`  Expected: ${this.expectedCount}`);
+      console.log(`  Found: ${safeguardIds.length}`);
+      results.countTest = safeguardIds.length === this.expectedCount;
+      console.log(`  Result: ${results.countTest ? '✅' : '❌'}\n`);
+
+      // Test 2: Duplicate check
+      console.log('🔍 Duplicate Check:');
+      const duplicates = safeguardIds.filter((id, index) => safeguardIds.indexOf(id) !== index);
+      results.duplicateTest = duplicates.length === 0;
+      console.log(`  Duplicates found: ${duplicates.length}`);
+      console.log(`  Result: ${results.duplicateTest ? '✅' : '❌'}\n`);
+
+      // Test 3: ID format validation
+      console.log('📝 Format Validation:');
+      const invalidFormats = safeguardIds.filter(id => !/^\d+\.\d+$/.test(id));
+      results.formatTest = invalidFormats.length === 0;
+      console.log(`  Invalid formats: ${invalidFormats.length}`);
+      console.log(`  Result: ${results.formatTest ? '✅' : '❌'}\n`);
+
+      // Test 4: Syntax validation (already done by eval above)
+      console.log('⚙️  Syntax Validation:');
+      results.syntaxTest = true; // If we got here, syntax is valid
+      console.log(`  Result: ✅\n`);
+
+      // Test 5: Required fields validation
+      console.log('📋 Fields Validation:');
+      let fieldsValid = true;
+      const sampleSafeguard = safeguards[safeguardIds[0]];
+      const missingFields = this.requiredFields.filter(field => !(field in sampleSafeguard));
+      
+      if (missingFields.length > 0) {
+        console.log(`  Missing fields in sample: ${missingFields.join(', ')}`);
+        fieldsValid = false;
+      }
+
+      // Check a few random safeguards for field completeness
+      const testSafeguards = [safeguardIds[0], safeguardIds[Math.floor(safeguardIds.length / 2)], safeguardIds[safeguardIds.length - 1]];
+      for (const id of testSafeguards) {
+        const missing = this.requiredFields.filter(field => !(field in safeguards[id]));
+        if (missing.length > 0) {
+          console.log(`  Missing fields in ${id}: ${missing.join(', ')}`);
+          fieldsValid = false;
+        }
+      }
+
+      results.fieldsTest = fieldsValid;
+      console.log(`  Result: ${fieldsValid ? '✅' : '❌'}\n`);
+
+      // Test 6: Control coverage
+      console.log('🎯 Control Coverage:');
+      const controlCounts = {};
+      safeguardIds.forEach(id => {
+        const control = parseInt(id.split('.')[0]);
+        controlCounts[control] = (controlCounts[control] || 0) + 1;
+      });
+
+      let allControlsPresent = true;
+      for (let i = 1; i <= this.expectedControls; i++) {
+        const count = controlCounts[i] || 0;
+        if (count === 0) {
+          console.log(`  ❌ Control ${i}: Missing`);
+          allControlsPresent = false;
+        } else {
+          console.log(`  ✅ Control ${i}: ${count} safeguards`);
+        }
+      }
+
+      results.controlsTest = allControlsPresent;
+      console.log(`  Result: ${allControlsPresent ? '✅' : '❌'}\n`);
+
+    } catch (error) {
+      console.log('❌ Validation error:', error.message);
+      return false;
+    }
+
+    // Overall result
+    const allTestsPassed = Object.values(results).every(test => test);
+    console.log('🎯 Overall Validation Result:');
+    console.log(`  Status: ${allTestsPassed ? '✅ PASSED' : '❌ FAILED'}`);
+    console.log(`  Details:`, results);
+
+    return allTestsPassed;
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  const validator = new SafeguardsValidator();
+  
+  console.log('🔍 CIS Safeguards Comprehensive Validation\n');
+  console.log('=' .repeat(50) + '\n');
+  
+  // Test the formatted data ready for integration
+  const testFile = '/tmp/formatted_safeguards_ready.ts';
+  const isValid = validator.validateFile(testFile);
+  
+  console.log('\n' + '='.repeat(50));
+  console.log(`Final Result: ${isValid ? '✅ READY FOR INTEGRATION' : '❌ NOT READY'}`);
+  
+  if (!isValid) {
+    console.log('\n❌ Issues found - please fix before proceeding with integration');
+    process.exit(1);
+  } else {
+    console.log('\n🎉 All validations passed - data is ready for SafeguardManager integration!');
+  }
+}
+
+module.exports = SafeguardsValidator;

package/scripts/count-safeguards.cjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+/**
+ * Safeguard Count and Validation Script
+ */
+
+const fs = require('fs');
+
+console.log('🔢 CIS Safeguards Count and Validation\n');
+
+const originalData = fs.readFileSync('/tmp/complete_cis_safeguards.ts', 'utf8');
+
+// Extract all safeguard IDs using regex
+const safeguardPattern = /"(\d+\.\d+)":\s*{/g;
+const safeguardIds = [];
+let match;
+
+while ((match = safeguardPattern.exec(originalData)) !== null) {
+  safeguardIds.push(match[1]);
+}
+
+console.log('📊 Safeguard Count Analysis:');
+console.log(`  Total safeguards found: ${safeguardIds.length}`);
+
+// Sort safeguards numerically
+const sortedIds = safeguardIds.sort((a, b) => {
+  const [aMajor, aMinor] = a.split('.').map(Number);
+  const [bMajor, bMinor] = b.split('.').map(Number);
+  return aMajor - bMajor || aMinor - bMinor;
+});
+
+console.log(`  First safeguard: ${sortedIds[0]}`);
+console.log(`  Last safeguard: ${sortedIds[sortedIds.length - 1]}`);
+
+// Check for duplicates
+const duplicates = safeguardIds.filter((id, index) => safeguardIds.indexOf(id) !== index);
+if (duplicates.length > 0) {
+  console.log('❌ Duplicate safeguards found:', duplicates);
+} else {
+  console.log('✅ No duplicate safeguards');
+}
+
+// Group by control
+const byControl = {};
+sortedIds.forEach(id => {
+  const control = id.split('.')[0];
+  if (!byControl[control]) byControl[control] = [];
+  byControl[control].push(id);
+});
+
+console.log('\n📋 Safeguards by Control:');
+for (let i = 1; i <= 18; i++) {
+  const controlSafeguards = byControl[i.toString()] || [];
+  console.log(`  Control ${i}: ${controlSafeguards.length} safeguards`);
+  if (controlSafeguards.length > 0) {
+    console.log(`    Range: ${controlSafeguards[0]} - ${controlSafeguards[controlSafeguards.length - 1]}`);
+  }
+}
+
+// Validate expected total
+const expectedTotal = 153;
+console.log('\n🎯 Validation Results:');
+console.log(`  Expected: ${expectedTotal} safeguards`);
+console.log(`  Found: ${safeguardIds.length} safeguards`);
+
+if (safeguardIds.length === expectedTotal) {
+  console.log('✅ Perfect count match!');
+} else {
+  console.log(`❌ Count mismatch: ${safeguardIds.length - expectedTotal} difference`);
+}
+
+// Check for missing controls
+const missingControls = [];
+for (let i = 1; i <= 18; i++) {
+  if (!byControl[i.toString()] || byControl[i.toString()].length === 0) {
+    missingControls.push(i);
+  }
+}
+
+if (missingControls.length === 0) {
+  console.log('✅ All 18 CIS Controls represented');
+} else {
+  console.log('❌ Missing controls:', missingControls);
+}
+
+console.log('\n📄 Sample safeguards:');
+sortedIds.slice(0, 5).forEach(id => console.log(`  - ${id}`));
+console.log('  ...');
+sortedIds.slice(-5).forEach(id => console.log(`  - ${id}`));

package/scripts/format-safeguards-proper.cjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+/**
+ * Properly format CIS Safeguards data with readable indentation
+ */
+
+const fs = require('fs');
+
+console.log('✨ Properly Formatting CIS Safeguards Data\n');
+
+// Read original data  
+const originalData = fs.readFileSync('/tmp/complete_cis_safeguards.ts', 'utf8');
+
+// Extract just the safeguards object content (between the braces)
+const match = originalData.match(/const CIS_SAFEGUARDS[^=]*=\s*({[\s\S]*});/);
+if (!match) {
+  console.log('❌ Failed to extract safeguards object');
+  process.exit(1);
+}
+
+const safeguardsObject = match[1];
+
+console.log('✅ Extracted safeguards object');
+
+// Create properly formatted assignment for SafeguardManager
+const formattedContent = `    // Complete CIS Controls v8.1 Framework - 153 safeguards across 18 controls
+    // Migrated from original implementation on ${new Date().toISOString().split('T')[0]}
+    this.safeguards = ${safeguardsObject};`;
+
+// Write formatted data
+fs.writeFileSync('/tmp/formatted_safeguards_ready.ts', formattedContent);
+
+console.log('✅ Properly formatted data saved to /tmp/formatted_safeguards_ready.ts');
+
+// Show preview of properly formatted data
+const lines = formattedContent.split('\n');
+console.log('\n📄 Preview (first 20 lines):');
+lines.slice(0, 20).forEach((line, i) => console.log(`${i + 1}: ${line}`));
+console.log('  ...');
+
+console.log('\n📊 Final Statistics:');
+console.log('  Lines:', lines.length);
+console.log('  Size:', formattedContent.length, 'characters');
+console.log('  Ready for direct integration into SafeguardManager ✅');

package/scripts/validate-formatted-data.cjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+/**
+ * Validate formatted safeguards data for integration readiness
+ */
+
+const fs = require('fs');
+
+console.log('🔍 Validating Formatted Safeguards Data\n');
+
+// Read formatted data
+const formattedData = fs.readFileSync('/tmp/formatted_safeguards_ready.ts', 'utf8');
+
+// Extract safeguard IDs from formatted data
+const idPattern = /"(\d+\.\d+)":\s*{/g;
+const foundIds = [];
+let match;
+
+while ((match = idPattern.exec(formattedData)) !== null) {
+  foundIds.push(match[1]);
+}
+
+console.log('📊 Validation Results:');
+console.log(`  Safeguards found: ${foundIds.length}`);
+
+// Check for duplicates
+const duplicates = foundIds.filter((id, index) => foundIds.indexOf(id) !== index);
+if (duplicates.length > 0) {
+  console.log('❌ Duplicates found:', duplicates);
+} else {
+  console.log('✅ No duplicates');
+}
+
+// Validate ID format
+const invalidIds = foundIds.filter(id => !/^\d+\.\d+$/.test(id));
+if (invalidIds.length > 0) {
+  console.log('❌ Invalid ID formats:', invalidIds);
+} else {
+  console.log('✅ All IDs follow X.Y format');
+}
+
+// Sort and check sequence
+const sortedIds = foundIds.sort((a, b) => {
+  const [aMajor, aMinor] = a.split('.').map(Number);
+  const [bMajor, bMinor] = b.split('.').map(Number);
+  return aMajor - bMajor || aMinor - bMinor;
+});
+
+console.log(`  ID range: ${sortedIds[0]} to ${sortedIds[sortedIds.length - 1]}`);
+
+// Check control coverage
+const controlCounts = {};
+sortedIds.forEach(id => {
+  const control = id.split('.')[0];
+  controlCounts[control] = (controlCounts[control] || 0) + 1;
+});
+
+console.log('\n📋 Control Coverage:');
+for (let i = 1; i <= 18; i++) {
+  const count = controlCounts[i.toString()] || 0;
+  console.log(`  Control ${i}: ${count} safeguards ${count === 0 ? '❌' : '✅'}`);
+}
+
+// Syntax validation - try to evaluate as JavaScript object
+console.log('\n🔍 Syntax Validation:');
+try {
+  // Extract just the object part for validation
+  const objectMatch = formattedData.match(/this\.safeguards = ({[\s\S]*});/);
+  if (objectMatch) {
+    // Basic syntax check by attempting to parse
+    eval(`const testObj = ${objectMatch[1]}`);
+    console.log('✅ Valid JavaScript object syntax');
+    
+    // Check if object has expected safeguard count
+    eval(`const safeguardsCount = Object.keys(${objectMatch[1]}).length`);
+    console.log(`✅ Object contains ${eval(`Object.keys(${objectMatch[1]}).length`)} properties`);
+  } else {
+    console.log('❌ Could not extract object for validation');
+  }
+} catch (error) {
+  console.log('❌ Syntax validation failed:', error.message);
+}
+
+console.log('\n🎯 Final Validation Summary:');
+console.log(`  Expected: 153 safeguards`);
+console.log(`  Found: ${foundIds.length} safeguards`);
+console.log(`  Match: ${foundIds.length === 153 ? '✅' : '❌'}`);
+console.log(`  Ready for integration: ${foundIds.length === 153 && duplicates.length === 0 && invalidIds.length === 0 ? '✅' : '❌'}`);