moai-adk 0.25.4__py3-none-any.whl → 0.32.8__py3-none-any.whl

moai_adk/core/project/checker.py

@@ -258,12 +258,10 @@ def check_environment() -> dict[str, bool]:
         Mapping from check description to boolean status.
     """
     return {
-        "Python >= 3.13": sys.version_info >= (3, 13),
+        "Python >= 3.11": sys.version_info >= (3, 11),
         "Git installed": shutil.which("git") is not None,
         "Project structure (.moai/)": Path(".moai").exists(),
-        "Config file (.moai/config/config.json)": Path(
-            ".moai/config/config.json"
-        ).exists(),
+        "Config file (.moai/config/config.yaml)": Path(".moai/config/config.yaml").exists(),
     }
 
 

moai_adk/core/project/detector.py

@@ -212,9 +212,7 @@ class LanguageDetector:
 
         return None
 
-    def detect_build_tool(
-        self, path: str | Path = ".", language: str | None = None
-    ) -> str | None:
+    def detect_build_tool(self, path: str | Path = ".", language: str | None = None) -> str | None:
         """Detect the build tool for the detected language.
 
 

moai_adk/core/project/initializer.py

@@ -12,6 +12,7 @@ Phase-based 5-step initialization process:
 # type: ignore
 
 import json
+import stat
 import time
 from datetime import datetime
 from pathlib import Path
@@ -112,10 +113,63 @@ class ProjectInitializer:
 
         return created_files
 
