moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/core/template/processor.py

@@ -85,7 +85,8 @@ class TemplateProcessor:
         ".moai/specs/",  # User SPEC documents
         ".moai/reports/",  # User reports
         ".moai/project/",  # User project documents (product/structure/tech.md)
-        # config.json is now FORCE OVERWRITTEN (backup in .moai-backups/)
+        ".moai/config/sections/",  # User configuration section files (YAML)
+        # config.json/config.yaml is now FORCE OVERWRITTEN (backup in .moai-backups/)
         # Merge via /moai:0-project when optimized=false
     ]
 
@@ -107,6 +108,7 @@ class TemplateProcessor:
         "MOAI_VERSION_SOURCE": "Version source information",
         "MOAI_VERSION_CACHE_AGE": "Cache age for debugging",
         "CREATION_TIMESTAMP": "Project creation timestamp",
+        "STATUSLINE_COMMAND": "Cross-platform statusline command (OS-specific)",
     }
 
     def __init__(self, target_path: Path, config: Optional[TemplateProcessorConfig] = None) -> None:
@@ -173,6 +175,31 @@ class TemplateProcessor:
                 self.logger.info("VersionReader created with enhanced configuration")
         return self._version_reader
 
+    def _get_current_version(self) -> Optional[str]:
+        """
+        Get the current MoAI-ADK package version.
+
+        Returns:
+            Current version string, or None if version cannot be determined
+        """
+        try:
+            version_reader = self._get_version_reader()
+            version = version_reader.get_version()
+            if version and version != "unknown":
+                return version
+        except Exception as e:
+            self.logger.warning(f"Failed to get current version: {e}")
+
+        # Fallback: try direct import
+        try:
+            from moai_adk import __version__
+
+            return __version__
+        except ImportError:
+            pass
+
+        return None
+
     def _validate_template_variables(self, context: Dict[str, str]) -> None:
         """
         Validate template variables with comprehensive checking.
@@ -718,6 +745,7 @@ class TemplateProcessor:
 
         self._copy_claude(silent)
         self._copy_moai(silent)
+        self._sync_new_section_files(silent)  # Add new section files from template
         self._copy_github(silent)
         self._copy_claude_md(silent)
         self._copy_gitignore(silent)
@@ -800,7 +828,7 @@ class TemplateProcessor:
             "output-styles/moai",
             "agents/alfred",
             "agents/moai",
-            "skills",  # NEW: Complete replacement for skills folder
+            # NOTE: "skills" handled by _sync_skills_selective() to preserve custom skills
         ]
 
         # 1. Copy Alfred and Moai folders wholesale (backup before delete & overwrite)
@@ -847,6 +875,9 @@ class TemplateProcessor:
                 if not silent:
                     console.print(f"   ✅ .claude/{rel_subdir}/ copied")
 
+        # 1.6 Sync skills selectively (preserve custom skills, update moai-* skills)
+        self._sync_skills_selective(src, dst, silent)
+
         # 2. Copy other files/folders individually (smart merge for settings.json and config.json)
         all_warnings = []
         for item in src.iterdir():
@@ -854,11 +885,13 @@ class TemplateProcessor:
             dst_item = dst / rel_path
 
             # Skip Alfred parent folders (already handled above)
+            # Also skip "skills" - handled by _sync_skills_selective()
             if item.is_dir() and item.name in [
                 "hooks",
                 "commands",
                 "output-styles",
                 "agents",
+                "skills",  # Handled by _sync_skills_selective() to preserve custom skills
             ]:
                 continue
 
@@ -896,6 +929,54 @@ class TemplateProcessor:
         if not silent:
             console.print("   ✅ .claude/ copy complete (variables substituted)")
 
+    def _sync_skills_selective(self, src: Path, dst: Path, silent: bool = False) -> None:
+        """Sync only moai-* template skills, preserve custom skills.
+
+        This method ensures that:
+        - Template skills (moai-* prefix) are updated from source
+        - Custom skills (any other prefix) are preserved untouched
+
+        Args:
+            src: Source .claude directory from template
+            dst: Destination .claude directory in project
+            silent: Suppress console output if True
+        """
+        skills_src = src / "skills"
+        skills_dst = dst / "skills"
+
+        if not skills_src.exists():
+            return
+
+        skills_dst.mkdir(parents=True, exist_ok=True)
+
+        # Step 1: Identify template skills in source (moai-* prefix)
+        template_skills = {d.name for d in skills_src.iterdir() if d.is_dir() and d.name.startswith("moai-")}
+
+        # Step 2: Delete only template skills in destination
+        if skills_dst.exists():
+            for skill_dir in list(skills_dst.iterdir()):
+                if skill_dir.is_dir() and skill_dir.name.startswith("moai-"):
+                    shutil.rmtree(skill_dir)
+                    if not silent:
+                        console.print(f"   [dim]Updating template skill: {skill_dir.name}[/dim]")
+
+        # Step 3: Copy template skills from source
+        for skill_name in sorted(template_skills):
+            src_skill = skills_src / skill_name
+            dst_skill = skills_dst / skill_name
+            shutil.copytree(src_skill, dst_skill)
+
+        if not silent and template_skills:
+            console.print(f"   ✅ Synced {len(template_skills)} template skill(s)")
+
+        # Step 4: Report preserved custom skills
+        if skills_dst.exists():
+            custom_skills = [d.name for d in skills_dst.iterdir() if d.is_dir() and not d.name.startswith("moai-")]
+            if custom_skills and not silent:
+                preview = ", ".join(sorted(custom_skills)[:3])
+                suffix = "..." if len(custom_skills) > 3 else ""
+                console.print(f"   ✅ Preserved {len(custom_skills)} custom skill(s): {preview}{suffix}")
+
     def _copy_moai(self, silent: bool = False) -> None:
         """.moai/ directory copy with variable substitution (excludes protected paths)."""
         src = self.template_root / ".moai"
@@ -906,11 +987,11 @@ class TemplateProcessor:
                 console.print("⚠️ .moai/ template not found")
             return
 
-        # Paths excluded from template copying (specs/, reports/, .moai/config/config.json)
+        # Paths excluded from template copying (specs/, reports/, sections/)
         template_protected_paths = [
             "specs",
             "reports",
-            ".moai/config/config.json",
+            "config/sections",  # User section YAML files
         ]
 
         all_warnings = []
@@ -943,6 +1024,132 @@ class TemplateProcessor:
         if not silent:
             console.print("   ✅ .moai/ copy complete (variables substituted)")
 
+    def _deep_merge_dicts(self, base: dict, overlay: dict) -> tuple[dict, list[str]]:
+        """Deep merge two dictionaries, preserving base values and adding new keys from overlay.
+
+        Args:
+            base: User's existing configuration (values to preserve)
+            overlay: Template configuration (new keys to add)
+
+        Returns:
+            Tuple of (merged dict, list of new keys added)
+        """
+        result = base.copy()
+        new_keys = []
+
+        for key, value in overlay.items():
+            if key not in result:
+                # New key: add from template
+                result[key] = value
+                new_keys.append(key)
+            elif isinstance(value, dict) and isinstance(result.get(key), dict):
+                # Both are dicts: recurse
+                merged, nested_new = self._deep_merge_dicts(result[key], value)
+                result[key] = merged
+                new_keys.extend([f"{key}.{k}" for k in nested_new])
+            # else: key exists in base, preserve user's value
+
+        return result, new_keys
+
+    def _sync_new_section_files(self, silent: bool = False) -> None:
+        """Sync section files from template to project with smart merge.
+
+        This method handles section file synchronization with the following logic:
+        - New files (template has, project doesn't): Copy from template
+        - Existing files: Smart merge (preserve user values, add new fields)
+        - system.yaml: Always update moai.version to current package version
+
+        Smart Merge Behavior:
+        - User values are NEVER overwritten
+        - Only new keys/fields from template are added
+        - Nested structures are recursively merged
+        """
+        template_sections = self.template_root / ".moai" / "config" / "sections"
+        project_sections = self.target_path / ".moai" / "config" / "sections"
+
+        if not template_sections.exists():
+            return
+
+        # Ensure project sections directory exists
+        project_sections.mkdir(parents=True, exist_ok=True)
+
+        # Get current package version
+        try:
+            from moai_adk import __version__
+
+            current_version = __version__
+        except ImportError:
+            current_version = None
+
+        new_files_added = []
+        files_updated = []
+
+        import yaml
+
+        for template_file in template_sections.glob("*.yaml"):
+            project_file = project_sections / template_file.name
+
+            if not project_file.exists():
+                # New file: copy with variable substitution
+                self._copy_file_with_substitution(template_file, project_file)
+                new_files_added.append(template_file.name)
+            else:
+                # Existing file: smart merge (add new fields only)
+                try:
+                    # Load template data
+                    template_content = template_file.read_text(encoding="utf-8")
+                    template_data = yaml.safe_load(template_content) or {}
+
+                    # Load project data (user's current values)
+                    project_content = project_file.read_text(encoding="utf-8")
+                    project_data = yaml.safe_load(project_content) or {}
+
+                    # Deep merge: preserve user values, add new template keys
+                    merged_data, new_keys = self._deep_merge_dicts(project_data, template_data)
+
+                    if new_keys:
+                        # Write merged data back
+                        with open(project_file, "w", encoding="utf-8") as f:
+                            yaml.dump(
+                                merged_data,
+                                f,
+                                default_flow_style=False,
+                                allow_unicode=True,
+                                sort_keys=False,
+                            )
+                        files_updated.append(f"{template_file.name} (+{len(new_keys)} fields)")
+
+                except Exception:
+                    pass  # Silently ignore yaml errors for individual files
+
+        # Update system.yaml version (special case: always update version)
+        system_yaml = project_sections / "system.yaml"
+        if system_yaml.exists() and current_version:
+            try:
+                content = system_yaml.read_text(encoding="utf-8")
+                data = yaml.safe_load(content) or {}
+
+                # Update moai.version
+                if "moai" not in data:
+                    data["moai"] = {}
+                if data.get("moai", {}).get("version") != current_version:
+                    data["moai"]["version"] = current_version
+
+                    # Write back
+                    with open(system_yaml, "w", encoding="utf-8") as f:
+                        yaml.dump(data, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+
+                    if not silent:
+                        console.print(f"   🔄 system.yaml version updated to {current_version}")
+            except Exception:
+                pass  # Silently ignore yaml errors
+
+        if new_files_added and not silent:
+            console.print(f"   ✨ New section files added: {', '.join(new_files_added)}")
+
+        if files_updated and not silent:
+            console.print(f"   🔀 Section files updated: {', '.join(files_updated)}")
+
     def _copy_github(self, silent: bool = False) -> None:
         """.github/ directory copy with smart merge (preserves user workflows)."""
         src = self.template_root / ".github"
@@ -964,8 +1171,28 @@ class TemplateProcessor:
             console.print("   🔄 .github/ merged (user workflows preserved, variables substituted)")
 
     def _copy_claude_md(self, silent: bool = False) -> None:
-        """Copy CLAUDE.md with complete replacement (no merge)."""
-        src = self.template_root / "CLAUDE.md"
+        """Copy CLAUDE.md with complete replacement (no merge).
+
+        Selects language-specific CLAUDE.md based on conversation_language setting:
+        - CLAUDE.ko.md for Korean
+        - CLAUDE.ja.md for Japanese
+        - CLAUDE.zh.md for Chinese
+        - CLAUDE.md for English (default)
+        """
+        # Get language from context (set by set_context())
+        language = self.context.get("CONVERSATION_LANGUAGE", "en") if self.context else "en"
+
+        # Select language-specific file
+        if language and language != "en":
+            lang_specific_src = self.template_root / f"CLAUDE.{language}.md"
+            if lang_specific_src.exists():
+                src = lang_specific_src
+            else:
+                # Fallback to English if language-specific file doesn't exist
+                src = self.template_root / "CLAUDE.md"
+        else:
+            src = self.template_root / "CLAUDE.md"
+
         dst = self.target_path / "CLAUDE.md"
 
         if not src.exists():
@@ -1015,14 +1242,34 @@ class TemplateProcessor:
         self.merger.merge_settings_json(src, dst, backup_path)
 
     def _merge_config_json(self, src: Path, dst: Path) -> None:
-        """Smart merge for config.json using LanguageConfigResolver priority system.
+        """Smart merge for config using section YAML files with JSON fallback.
+
+        Supports both new section-based YAML files and legacy config.json.
+        Priority: Section YAML files > config.json fallback
 
         Args:
-            src: Template config.json.
-            dst: Project config.json.
+            src: Template config file (config.json for legacy projects).
+            dst: Project config file destination.
         """
         import json
+        import os
 
+        try:
+            import yaml  # noqa: F401 # pyright: ignore[reportUnusedImport]
+
+            yaml_available = True
+        except ImportError:
+            yaml_available = False
+
+        # Check for section-based YAML configuration (new approach)
+        sections_dir = self.target_path / ".moai" / "config" / "sections"
+
+        if yaml_available and sections_dir.exists() and sections_dir.is_dir():
+            # Use section YAML files - merge each section individually
+            self._merge_section_yaml_files(sections_dir)
+            return
+
+        # Fallback to legacy config.json merging
         # Load template config
         try:
             template_config = json.loads(src.read_text(encoding="utf-8"))
@@ -1071,8 +1318,6 @@ class TemplateProcessor:
                         merged_config[key] = value
 
             # Apply environment variables (highest priority)
-            import os
-
             env_mappings = {
                 "MOAI_USER_NAME": ("user", "name"),
                 "MOAI_CONVERSATION_LANG": ("language", "conversation_language"),
@@ -1119,6 +1364,84 @@ class TemplateProcessor:
             )
             console.print("   ⚠️ Warning: Using simple merge (LanguageConfigResolver not available)")
 
+    def _merge_section_yaml_files(self, sections_dir: Path) -> None:
+        """Merge section YAML files with user-specific values preserved.
+
+        Args:
+            sections_dir: Path to sections directory (.moai/config/sections/)
+        """
+        import os
+
+        try:
+            import yaml
+        except ImportError:
+            console.print("⚠️ Warning: PyYAML not available, skipping section merge")
+            return
+
+        # Get current package version for system.yaml update
+        current_version = self._get_current_version()
+
+        # Environment variable mappings for each section
+        env_mappings = {
+            "language.yaml": {
+                "MOAI_CONVERSATION_LANG": ["language", "conversation_language"],
+                "MOAI_AGENT_PROMPT_LANG": ["language", "agent_prompt_language"],
+                "MOAI_CONVERSATION_LANG_NAME": ["language", "conversation_language_name"],
+                "MOAI_GIT_COMMIT_MESSAGES_LANG": ["language", "git_commit_messages"],
+                "MOAI_CODE_COMMENTS_LANG": ["language", "code_comments"],
+                "MOAI_DOCUMENTATION_LANG": ["language", "documentation"],
+                "MOAI_ERROR_MESSAGES_LANG": ["language", "error_messages"],
+            },
+            "user.yaml": {
+                "MOAI_USER_NAME": ["user", "name"],
+            },
+        }
+
+        for section_file in sections_dir.glob("*.yaml"):
+            try:
+                # Read existing section content
+                with open(section_file, "r", encoding="utf-8") as f:
+                    section_data = yaml.safe_load(f) or {}
+
+                modified = False
+
+                # Update system.yaml version to current package version
+                if section_file.name == "system.yaml" and current_version:
+                    if "moai" not in section_data:
+                        section_data["moai"] = {}
+                    if section_data.get("moai", {}).get("version") != current_version:
+                        section_data["moai"]["version"] = current_version
+                        modified = True
+
+                # Apply environment variable overrides if applicable
+                if section_file.name in env_mappings:
+                    for env_var, path in env_mappings[section_file.name].items():
+                        env_value = os.getenv(env_var)
+                        if env_value:
+                            # Navigate to the correct nested location
+                            current = section_data
+                            for key in path[:-1]:
+                                if key not in current:
+                                    current[key] = {}
+                                current = current[key]
+                            if current.get(path[-1]) != env_value:
+                                current[path[-1]] = env_value
+                                modified = True
+
+                # Write back only if modifications were made
+                if modified or section_file.name in env_mappings:
+                    with open(section_file, "w", encoding="utf-8") as f:
+                        yaml.safe_dump(
+                            section_data,
+                            f,
+                            default_flow_style=False,
+                            allow_unicode=True,
+                            sort_keys=False,
+                        )
+
+            except Exception as e:
+                console.print(f"⚠️ Warning: Failed to merge {section_file.name}: {e}")
+
     def _copy_gitignore(self, silent: bool = False) -> None:
         """.gitignore copy (optional)."""
         src = self.template_root / ".gitignore"

moai_adk/core/template_engine.py

@@ -209,7 +209,16 @@ class TemplateEngine:
         Extract template variables from project configuration.
 
         Args:
-            config: Project configuration dictionary (from .moai/config/config.json)
+            config: Project configuration dictionary (from section YAML files
+                   or legacy .moai/config/config.json)
+
+        Configuration sources (in priority order):
+        1. Section YAML files: .moai/config/sections/*.yaml
+           - project.yaml: Project settings (name, description, owner)
+           - language.yaml: Language settings
+           - user.yaml: User settings
+           - system.yaml: MoAI/GitHub settings
+        2. Legacy: .moai/config/config.json
 
         Returns:
             Dictionary of template variables

moai_adk/core/template_variable_synchronizer.py

@@ -41,7 +41,8 @@ class TemplateVariableSynchronizer:
     TEMPLATE_TRACKING_PATTERNS = [
         ".claude/settings.json",
         ".claude/settings.local.json",
-        ".moai/config/config.json",
+        ".moai/config/sections/*.yaml",  # Section YAML files (new)
+        ".moai/config/config.json",  # Legacy config.json (fallback)
         ".claude/output-styles/**/*.md",
         ".claude/hooks/**/*.py",
         ".claude/commands/**/*.md",
@@ -126,12 +127,25 @@ class TemplateVariableSynchronizer:
         # If a specific config file changed, prioritize files that depend on it
         if changed_config_path:
             dependency_map = {
+                # Section YAML file dependencies (new approach)
+                ".moai/config/sections/language.yaml": [
+                    ".claude/settings.json",
+                    ".claude/settings.local.json",
+                    ".claude/output-styles",
+                    ".claude/hooks",
+                ],
+                ".moai/config/sections/user.yaml": [
+                    ".claude/settings.json",
+                    ".claude/settings.local.json",
+                    ".claude/output-styles",
+                ],
+                # Legacy config.json dependencies (fallback)
                 ".moai/config/config.json": [
                     ".claude/settings.json",
                     ".claude/settings.local.json",
                     ".claude/output-styles",
                     ".claude/hooks",
-                ]
+                ],
             }
 
             config_key = str(changed_config_path.relative_to(self.project_root))

