dhurandhar 1.0.0

package/tools/lib/sdm-manager.js

@@ -0,0 +1,982 @@
+/**
+ * System Design Map (SDM) Manager
+ * Handles persistent architectural state for cross-session context rehydration
+ * 
+ * Purpose: Eliminate cognitive fatigue by maintaining architectural context
+ * between sessions without requiring rediscovery
+ */
+
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { readFile, writeFile } from 'fs/promises';
+import yaml from 'yaml';
+
+export class SDMManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.sdmPath = join(projectRoot, 'SYSTEM_DESIGN_MAP.yaml');
+  }
+  
+  /**
+   * Check if SDM exists
+   */
+  exists() {
+    return existsSync(this.sdmPath);
+  }
+  
+  /**
+   * Initialize new SDM
+   */
+  async initialize(projectName = 'new-project') {
+    const sdm = {
+      metadata: {
+        project_name: projectName,
+        version: '1.0.0',
+        last_updated: new Date().toISOString(),
+        architecture_type: 'microservices', // or monolith, serverless
+      },
+      tech_stack: {
+        languages: [],
+        frameworks: [],
+        databases: [],
+        infrastructure: [],
+      },
+      user_types: [],
+      entities: [],
+      services: [],
+      communication: [],
+      infrastructure: {
+        deployment_target: null,
+        components: [],
+      },
+      build_config: [],
+      // NEW: Agile Blueprint for Test-First
+      agile_blueprint: {
+        epics: [],
+        test_suite_status: {
+          total_stories: 0,
+          tested_stories: 0,
+          coverage_percentage: 0,
+          last_test_run: null,
+        },
+      },
+      // NEW: Technical Strategies - Pluggable Architectural Patterns
+      technical_strategies: {
+        persistence: {
+          model: null,
+          constraints: [],
+          database_assignments: {},
+        },
+        state_management: {
+          caching_layer: null,
+          session_storage: null,
+          cache_invalidation: null,
+        },
+        communication: {
+          primary_pattern: null,
+          event_bus: null,
+          api_gateway: null,
+        },
+        deployment: {
+          orchestration: null,
+          scaling_strategy: null,
+          service_mesh: { enabled: false, technology: 'none' },
+        },
+        observability: {
+          logging: null,
+          metrics: null,
+          tracing: null,
+          distributed_tracing: false,
+        },
+        security: {
+          authentication: null,
+          authorization: null,
+          secrets_management: null,
+        },
+        resilience: {
+          circuit_breaker: false,
+          retry_strategy: null,
+          timeout_policy: null,
+          bulkhead_isolation: false,
+        },
+      },
+    };
+
+    await this.save(sdm);
+    return sdm;
+  }
+  
+  /**
+   * Load SDM for rehydration
+   */
+  async load() {
+    if (!this.exists()) {
+      throw new Error('System Design Map not found. Run "dhurandhar install" first.');
+    }
+    
+    const content = await readFile(this.sdmPath, 'utf-8');
+    return yaml.parse(content);
+  }
+  
+  /**
+   * Save SDM
+   */
+  async save(sdm) {
+    // Update timestamp
+    sdm.metadata.last_updated = new Date().toISOString();
+    
+    const content = yaml.stringify(sdm, {
+      indent: 2,
+      lineWidth: 0,
+    });
+    
+    await writeFile(this.sdmPath, content, 'utf-8');
+  }
+  
+  /**
+   * Set architectural strategy
+   */
+  async setStrategy(category, strategy) {
+    const sdm = await this.load();
+
+    if (!sdm.technical_strategies) {
+      sdm.technical_strategies = {};
+    }
+
+    if (!sdm.technical_strategies[category]) {
+      sdm.technical_strategies[category] = {};
+    }
+
+    // Merge strategy into category
+    Object.assign(sdm.technical_strategies[category], strategy);
+
+    await this.save(sdm);
+    return sdm;
+  }
+
+  /**
+   * Get active strategies
+   */
+  async getStrategies() {
+    const sdm = await this.load();
+    return sdm.technical_strategies || {};
+  }
+
+  /**
+   * Get decision registry
+   */
+  async getDecisions() {
+    const sdm = await this.load();
+    return sdm.decision_registry || {};
+  }
+
+  /**
+   * Set decision category
+   */
+  async setDecision(category, decisions) {
+    const sdm = await this.load();
+
+    if (!sdm.decision_registry) {
+      sdm.decision_registry = {};
+    }
+
+    sdm.decision_registry[category] = decisions;
+
+    await this.save(sdm);
+    return sdm;
+  }
+
+  /**
+   * Get rehydration context (including decisions)
+   */
+  async getRehydrationContext() {
+    const sdm = await this.load();
+
+    return {
+      metadata: sdm.metadata || {},
+      tech_stack: sdm.tech_stack || {},
+      decision_registry: sdm.decision_registry || {}, // NEW
+      technical_strategies: sdm.technical_strategies || {},
+      services: sdm.services || [],
+      entities: sdm.entities || [],
+      agile_blueprint: sdm.agile_blueprint || {},
+    };
+  }
+
+  /**
+   * Apply strategy constraints to service
+   */
+  applyStrategyConstraints(service, strategies) {
+    // Clone service to avoid mutation
+    const enhancedService = { ...service };
+
+    // Persistence Strategy: Database-per-Service
+    if (strategies.persistence?.model === 'database_per_service') {
+      if (!enhancedService.dedicated_database) {
+        enhancedService.dedicated_database = {
+          name: `${service.name.replace('-service', '')}_db`,
+          type: service.tech_stack?.database || 'PostgreSQL',
+          isolation: 'full',
+        };
+      }
+
+      // Add constraint: No cross-service queries
+      if (!enhancedService.constraints) enhancedService.constraints = [];
+      if (!enhancedService.constraints.includes('no_cross_service_queries')) {
+        enhancedService.constraints.push('no_cross_service_queries');
+      }
+    }
+
+    // Communication Strategy: Event-Driven
+    if (strategies.communication?.primary_pattern === 'asynchronous_events') {
+      if (!enhancedService.event_boundaries) {
+        enhancedService.event_boundaries = {
+          produces: [],
+          consumes: [],
+          event_bus: strategies.communication.event_bus?.technology || 'kafka',
+        };
+      }
+    }
+
+    // State Management: Distributed Cache
+    if (strategies.state_management?.caching_layer === 'distributed_redis') {
+      if (!enhancedService.dependencies) enhancedService.dependencies = [];
+      if (!enhancedService.dependencies.includes('redis')) {
+        enhancedService.dependencies.push('redis');
+      }
+
+      enhancedService.cache_config = {
+        type: 'redis',
+        strategy: strategies.state_management.cache_invalidation || 'ttl_based',
+      };
+    }
+
+    // Resilience: Circuit Breaker
+    if (strategies.resilience?.circuit_breaker) {
+      enhancedService.resilience = {
+        circuit_breaker: {
+          enabled: true,
+          failure_threshold: 5,
+          timeout: 30000,
+        },
+        retry: {
+          strategy: strategies.resilience.retry_strategy || 'exponential_backoff',
+          max_attempts: 3,
+        },
+        timeout: strategies.resilience.timeout_policy || 'moderate_30s',
+      };
+    }
+
+    // Security: Authentication
+    if (strategies.security?.authentication === 'jwt_centralized') {
+      if (!enhancedService.dependencies) enhancedService.dependencies = [];
+      if (!enhancedService.dependencies.includes('auth-service')) {
+        enhancedService.dependencies.push('auth-service');
+      }
+
+      enhancedService.authentication = {
+        type: 'jwt',
+        validation: 'centralized',
+        token_endpoint: '/api/v1/auth/validate',
+      };
+    }
+
+    return enhancedService;
+  }
+
+  /**
+   * Apply decision registry constraints to service
+   */
+  applyDecisionConstraints(service, decisions) {
+    if (!decisions) return service;
+
+    const enhancedService = { ...service };
+
+    // Add decision constraints as metadata
+    enhancedService._decision_constraints = {};
+
+    // Naming conventions
+    if (decisions.naming_conventions) {
+      enhancedService._decision_constraints.naming = {
+        case_styles: decisions.naming_conventions.case_styles || {},
+        file_patterns: decisions.naming_conventions.file_patterns || {},
+      };
+    }
+
+    // Design patterns
+    if (decisions.design_patterns) {
+      enhancedService._decision_constraints.patterns = {
+        data_access: decisions.design_patterns.data_access,
+        dependency_injection: decisions.design_patterns.dependency_injection,
+        validation: decisions.design_patterns.validation,
+      };
+
+      // Check for service-specific patterns
+      const servicePattern = decisions.design_patterns.service_specific_patterns?.find(
+        p => p.service === service.name
+      );
+      if (servicePattern) {
+        enhancedService._decision_constraints.patterns.service_specific = servicePattern.pattern;
+      }
+    }
+
+    // Error standards
+    if (decisions.error_response_standards) {
+      enhancedService._decision_constraints.errors = {
+        code_mapping: decisions.error_response_standards.error_code_mapping || {},
+        response_envelope: decisions.error_response_standards.response_envelope || {},
+      };
+    }
+
+    // Observability standards
+    if (decisions.observability_standards) {
+      enhancedService._decision_constraints.observability = {
+        logging: decisions.observability_standards.logging || {},
+        tracing: decisions.observability_standards.tracing || {},
+        metrics: decisions.observability_standards.metrics || {},
+      };
+    }
+
+    return enhancedService;
+  }
+
+  /**
+   * Add a service to SDM (with strategy and decision injection)
+   */
+  async addService(service) {
+    const sdm = await this.load();
+
+    // Apply global strategy constraints
+    const strategies = sdm.technical_strategies || {};
+    let enhancedService = this.applyStrategyConstraints(service, strategies);
+
+    // Apply decision registry constraints
+    const decisions = sdm.decision_registry || {};
+    enhancedService = this.applyDecisionConstraints(enhancedService, decisions);
+
+    // Check if service already exists
+    const existingIndex = sdm.services.findIndex(s => s.name === service.name);
+
+    if (existingIndex >= 0) {
+      // Update existing
+      sdm.services[existingIndex] = { ...sdm.services[existingIndex], ...enhancedService };
+    } else {
+      // Add new
+      sdm.services.push(enhancedService);
+    }
+
+    // Update tech stack summary
+    this.updateTechStackSummary(sdm, enhancedService);
+
+    await this.save(sdm);
+    return sdm;
+  }
+  
+  /**
+   * Add an entity to SDM
+   */
+  async addEntity(entity) {
+    const sdm = await this.load();
+    
+    const existingIndex = sdm.entities.findIndex(e => e.name === entity.name);
+    
+    if (existingIndex >= 0) {
+      sdm.entities[existingIndex] = { ...sdm.entities[existingIndex], ...entity };
+    } else {
+      sdm.entities.push(entity);
+    }
+    
+    await this.save(sdm);
+    return sdm;
+  }
+  
+  /**
+   * Add service communication pattern
+   */
+  async addCommunication(from, to, protocol, pattern = 'sync') {
+    const sdm = await this.load();
+    
+    const comm = { from, to, protocol, pattern };
+    
+    // Remove duplicate if exists
+    sdm.communication = sdm.communication.filter(
+      c => !(c.from === from && c.to === to)
+    );
+    
+    sdm.communication.push(comm);
+    
+    await this.save(sdm);
+    return sdm;
+  }
+  
+  /**
+   * Add Epic to Agile Blueprint
+   */
+  async addEpic(epic) {
+    const sdm = await this.load();
+
+    if (!sdm.agile_blueprint) {
+      sdm.agile_blueprint = { epics: [], test_suite_status: {} };
+    }
+    if (!sdm.agile_blueprint.epics) {
+      sdm.agile_blueprint.epics = [];
+    }
+
+    sdm.agile_blueprint.epics.push(epic);
+    await this.save(sdm);
+    return sdm;
+  }
+
+  /**
+   * Add Story to Epic
+   */
+  async addStory(epicId, story) {
+    const sdm = await this.load();
+
+    const epic = sdm.agile_blueprint?.epics?.find(e => e.id === epicId);
+    if (!epic) {
+      throw new Error(`Epic ${epicId} not found`);
+    }
+
+    if (!epic.stories) epic.stories = [];
+    epic.stories.push(story);
+
+    await this.save(sdm);
+    return sdm;
+  }
+
+  /**
+   * Update task status
+   */
+  async updateTaskStatus(storyId, taskId, status) {
+    const sdm = await this.load();
+
+    for (const epic of sdm.agile_blueprint?.epics || []) {
+      const story = epic.stories?.find(s => s.id === storyId);
+      if (story) {
+        const task = story.tasks?.find(t => t.id === taskId);
+        if (task) {
+          task.status = status;
+          await this.save(sdm);
+          return sdm;
+        }
+      }
+    }
+
+    throw new Error(`Task ${taskId} not found in Story ${storyId}`);
+  }
+
+  /**
+   * Get rehydration context (formatted for agent consumption)
+   */
+  async getRehydrationContext() {
+    const sdm = await this.load();
+
+    return {
+      summary: this.generateSummary(sdm),
+      services: sdm.services,
+      entities: sdm.entities,
+      communication: sdm.communication,
+      agile_blueprint: sdm.agile_blueprint,
+      fullMap: sdm,
+    };
+  }
+  
+  /**
+   * Generate human-readable summary
+   */
+  generateSummary(sdm) {
+    const lines = [];
+
+    lines.push(`# ${sdm.metadata.project_name}`);
+    lines.push(`Architecture: ${sdm.metadata.architecture_type}`);
+    lines.push(`Last Updated: ${sdm.metadata.last_updated}`);
+    lines.push('');
+    lines.push('## Tech Stack');
+    lines.push(`Languages: ${sdm.tech_stack.languages.join(', ') || 'None'}`);
+    lines.push(`Frameworks: ${sdm.tech_stack.frameworks.join(', ') || 'None'}`);
+    lines.push(`Databases: ${sdm.tech_stack.databases.join(', ') || 'None'}`);
+    lines.push('');
+    lines.push(`## Services (${sdm.services.length})`);
+    sdm.services.forEach(s => {
+      lines.push(`- ${s.name}: ${s.scope}`);
+      lines.push(`  Stack: ${s.tech_stack.language}/${s.tech_stack.framework}`);
+    });
+    lines.push('');
+
+    // Technical Strategies Summary
+    if (sdm.technical_strategies) {
+      const strategies = [];
+      if (sdm.technical_strategies.persistence?.model) {
+        strategies.push(`Persistence: ${sdm.technical_strategies.persistence.model}`);
+      }
+      if (sdm.technical_strategies.communication?.primary_pattern) {
+        strategies.push(`Communication: ${sdm.technical_strategies.communication.primary_pattern}`);
+      }
+      if (sdm.technical_strategies.state_management?.caching_layer) {
+        strategies.push(`Caching: ${sdm.technical_strategies.state_management.caching_layer}`);
+      }
+
+      if (strategies.length > 0) {
+        lines.push(`## Active Strategies`);
+        strategies.forEach(s => lines.push(`- ${s}`));
+        lines.push('');
+      }
+    }
+
+    // Agile Blueprint Summary
+    if (sdm.agile_blueprint && sdm.agile_blueprint.epics && sdm.agile_blueprint.epics.length > 0) {
+      const totalStories = sdm.agile_blueprint.epics.reduce((acc, e) => acc + (e.stories?.length || 0), 0);
+      lines.push(`## Agile Blueprint`);
+      lines.push(`Epics: ${sdm.agile_blueprint.epics.length}`);
+      lines.push(`Stories: ${totalStories}`);
+      if (sdm.agile_blueprint.test_suite_status) {
+        lines.push(`Test Coverage: ${sdm.agile_blueprint.test_suite_status.coverage_percentage || 0}%`);
+      }
+      lines.push('');
+    }
+
+    return lines.join('\n');
+  }
+  
+  /**
+   * Check architectural alignment for existing services
+   * Returns services that need updates to match new strategy
+   */
+  async checkStrategyAlignment(newStrategy, category) {
+    const sdm = await this.load();
+    const misalignedServices = [];
+
+    for (const service of sdm.services) {
+      const alignmentIssues = [];
+
+      // Check persistence alignment
+      if (category === 'persistence' && newStrategy.model === 'database_per_service') {
+        if (!service.dedicated_database) {
+          alignmentIssues.push('Missing dedicated database');
+        }
+      }
+
+      // Check communication alignment
+      if (category === 'communication' && newStrategy.primary_pattern === 'asynchronous_events') {
+        if (!service.event_boundaries) {
+          alignmentIssues.push('Missing event boundaries (produces/consumes)');
+        }
+      }
+
+      // Check state management alignment
+      if (category === 'state_management' && newStrategy.caching_layer === 'distributed_redis') {
+        if (!service.dependencies?.includes('redis')) {
+          alignmentIssues.push('Missing Redis dependency for distributed cache');
+        }
+      }
+
+      if (alignmentIssues.length > 0) {
+        misalignedServices.push({
+          service: service.name,
+          issues: alignmentIssues,
+        });
+      }
+    }
+
+    return misalignedServices;
+  }
+
+  /**
+   * Apply strategy to all existing services
+   */
+  async realignServicesToStrategy() {
+    const sdm = await this.load();
+    const strategies = sdm.technical_strategies;
+
+    for (let i = 0; i < sdm.services.length; i++) {
+      sdm.services[i] = this.applyStrategyConstraints(sdm.services[i], strategies);
+    }
+
+    await this.save(sdm);
+    return sdm;
+  }
+
+  /**
+   * Perform architectural audit - detect drift between SDM and codebase
+   */
+  async performAudit() {
+    const sdm = await this.load();
+    const codebase = await this.scanCodebase();
+
+    const audit = {
+      timestamp: new Date().toISOString(),
+      summary: {
+        total_services: sdm.services.length,
+        implemented_services: 0,
+        total_entities: sdm.entities.length,
+        implemented_entities: 0,
+        total_stories: 0,
+        tested_stories: 0,
+        strategy_compliance_percentage: 100,
+      },
+      unimplemented: {
+        services: [],
+        entities: [],
+        stories: [],
+      },
+      unmanaged: {
+        services: [],
+        entities: [],
+        routes: [],
+      },
+      strategy_violations: [],
+      drift_percentage: 0,
+    };
+
+    // Check services
+    for (const service of sdm.services) {
+      const implemented = codebase.services.some(s =>
+        s.name === service.name || s.name === service.name.replace('-service', '')
+      );
+
+      if (implemented) {
+        audit.summary.implemented_services++;
+
+        // Check strategy compliance
+        const violations = this.checkServiceStrategyCompliance(service, sdm.technical_strategies, codebase);
+        audit.strategy_violations.push(...violations);
+      } else {
+        audit.unimplemented.services.push({
+          name: service.name,
+          scope: service.scope,
+        });
+      }
+    }
+
+    // Check entities
+    for (const entity of sdm.entities) {
+      const implemented = codebase.entities.some(e =>
+        e.name === entity.name || e.table_name === entity.table_name
+      );
+
+      if (implemented) {
+        audit.summary.implemented_entities++;
+      } else {
+        audit.unimplemented.entities.push({
+          name: entity.name,
+          table_name: entity.table_name,
+        });
+      }
+    }
+
+    // Check stories and tests
+    if (sdm.agile_blueprint && sdm.agile_blueprint.epics) {
+      for (const epic of sdm.agile_blueprint.epics) {
+        for (const story of epic.stories || []) {
+          audit.summary.total_stories++;
+
+          const testFile = `tests/contracts/${story.id.toLowerCase()}-standard.test.js`;
+          const testExists = codebase.tests.includes(testFile);
+
+          if (testExists) {
+            audit.summary.tested_stories++;
+          } else {
+            audit.unimplemented.stories.push({
+              id: story.id,
+              name: story.name,
+              epic: epic.id,
+            });
+          }
+        }
+      }
+    }
+
+    // Check unmanaged (code not in SDM)
+    for (const codeService of codebase.services) {
+      const inSDM = sdm.services.some(s =>
+        s.name === codeService.name || `${codeService.name}-service` === s.name
+      );
+
+      if (!inSDM) {
+        audit.unmanaged.services.push(codeService);
+      }
+    }
+
+    for (const codeEntity of codebase.entities) {
+      const inSDM = sdm.entities.some(e =>
+        e.name === codeEntity.name || e.table_name === codeEntity.table_name
+      );
+
+      if (!inSDM) {
+        audit.unmanaged.entities.push(codeEntity);
+      }
+    }
+
+    // Calculate drift percentage
+    const totalComponents =
+      audit.summary.total_services +
+      audit.summary.total_entities +
+      audit.summary.total_stories;
+
+    const driftComponents =
+      audit.unimplemented.services.length +
+      audit.unimplemented.entities.length +
+      audit.unimplemented.stories.length +
+      audit.unmanaged.services.length +
+      audit.unmanaged.entities.length +
+      audit.strategy_violations.length;
+
+    audit.drift_percentage = totalComponents > 0
+      ? Math.round((driftComponents / totalComponents) * 100)
+      : 0;
+
+    // Calculate strategy compliance
+    const totalViolations = audit.strategy_violations.length;
+    const totalServices = sdm.services.length;
+    audit.summary.strategy_compliance_percentage = totalServices > 0
+      ? Math.round(((totalServices - totalViolations) / totalServices) * 100)
+      : 100;
+
+    return audit;
+  }
+
+  /**
+   * Scan codebase for actual implementation
+   */
+  async scanCodebase() {
+    const fs = await import('fs');
+    const path = await import('path');
+
+    const codebase = {
+      services: [],
+      entities: [],
+      routes: [],
+      tests: [],
+    };
+
+    // Scan for services
+    const serviceDirs = ['services', 'cmd', 'src/services', 'apps'];
+    for (const dir of serviceDirs) {
+      const fullPath = path.join(this.projectRoot, dir);
+      if (fs.existsSync(fullPath)) {
+        const items = fs.readdirSync(fullPath, { withFileTypes: true });
+        for (const item of items) {
+          if (item.isDirectory()) {
+            codebase.services.push({
+              name: item.name,
+              path: path.join(dir, item.name),
+            });
+          }
+        }
+      }
+    }
+
+    // Scan for entities/models
+    const entityDirs = ['models', 'entities', 'src/models', 'src/entities'];
+    for (const dir of entityDirs) {
+      const fullPath = path.join(this.projectRoot, dir);
+      if (fs.existsSync(fullPath)) {
+        const items = fs.readdirSync(fullPath);
+        for (const item of items) {
+          if (item.match(/\.(ts|js|go|py)$/)) {
+            const name = item.replace(/\.(ts|js|go|py)$/, '');
+            codebase.entities.push({
+              name,
+              file: path.join(dir, item),
+            });
+          }
+        }
+      }
+    }
+
+    // Scan for tests
+    const testDirs = ['tests', '__tests__', 'test'];
+    for (const dir of testDirs) {
+      const fullPath = path.join(this.projectRoot, dir);
+      if (fs.existsSync(fullPath)) {
+        this.scanTestsRecursive(fullPath, dir, codebase.tests);
+      }
+    }
+
+    return codebase;
+  }
+
+  /**
+   * Recursively scan test directories
+   */
+  scanTestsRecursive(dir, relativePath, tests) {
+    const fs = require('fs');
+    const path = require('path');
+
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+      const fullPath = path.join(dir, item.name);
+      const relPath = path.join(relativePath, item.name);
+
+      if (item.isDirectory()) {
+        this.scanTestsRecursive(fullPath, relPath, tests);
+      } else if (item.name.match(/\.(test|spec)\.(ts|js)$/) || item.name.match(/_test\.go$/)) {
+        tests.push(relPath);
+      }
+    }
+  }
+
+  /**
+   * Check service compliance with decision registry
+   */
+  checkServiceDecisionCompliance(service, decisions, codebase) {
+    const violations = [];
+
+    if (!decisions) return violations;
+
+    // Check naming conventions (would need code analysis - placeholder)
+    // In real implementation, would analyze actual code files
+
+    // Check design patterns compliance
+    if (decisions.design_patterns?.data_access && service._decision_constraints) {
+      const expectedPattern = decisions.design_patterns.data_access;
+      // Placeholder: Would analyze code to verify Repository pattern is used
+    }
+
+    return violations;
+  }
+
+  /**
+   * Check service compliance with active strategies
+   */
+  checkServiceStrategyCompliance(service, strategies, codebase) {
+    const violations = [];
+
+    if (!strategies) return violations;
+
+    // Check persistence strategy
+    if (strategies.persistence?.model === 'database_per_service') {
+      if (!service.dedicated_database) {
+        violations.push({
+          service: service.name,
+          strategy: 'persistence',
+          violation: 'Missing dedicated database',
+          expected: 'database_per_service',
+          actual: 'no dedicated_database config',
+        });
+      }
+    }
+
+    // Check communication strategy
+    if (strategies.communication?.primary_pattern === 'asynchronous_events') {
+      if (!service.event_boundaries) {
+        violations.push({
+          service: service.name,
+          strategy: 'communication',
+          violation: 'Missing event boundaries',
+          expected: 'asynchronous_events',
+          actual: 'no event_boundaries config',
+        });
+      }
+    }
+
+    // Check security strategy
+    if (strategies.security?.authentication === 'jwt_centralized') {
+      if (service.name !== 'auth-service' && !service.dependencies?.includes('auth-service')) {
+        violations.push({
+          service: service.name,
+          strategy: 'security',
+          violation: 'Missing auth-service dependency',
+          expected: 'jwt_centralized',
+          actual: 'no auth-service dependency',
+        });
+      }
+    }
+
+    // Check resilience strategy
+    if (strategies.resilience?.circuit_breaker === true) {
+      if (!service.resilience?.circuit_breaker) {
+        violations.push({
+          service: service.name,
+          strategy: 'resilience',
+          violation: 'Missing circuit breaker config',
+          expected: 'circuit_breaker: true',
+          actual: 'no circuit_breaker config',
+        });
+      }
+    }
+
+    return violations;
+  }
+
+  /**
+   * Sync SDM to match codebase state
+   */
+  async syncToCodebase() {
+    const sdm = await this.load();
+    const codebase = await this.scanCodebase();
+    const changes = {
+      added: { services: 0, entities: 0 },
+      removed: { services: 0, entities: 0 },
+    };
+
+    // Add unmanaged services
+    for (const codeService of codebase.services) {
+      const inSDM = sdm.services.some(s =>
+        s.name === codeService.name || `${codeService.name}-service` === s.name
+      );
+
+      if (!inSDM) {
+        sdm.services.push({
+          name: `${codeService.name}-service`,
+          scope: `Auto-discovered from ${codeService.path}`,
+          tech_stack: {
+            language: sdm.tech_stack.languages[0] || 'Unknown',
+            framework: sdm.tech_stack.frameworks[0] || 'Unknown',
+          },
+          _discovered: true,
+        });
+        changes.added.services++;
+      }
+    }
+
+    // Add unmanaged entities
+    for (const codeEntity of codebase.entities) {
+      const inSDM = sdm.entities.some(e =>
+        e.name === codeEntity.name
+      );
+
+      if (!inSDM) {
+        sdm.entities.push({
+          name: codeEntity.name,
+          table_name: codeEntity.name.toLowerCase() + 's',
+          attributes: [],
+          _discovered: true,
+        });
+        changes.added.entities++;
+      }
+    }
+
+    // Mark unimplemented as "planned" instead of removing
+    for (const service of sdm.services) {
+      const implemented = codebase.services.some(s =>
+        s.name === service.name || s.name === service.name.replace('-service', '')
+      );
+
+      if (!implemented && !service._status) {
+        service._status = 'planned';
+      }
+    }
+
+    await this.save(sdm);
+    return changes;
+  }
+
+  /**
+   * Update tech stack summary from service
+   */
+  updateTechStackSummary(sdm, service) {
+    const { language, framework, database } = service.tech_stack;
+
+    if (language && !sdm.tech_stack.languages.includes(language)) {
+      sdm.tech_stack.languages.push(language);
+    }
+    if (framework && !sdm.tech_stack.frameworks.includes(framework)) {
+      sdm.tech_stack.frameworks.push(framework);
+    }
+    if (database && !sdm.tech_stack.databases.includes(database)) {
+      sdm.tech_stack.databases.push(database);
+    }
+  }
+}