+    def _create_user_settings(self) -> list[str]:
+        """Create user-specific settings files (.claude/settings.local.json)
+
+        Returns:
+            List of created settings files
+        """
+        created_files = []
+        claude_dir = self.path / ".claude"
+        claude_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create settings.local.json
+        settings_local = {
+            "_meta": {
+                "description": "User-specific Claude Code settings (gitignored - never commit)",
+                "created_at": datetime.now().isoformat() + "Z",
+                "note": "Edit this file to customize your local development environment",
+            },
+            "enabledMcpjsonServers": ["context7"],  # context7 is mandatory
+        }
+
+        # Add companyAnnouncements in user's selected language
+        try:
+            import sys
+
+            utils_dir = (
+                Path(__file__).parent.parent.parent / "templates" / ".claude" / "hooks" / "moai" / "shared" / "utils"
+            )
+
+            if utils_dir.exists():
+                sys.path.insert(0, str(utils_dir))
+                try:
+                    from announcement_translator import (
+                        get_language_from_config,
+                        translate_announcements,
+                    )
+
+                    language = get_language_from_config(self.path)
+                    announcements = translate_announcements(language, self.path)
+                    settings_local["companyAnnouncements"] = announcements
+                except Exception as e:
+                    print(f"[ProjectInitializer] Warning: Failed to add announcements: {e}")
+                finally:
+                    sys.path.remove(str(utils_dir))
+
+        except Exception as e:
+            print(f"[ProjectInitializer] Warning: Announcement module not available: {e}")
+
+        settings_local_file = claude_dir / "settings.local.json"
+        settings_local_file.write_text(json.dumps(settings_local, indent=2, ensure_ascii=False))
+        created_files.append(str(settings_local_file))
+
+        return created_files
+
     def initialize(
         self,
         mode: str = "personal",
-        locale: str = "en",  # Changed from "ko" to "en" (will be configurable in /alfred:0-project)
+        locale: str = "en",  # Changed from "ko" to "en" (will be configurable in /moai:0-project)
         language: str | None = None,
         custom_language: str | None = None,
         backup_enabled: bool = True,
@@ -125,9 +179,9 @@ class ProjectInitializer:
         """Execute project initialization (5-phase process)
 
         Args:
-            mode: Project mode (personal/team) - Default: personal (configurable in /alfred:0-project)
-            locale: Locale (ko/en/ja/zh/other) - Default: en (configurable in /alfred:0-project)
-            language: Force language specification (auto-detect if None) - Will be detected in /alfred:0-project
+            mode: Project mode (personal/team) - Default: personal (configurable in /moai:0-project)
+            locale: Locale (ko/en/ja/zh/other) - Default: en (configurable in /moai:0-project)
+            language: Force language specification (auto-detect if None) - Will be detected in /moai:0-project
             custom_language: Custom language name when locale="other" (user input)
             backup_enabled: Whether to enable backup
             progress_callback: Progress callback
@@ -150,13 +204,11 @@ class ProjectInitializer:
                 )
 
             # Use provided language or default to generic
-            # Language detection now happens in /alfred:0-project via project-manager
+            # Language detection now happens in /moai:0-project via project-manager
             detected_language = language or "generic"
 
             # Phase 1: Preparation (backup and validation)
-            self.executor.execute_preparation_phase(
-                self.path, backup_enabled, progress_callback
-            )
+            self.executor.execute_preparation_phase(self.path, backup_enabled, progress_callback)
 
             # Phase 2: Directory (create directories)
             self.executor.execute_directory_phase(self.path, progress_callback)
@@ -173,9 +225,22 @@ class ProjectInitializer:
             }
 
             # Phase 3: Resource (copy templates with variable substitution)
-            resource_files = self.executor.execute_resource_phase(
-                self.path, config, progress_callback
-            )
+            resource_files = self.executor.execute_resource_phase(self.path, config, progress_callback)
+
+            # Post-Phase 3: Fix shell script permissions
+            # git may not preserve file permissions, so explicitly set them
+            scripts_dir = self.path / ".moai" / "scripts"
+            if scripts_dir.exists():
+                for script_file in scripts_dir.glob("*.sh"):
+                    try:
+                        current_mode = script_file.stat().st_mode
+                        new_mode = current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+                        # On Windows, chmod has limited effect, but we try anyway
+                        # or check os.name != 'nt' if strict behavior is needed.
+                        # For now, we just apply it and ignore errors if it fails.
+                        script_file.chmod(new_mode)
+                    except Exception:
+                        pass  # Silently ignore permission errors
 
             # Phase 4: Configuration (generate config.json)
             # Handle language configuration
@@ -187,10 +252,10 @@ class ProjectInitializer:
                 }
             elif locale in ["ko", "en", "ja", "zh"]:
                 language_names = {
-                    "ko": "한국어",
+                    "ko": "Korean",
                     "en": "English",
-                    "ja": "日本語",
-                    "zh": "中文",
+                    "ja": "Japanese",
+                    "zh": "Chinese",
                 }
                 language_config = {
                     "conversation_language": locale,
@@ -209,20 +274,66 @@ class ProjectInitializer:
                     "mode": mode,
                     "locale": locale,
                     "language": detected_language,
-                    # Language detection metadata (will be updated by project-manager via /alfred:0-project)
+                    # Language detection metadata (will be updated by project-manager via /moai:0-project)
                     "language_detection": {
                         "detected_language": detected_language,
-                        "detection_method": "cli_default",  # Will be "context_aware" after /alfred:0-project
+                        "detection_method": "cli_default",  # Will be "context_aware" after /moai:0-project
                         "confidence": None,  # Will be calculated by project-manager
                         "markers": [],  # Will be populated by project-manager
                         "confirmed_by": None,  # Will be "user" after project-manager confirmation
                     },
                 },
                 "language": language_config,
+                "constitution": {
+                    "enforce_tdd": True,
+                    "principles": {
+                        "simplicity": {
+                            "max_projects": 5,
+                            "notes": "Default recommendation. Adjust in .moai/config.json "
+                            "or via SPEC/ADR with documented rationale based on project size.",
+                        }
+                    },
+                    "test_coverage_target": 90,
+                },
+                "git_strategy": {
+                    "personal": {
+                        "auto_checkpoint": "disabled",
+                        "checkpoint_events": [
+                            "delete",
+                            "refactor",
+                            "merge",
+                            "script",
+                            "critical-file",
+                        ],
+                        "checkpoint_type": "local-branch",
+                        "max_checkpoints": 10,
+                        "cleanup_days": 7,
+                        "push_to_remote": False,
+                        "auto_commit": True,
+                        "branch_prefix": "feature/SPEC-",
+                        "develop_branch": "develop",
+                        "main_branch": "main",
+                        "prevent_branch_creation": False,
+                        "work_on_main": False,
+                    },
+                    "team": {
+                        "auto_pr": False,
+                        "develop_branch": "develop",
+                        "draft_pr": False,
+                        "feature_prefix": "feature/SPEC-",
+                        "main_branch": "main",
+                        "use_gitflow": True,
+                        "default_pr_base": "develop",
+                        "prevent_main_direct_merge": False,
+                    },
+                },
+                "session": {
+                    "suppress_setup_messages": False,
+                    "notes": "suppress_setup_messages: false enables SessionStart output. "
+                    "Set to true to suppress messages (show again after 7 days)",
+                },
             }
-            config_files = self.executor.execute_configuration_phase(
-                self.path, config_data, progress_callback
-            )
+            config_files = self.executor.execute_configuration_phase(self.path, config_data, progress_callback)
 
             # Phase 5: Validation (verify and finalize)
             self.executor.execute_validation_phase(self.path, mode, progress_callback)
@@ -230,6 +341,9 @@ class ProjectInitializer:
             # Phase 6: Create runtime memory files (auto-generated per user/session)
             memory_files = self._create_memory_files()
 
+            # Phase 7: Create user settings (gitignored, user-specific)
+            user_settings_files = self._create_user_settings()
+
             # Generate result
             duration = int((time.time() - start_time) * 1000)  # ms
             return InstallationResult(
@@ -239,7 +353,7 @@ class ProjectInitializer:
                 mode=mode,
                 locale=locale,
                 duration=duration,
-                created_files=resource_files + config_files + memory_files,
+                created_files=resource_files + config_files + memory_files + user_settings_files,
             )
 
         except Exception as e:
@@ -264,9 +378,7 @@ class ProjectInitializer:
         return (self.path / ".moai").exists()
 
 
-def initialize_project(
-    project_path: Path, progress_callback: ProgressCallback | None = None
-) -> InstallationResult:
+def initialize_project(project_path: Path, progress_callback: ProgressCallback | None = None) -> InstallationResult:
     """Initialize project (for CLI command)
 
     Args:

moai_adk/core/project/phase_executor.py

@@ -109,24 +109,12 @@ class PhaseExecutor:
 
             # Enhanced version context with multiple format options
             version_context["MOAI_VERSION"] = moai_version
-            version_context["MOAI_VERSION_SHORT"] = self._format_short_version(
-                moai_version
-            )
-            version_context["MOAI_VERSION_DISPLAY"] = self._format_display_version(
-                moai_version
-            )
-            version_context["MOAI_VERSION_TRIMMED"] = self._format_trimmed_version(
-                moai_version, max_length=10
-            )
-            version_context["MOAI_VERSION_SEMVER"] = self._format_semver_version(
-                moai_version
-            )
-            version_context["MOAI_VERSION_VALID"] = (
-                "true" if moai_version != "unknown" else "false"
-            )
-            version_context["MOAI_VERSION_SOURCE"] = self._get_version_source(
-                version_reader
-            )
+            version_context["MOAI_VERSION_SHORT"] = self._format_short_version(moai_version)
+            version_context["MOAI_VERSION_DISPLAY"] = self._format_display_version(moai_version)
+            version_context["MOAI_VERSION_TRIMMED"] = self._format_trimmed_version(moai_version, max_length=10)
+            version_context["MOAI_VERSION_SEMVER"] = self._format_semver_version(moai_version)
+            version_context["MOAI_VERSION_VALID"] = "true" if moai_version != "unknown" else "false"
+            version_context["MOAI_VERSION_SOURCE"] = self._get_version_source(version_reader)
 
             # Add performance metrics for debugging
             cache_age = version_reader.get_cache_age_seconds()
@@ -140,18 +128,10 @@ class PhaseExecutor:
             # Use fallback version with comprehensive fallback formatting
             fallback_version = __version__
             version_context["MOAI_VERSION"] = fallback_version
-            version_context["MOAI_VERSION_SHORT"] = self._format_short_version(
-                fallback_version
-            )
-            version_context["MOAI_VERSION_DISPLAY"] = self._format_display_version(
-                fallback_version
-            )
-            version_context["MOAI_VERSION_TRIMMED"] = self._format_trimmed_version(
-                fallback_version, max_length=10
-            )
-            version_context["MOAI_VERSION_SEMVER"] = self._format_semver_version(
-                fallback_version
-            )
+            version_context["MOAI_VERSION_SHORT"] = self._format_short_version(fallback_version)
+            version_context["MOAI_VERSION_DISPLAY"] = self._format_display_version(fallback_version)
+            version_context["MOAI_VERSION_TRIMMED"] = self._format_trimmed_version(fallback_version, max_length=10)
+            version_context["MOAI_VERSION_SEMVER"] = self._format_semver_version(fallback_version)
             version_context["MOAI_VERSION_VALID"] = "true"
             version_context["MOAI_VERSION_SOURCE"] = "fallback_package"
             version_context["MOAI_VERSION_CACHE_AGE"] = "unavailable"
@@ -292,9 +272,7 @@ class PhaseExecutor:
             progress_callback: Optional progress callback.
         """
         self.current_phase = 2
-        self._report_progress(
-            "Phase 2: Creating directory structure...", progress_callback
-        )
+        self._report_progress("Phase 2: Creating directory structure...", progress_callback)
 
         for directory in self.REQUIRED_DIRECTORIES:
             dir_path = project_path / directory
@@ -316,6 +294,8 @@ class PhaseExecutor:
         Returns:
             List of created files or directories.
         """
+        import stat
+
         self.current_phase = 3
         self._report_progress("Phase 3: Installing resources...", progress_callback)
 
@@ -329,11 +309,7 @@ class PhaseExecutor:
                 language_config = {}
 
             # Detect OS for cross-platform Hook path configuration
-            hook_project_dir = (
-                "%CLAUDE_PROJECT_DIR%"
-                if platform.system() == "Windows"
-                else "$CLAUDE_PROJECT_DIR"
-            )
+            hook_project_dir = "%CLAUDE_PROJECT_DIR%" if platform.system() == "Windows" else "$CLAUDE_PROJECT_DIR"
 
             # Get enhanced version context with fallback strategies
             version_context = self._get_enhanced_version_context()
@@ -347,20 +323,32 @@ class PhaseExecutor:
                 "PROJECT_VERSION": config.get("version", "0.1.0"),
                 "PROJECT_OWNER": config.get("author", "@user"),
                 "AUTHOR": config.get("author", "@user"),
-                "CONVERSATION_LANGUAGE": language_config.get(
-                    "conversation_language", "en"
-                ),
-                "CONVERSATION_LANGUAGE_NAME": language_config.get(
-                    "conversation_language_name", "English"
-                ),
+                "CONVERSATION_LANGUAGE": language_config.get("conversation_language", "en"),
+                "CONVERSATION_LANGUAGE_NAME": language_config.get("conversation_language_name", "English"),
                 "CODEBASE_LANGUAGE": config.get("language", "generic"),
                 "PROJECT_DIR": hook_project_dir,
             }
             processor.set_context(context)
 