moai_adk/core/version_sync.py

@@ -5,11 +5,15 @@ Ensures version consistency across multiple configuration files and provides
 automatic synchronization capabilities.
 
 Key Features:
-- Version consistency validation across pyproject.toml, __init__.py, and config.json
+- Version consistency validation across pyproject.toml, __init__.py, and config
 - Automatic synchronization when inconsistencies detected
 - Cache invalidation for statusline version readers
 - Version change detection and notification system
 - Fallback strategies for version resolution
+
+Configuration sources (in priority order):
+1. Section YAML: .moai/config/sections/system.yaml (moai.version)
+2. Legacy: .moai/config/config.json (moai.version)
 """
 
 import json
@@ -28,7 +32,8 @@ class VersionSource(Enum):
     """Enum for version source tracking"""
 
     PYPROJECT_TOML = "pyproject_toml"
-    CONFIG_JSON = "config_json"
+    SECTION_YAML = "section_yaml"  # New: system.yaml
+    CONFIG_JSON = "config_json"  # Legacy fallback
     PACKAGE_METADATA = "package_metadata"
     FALLBACK = "fallback"
 
@@ -74,14 +79,17 @@ class VersionSynchronizer:
 
         self.working_dir = working_dir
         self.pyproject_path = working_dir / "pyproject.toml"
+        self.system_yaml_path = working_dir / ".moai" / "config" / "sections" / "system.yaml"
         self.config_path = working_dir / ".moai" / "config" / "config.json"
         self.init_path = working_dir / "src" / "moai_adk" / "__init__.py"
 
         # Version file paths in order of priority
         # Note: __init__.py reads version dynamically, so we don't synchronize it
+        # Priority: pyproject.toml > system.yaml (new) > config.json (legacy)
         self.version_files = [
             (self.pyproject_path, VersionSource.PYPROJECT_TOML),
-            (self.config_path, VersionSource.CONFIG_JSON),
+            (self.system_yaml_path, VersionSource.SECTION_YAML),  # New: section YAML
+            (self.config_path, VersionSource.CONFIG_JSON),  # Legacy fallback
         ]
 
         # Statusline cache directories to invalidate
@@ -200,6 +208,8 @@ class VersionSynchronizer:
 
             if source == VersionSource.PYPROJECT_TOML:
                 version = self._extract_from_pyproject(content)
+            elif source == VersionSource.SECTION_YAML:
+                version = self._extract_from_section_yaml(content)
             elif source == VersionSource.CONFIG_JSON:
                 version = self._extract_from_config(content)
             elif source == VersionSource.PACKAGE_METADATA:
@@ -226,8 +236,23 @@ class VersionSynchronizer:
         match = re.search(pattern, content, re.MULTILINE)
         return match.group(1) if match else None
 
+    def _extract_from_section_yaml(self, content: str) -> Optional[str]:
+        """Extract version from .moai/config/sections/system.yaml"""
+        try:
+            import yaml
+
+            yaml_data = yaml.safe_load(content)
+            moai_config = yaml_data.get("moai", {})
+            return moai_config.get("version")
+        except ImportError:
+            logger.warning("PyYAML not available for section YAML parsing")
+            return None
+        except Exception as e:
+            logger.error(f"Invalid YAML in system.yaml: {e}")
+            return None
+
     def _extract_from_config(self, content: str) -> Optional[str]:
-        """Extract version from .moai/config/config.json"""
+        """Extract version from .moai/config/config.json (legacy)"""
         try:
             config_data = json.loads(content)
             moai_config = config_data.get("moai", {})
@@ -270,8 +295,31 @@ class VersionSynchronizer:
 
     def _update_version_in_content(self, content: str, source: VersionSource, target_version: str) -> str:
         """Update version in content based on source type"""
-        if source == VersionSource.CONFIG_JSON:
-            # Update moai.version in JSON
+        if source == VersionSource.SECTION_YAML:
+            # Update moai.version in section YAML
+            try:
+                import yaml
+
+                yaml_data = yaml.safe_load(content) or {}
+                if "moai" not in yaml_data:
+                    yaml_data["moai"] = {}
+                yaml_data["moai"]["version"] = target_version
+                return yaml.safe_dump(
+                    yaml_data,
+                    default_flow_style=False,
+                    allow_unicode=True,
+                    sort_keys=False,
+                )
+            except ImportError:
+                logger.warning("PyYAML not available for section YAML update")
+                return content
+            except Exception:
+                # Fallback: regex replacement for version line
+                pattern = r'(version:\s*["\']?)[\d.]+(["\']?)'
+                return re.sub(pattern, f"\\g<1>{target_version}\\g<2>", content)
+
+        elif source == VersionSource.CONFIG_JSON:
+            # Update moai.version in JSON (legacy)
             try:
                 config_data = json.loads(content)
                 if "moai" not in config_data:

moai_adk/foundation/__init__.py

@@ -1,19 +1,9 @@
 """
 MoAI Foundation module - Core foundation-level implementations.
