refactor: Update documentation and comments to replace CDD principles with architectural principles

Author: Jeshua ben Joseph

.github/copilot-instructions.md

@@ -90,7 +90,7 @@ When run on a typical Rust project with placeholder code:
 Default configuration includes:
 - **Placeholders**: TODO/FIXME/HACK comments, unimplemented!/todo!/panic! macros
 - **Incomplete implementations**: Empty Ok(()) returns 
-- **Architectural violations**: Hardcoded paths, CDD header missing
+- **Architectural violations**: Hardcoded paths, architectural header missing
 - **Severity levels**: error (fails CI), warning (informational), info (suggestions)
 - **Path filtering**: Supports .gitignore-style patterns with include/exclude
 

Cargo.toml

@@ -2,7 +2,7 @@
 name = "rust-guardian"
 version = "0.1.0"
 edition = "2021"
-authors = ["ARIA Systems"]
+authors = ["The Rust Guardian Team"]
 description = "Dynamic code quality enforcement preventing incomplete or placeholder code"
 license = "MIT"
 repository = "https://github.com/cloudfunnels/rust-guardian"

README.md

@@ -387,7 +387,7 @@ Simplified format for automated processing and agent consumption:
 Placeholder comment detected: TODO
 
 [102:src/lib.rs]  
-Traditional tests violate CDD - consciousness architecture should be self-validating
+Traditional unit tests found - consider integration tests for better architectural validation
 
 [67:src/models.rs]
 Function returns Ok(()) with no meaningful implementation
@@ -619,7 +619,7 @@ Built with love for the craft of software development.
 
 Done and done.
 
-— ARIA Systems
+— The Rust Guardian Team
 
 ## Support
 

examples/guardian.yaml

@@ -106,15 +106,15 @@ patterns:
             - "**/core/**"
             - "**/tests/**"
 
-  # CDD compliance checking (optional)
-  cdd_compliance:
+  # Architectural compliance checking (optional)
+  architectural_compliance:
     severity: info
     enabled: false  # Disabled by default - enable per project
     rules:
-      - id: cdd_header_missing
+      - id: architectural_header_missing
         type: regex
-        pattern: '//!\s*.*\n(?:.*\n)*?\s*//!\s*CDD Principle:'
-        message: "File missing CDD principle header comment"
+        pattern: '//!\s*.*\n(?:.*\n)*?\s*//!\s*Architecture:'
+        message: "File missing architectural principle header comment"
         exclude_if:
           in_tests: true
           file_patterns:

guardian.yaml

@@ -118,15 +118,15 @@ patterns:
         message: "Magic number found: {match} - consider using a named constant"
         enabled: false
 
-# Test pattern violations for CDD compliance
+# Test pattern violations for architectural compliance
 test_patterns:
   severity: error
   enabled: true
   rules:
     - id: no_traditional_tests
       type: regex
       pattern: '(mod\s+tests?\s*\{|#\[test\]|#\[cfg\(test\)\])'
-      message: "Traditional tests violate CDD principles - use integration tests instead: {match}"
+      message: "Traditional unit tests found - consider integration tests for better architectural validation: {match}"
       severity: error
       case_sensitive: true
       exclude_if:

src/cache/mod.rs

@@ -1,6 +1,6 @@
 //! File hash caching for incremental checks
 //!
-//! CDD Principle: Infrastructure Layer - Cache provides performance optimization without affecting domain logic
+//! Architecture: Infrastructure Layer - Cache provides performance optimization without affecting domain logic
 //! - FileCache acts as a repository for file metadata and analysis results
 //! - Hash-based validation ensures cache coherence with minimal overhead
 //! - Domain objects remain pure while infrastructure handles caching concerns
@@ -402,7 +402,7 @@ fn current_timestamp() -> u64 {
 impl FileCache {
     /// Self-validation - Infrastructure validates its own coherence
     /// 
-    /// Guardian Principle: Self-validating architecture - Infrastructure components ensure their own correctness
+    /// Architecture Principle: Self-validating infrastructure - Components ensure their own correctness
     /// - Cache validates its invariants during normal operation
     /// - File hash verification maintains cache coherence
     /// - Metadata consistency checked on each operation
@@ -459,7 +459,7 @@ impl FileCache {
 
     /// Integrity verification during normal operations
     /// 
-    /// Guardian Principle: Continuous self-monitoring - Infrastructure monitors its own health
+    /// Architecture Principle: Continuous self-monitoring - Infrastructure monitors its own health
     fn verify_integrity_on_operation(&self) -> GuardianResult<()> {
         // Quick integrity checks that run during normal operations
         if self.data.version == 0 {

src/config/mod.rs

@@ -1,6 +1,6 @@
 //! Configuration loading and management for Rust Guardian
 //!
-//! CDD Principle: Anti-Corruption Layer - Configuration translates external YAML formats
+//! Architecture: Anti-Corruption Layer - Configuration translates external YAML formats
 //! - Raw YAML structures are converted to clean domain objects
 //! - Default configurations are embedded in the domain, not infrastructure
 //! - Configuration acts as a repository for pattern rules and path filters
@@ -243,10 +243,10 @@ impl GuardianConfig {
                         }),
                     },
                     PatternRule {
-                        id: "cdd_header_missing".to_string(),
+                        id: "architectural_header_missing".to_string(),
                         rule_type: RuleType::Regex,
-                        pattern: r"//!\s*(?:.*\n)*?\s*//!\s*CDD Principle:".to_string(),
-                        message: "File missing CDD principle header".to_string(),
+                        pattern: r"//!\s*(?:.*\n)*?\s*//!\s*Architecture:".to_string(),
+                        message: "File missing architectural principle header".to_string(),
                         severity: Some(Severity::Info),
                         enabled: false, // Disabled by default, can be enabled per project
                         case_sensitive: false,
@@ -454,7 +454,7 @@ impl Default for ConfigBuilder {
 }
 
 impl GuardianConfig {
-    /// Self-validating configuration integrity check following CDD principles
+    /// Self-validating configuration integrity check following architectural principles
     /// Guardian validates itself rather than relying on external tests
     pub fn verify_config_integrity(&self) -> GuardianResult<()> {
         // Domain validates its own consistency

src/domain/mod.rs

@@ -1,6 +1,6 @@
 //! Domain layer for Rust Guardian
 //!
-//! CDD Principle: Domain Model - Pure business logic for code quality enforcement
+//! Architecture: Domain Model - Pure business logic for code quality enforcement
 //! - Contains all core entities, value objects, and domain services
 //! - Independent of infrastructure concerns like databases, file systems, or external APIs
 //! - Expresses the ubiquitous language of code quality and violation detection

src/domain/violations.rs

@@ -1,6 +1,6 @@
 //! Core domain models for code quality violations and validation results
 //!
-//! CDD Principle: Rich Domain Models - Violations are entities with behavior, not just data
+//! Architecture: Rich Domain Models - Violations are entities with behavior, not just data
 //! - Violations can classify themselves, suggest fixes, and maintain context
 //! - ValidationReport acts as an aggregate root managing collections of violations
 //! - Domain events can be generated when patterns are detected or when validation completes

src/lib.rs

@@ -1,6 +1,6 @@
 //! Rust Guardian - Dynamic code quality enforcement for systems
 //!
-//! CDD Principle: Clean Architecture - Library interface serves as the application layer
+//! Architecture: Clean Architecture - Library interface serves as the application layer
 //! - Pure domain logic separated from infrastructure concerns
 //! - Clean boundaries between core business logic and external dependencies
 //! - Agent integration API provides validation workflows