-        processor.copy_templates(
-            backup=False, silent=True
-        )  # Avoid progress bar conflicts
+        processor.copy_templates(backup=False, silent=True)  # Avoid progress bar conflicts
+
+        # Post-process: Set executable permission on shell scripts
+        # This is necessary because git may not preserve file permissions during clone/checkout
+        scripts_dir = project_path / ".moai" / "scripts"
+        logger = logging.getLogger(__name__)
+        if scripts_dir.exists():
+            logger.debug(f"Processing shell scripts in {scripts_dir}")
+            for script_file in scripts_dir.glob("*.sh"):
+                try:
+                    # Add execute permission for user, group, and others
+                    current_mode = script_file.stat().st_mode
+                    new_mode = current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+                    script_file.chmod(new_mode)
+                    logger.debug(f"Set executable permission on {script_file}: {oct(current_mode)} -> {oct(new_mode)}")
+                except Exception as e:
+                    logger.warning(f"Failed to set executable permission on {script_file}: {e}")
+        else:
+            logger.debug(f"Scripts directory not found: {scripts_dir}")
 
         # Return a simplified list of generated assets
         return [
@@ -388,9 +376,7 @@ class PhaseExecutor:
             List of created files.
         """
         self.current_phase = 4
-        self._report_progress(
-            "Phase 4: Generating configurations...", progress_callback
-        )
+        self._report_progress("Phase 4: Generating configurations...", progress_callback)
 
         logger = logging.getLogger(__name__)
 
@@ -407,9 +393,7 @@ class PhaseExecutor:
                 existing_config = {}
 
         # Enhanced config merging with comprehensive version preservation
-        merged_config = self._merge_configuration_preserving_versions(
-            config, existing_config
-        )
+        merged_config = self._merge_configuration_preserving_versions(config, existing_config)
 
         # Enhanced version handling using VersionReader for consistency
         try:
@@ -417,17 +401,11 @@ class PhaseExecutor:
             current_config_version = version_reader.get_version()
 
             # Ensure version consistency across the merged config
-            self._ensure_version_consistency(
-                merged_config, current_config_version, existing_config
-            )
+            self._ensure_version_consistency(merged_config, current_config_version, existing_config)
 
-            logger.debug(
-                f"Version consistency check completed. Current version: {current_config_version}"
-            )
+            logger.debug(f"Version consistency check completed. Current version: {current_config_version}")
         except Exception as e:
-            logger.warning(
-                f"Version consistency check failed: {e}. Using fallback version."
-            )
+            logger.warning(f"Version consistency check failed: {e}. Using fallback version.")
             merged_config["moai"]["version"] = __version__
 
         # Write final config with enhanced formatting
@@ -467,9 +445,7 @@ class PhaseExecutor:
         for section_name, strategy in config_sections.items():
             if section_name in existing_config:
                 logger.debug(f"Merging section: {section_name}")
-                self._merge_config_section(
-                    merged_config, existing_config, section_name, strategy
-                )
+                self._merge_config_section(merged_config, existing_config, section_name, strategy)
 
         return merged_config
 
@@ -553,12 +529,8 @@ class PhaseExecutor:
         elif "version" in config_moai:
             # Version already in new config, validate it
             config_version = config_moai["version"]
-            if config_version == "unknown" or not self._is_valid_version_format(
-                config_version
-            ):
-                logger.debug(
-                    f"Invalid config version {config_version}, updating to current: {current_version}"
-                )
+            if config_version == "unknown" or not self._is_valid_version_format(config_version):
+                logger.debug(f"Invalid config version {config_version}, updating to current: {current_version}")
                 config_moai["version"] = current_version
         else:
             # No version found, use current version
@@ -580,9 +552,7 @@ class PhaseExecutor:
         pattern = r"^v?(\d+\.\d+\.\d+(-[a-zA-Z0-9]+)?)$"
         return bool(re.match(pattern, version))
 
-    def _write_configuration_file(
-        self, config_path: Path, config: dict[str, Any]
-    ) -> None:
+    def _write_configuration_file(self, config_path: Path, config: dict[str, Any]) -> None:
         """
         Write configuration file with enhanced formatting and error handling.
 
@@ -621,9 +591,7 @@ class PhaseExecutor:
             progress_callback: Optional progress callback.
         """
         self.current_phase = 5
-        self._report_progress(
-            "Phase 5: Validation and finalization...", progress_callback
-        )
+        self._report_progress("Phase 5: Validation and finalization...", progress_callback)
 
         # Validate installation results
         # Comprehensive installation validation
@@ -631,9 +599,8 @@ class PhaseExecutor:
         # - 0-project.md, 1-plan.md, 2-run.md, 3-sync.md
         self.validator.validate_installation(project_path)
 
-        # Initialize Git for team mode
-        if mode == "team":
-            self._initialize_git(project_path)
+        # Initialize Git for all modes (team, personal, solo)
+        self._initialize_git(project_path)
 
     def _create_backup(self, project_path: Path) -> None:
         """Create a single backup (v0.4.2).
@@ -698,11 +665,17 @@ class PhaseExecutor:
                 dst_item.mkdir(parents=True, exist_ok=True)
 
     def _initialize_git(self, project_path: Path) -> None:
-        """Initialize a Git repository.
+        """Initialize a Git repository if not already initialized.
 
         Args:
             project_path: Project path.
         """
+        # Check if .git directory already exists
+        git_dir = project_path / ".git"
+        if git_dir.exists() and git_dir.is_dir():
+            # Git already initialized, skip
+            return
+
         try:
             subprocess.run(
                 ["git", "init"],

moai_adk/core/project/validator.py

@@ -33,7 +33,7 @@ class ProjectValidator:
 
     # Required files
     REQUIRED_FILES = [
-        ".moai/config/config.json",
+        ".moai/config/config.yaml",
         "CLAUDE.md",
     ]
 
@@ -59,9 +59,7 @@ class ProjectValidator:
         import sys
 
         if sys.version_info < (3, 10):
-            raise ValidationError(
-                f"Python 3.10+ required (current: {sys.version_info.major}.{sys.version_info.minor})"
-            )
+            raise ValidationError(f"Python 3.10+ required (current: {sys.version_info.major}.{sys.version_info.minor})")
 
     def validate_project_path(self, project_path: Path) -> None:
         """Verify the project path.
@@ -78,9 +76,7 @@ class ProjectValidator:
 
         # Parent directory must exist
         if not project_path.parent.exists():
-            raise ValidationError(
-                f"Parent directory does not exist: {project_path.parent}"
-            )
+            raise ValidationError(f"Parent directory does not exist: {project_path.parent}")
 
         # Prevent initialization inside the MoAI-ADK package
         if self._is_inside_moai_package(project_path):
@@ -108,18 +104,16 @@ class ProjectValidator:
             if not file_path.exists():
                 raise ValidationError(f"Required file not found: {file}")
 
-        alfred_dir = project_path / ".claude" / "commands" / "alfred"
+        moai_commands_dir = project_path / ".claude" / "commands" / "moai"
         missing_commands = []
         for cmd in self.REQUIRED_ALFRED_COMMANDS:
-            cmd_path = alfred_dir / cmd
+            cmd_path = moai_commands_dir / cmd
             if not cmd_path.exists():
                 missing_commands.append(cmd)
 
         if missing_commands:
             missing_list = ", ".join(missing_commands)
-            raise ValidationError(
-                f"Required Alfred command files not found: {missing_list}"
-            )
+            raise ValidationError(f"Required Alfred command files not found: {missing_list}")
 
     def _is_inside_moai_package(self, project_path: Path) -> bool:
         """Determine whether the path is inside the MoAI-ADK package.

moai_adk/core/quality/trust_checker.py

@@ -43,9 +43,7 @@ class TrustChecker:
     # T: Test First - Coverage Validation
     # ========================================
 
-    def validate_coverage(
-        self, project_path: Path, coverage_data: dict[str, Any]
-    ) -> ValidationResult:
+    def validate_coverage(self, project_path: Path, coverage_data: dict[str, Any]) -> ValidationResult:
         """
         Validate test coverage (≥85%)
 
@@ -119,9 +117,7 @@ class TrustChecker:
                 loc = len(lines)
 
                 if loc > MAX_FILE_LINES_OF_CODE:
-                    violations.append(
-                        f"{py_file.name}: {loc} LOC (Limit: {MAX_FILE_LINES_OF_CODE})"
-                    )
+                    violations.append(f"{py_file.name}: {loc} LOC (Limit: {MAX_FILE_LINES_OF_CODE})")
             except (UnicodeDecodeError, PermissionError):
                 # Security: handle file access errors
                 continue
@@ -129,9 +125,7 @@ class TrustChecker:
         if not violations:
             return ValidationResult(passed=True, message="All files within 300 LOC")
 
-        details = "Files exceeding 300 LOC:\n" + "\n".join(
-            f"  - {v}" for v in violations
-        )
+        details = "Files exceeding 300 LOC:\n" + "\n".join(f"  - {v}" for v in violations)
         details += "\n\nRecommended: Refactor large files into smaller modules."
 
         return ValidationResult(
@@ -181,9 +175,7 @@ class TrustChecker:
         if not violations:
             return ValidationResult(passed=True, message="All functions within 50 LOC")
 
-        details = "Functions exceeding 50 LOC:\n" + "\n".join(
-            f"  - {v}" for v in violations
-        )
+        details = "Functions exceeding 50 LOC:\n" + "\n".join(f"  - {v}" for v in violations)
         details += "\n\nRecommended: Extract complex functions into smaller ones."
 
         return ValidationResult(
@@ -222,13 +214,9 @@ class TrustChecker:
                 continue
 
         if not violations:
-            return ValidationResult(
-                passed=True, message="All functions within 5 parameters"
-            )
+            return ValidationResult(passed=True, message="All functions within 5 parameters")
 
-        details = "Functions exceeding 5 parameters:\n" + "\n".join(
-            f"  - {v}" for v in violations
-        )
+        details = "Functions exceeding 5 parameters:\n" + "\n".join(f"  - {v}" for v in violations)
         details += "\n\nRecommended: Use data classes or parameter objects."
 
         return ValidationResult(
@@ -267,13 +255,9 @@ class TrustChecker:
                 continue
 
         if not violations:
-            return ValidationResult(
-                passed=True, message="All functions within complexity 10"
-            )
+            return ValidationResult(passed=True, message="All functions within complexity 10")
 
-        details = "Functions exceeding complexity 10:\n" + "\n".join(
-            f"  - {v}" for v in violations
-        )
+        details = "Functions exceeding complexity 10:\n" + "\n".join(f"  - {v}" for v in violations)
         details += "\n\nRecommended: Simplify complex logic using guard clauses."
 
         return ValidationResult(
@@ -295,9 +279,7 @@ class TrustChecker:
         complexity = 1
         for child in ast.walk(node):
             # Add 1 for each branching statement
-            if isinstance(
-                child, (ast.If, ast.While, ast.For, ast.ExceptHandler, ast.With)
-            ):
+            if isinstance(child, (ast.If, ast.While, ast.For, ast.ExceptHandler, ast.With)):
                 complexity += 1
             # Add 1 for each and/or operator
             elif isinstance(child, ast.BoolOp):