-Includes: EARS methodology, programming language ecosystem, Git workflows.
+Includes: EARS methodology, programming language ecosystem, testing framework.
 """
 
 from .ears import EARSAnalyzer, EARSParser, EARSValidator
-from .git import (
-    BranchingStrategySelector,
-    ConventionalCommitValidator,
-    GitInfo,
-    GitPerformanceOptimizer,
-    GitVersionDetector,
-    GitWorkflowManager,
-    TDDCommitPhase,
-    ValidateResult,
-)
 from .langs import (
     AntiPatternDetector,
     EcosystemAnalyzer,
@@ -40,17 +30,8 @@ __all__ = [
     "EcosystemAnalyzer",
     "PerformanceOptimizer",
     "TestingStrategyAdvisor",
-    # Git Workflow
-    "GitVersionDetector",
-    "ConventionalCommitValidator",
-    "BranchingStrategySelector",
-    "GitWorkflowManager",
-    "GitPerformanceOptimizer",
     # Data structures
     "LanguageInfo",
     "Pattern",
     "TestingStrategy",
-    "GitInfo",
-    "ValidateResult",
-    "TDDCommitPhase",
 ]

moai_adk/foundation/testing.py

@@ -1498,7 +1498,7 @@ def main():
 
     print("\n4. CI Pipeline Configuration:")
     ci_config = automation_orchestrator.setup_ci_pipeline()
-    print(f"CI pipeline: {len(ci_config['stages'])} stages configured")
+    print(f"CI pipeline: {len(ci_config['pipeline_config']['stages'])} stages configured")
 
     print("\n5. Test Reporting:")
     test_report = reporting_specialist.generate_test_reports()