amd-gaia 0.14.1__py3-none-any.whl

gaia/agents/code/tools/project_management.py

@@ -0,0 +1,1016 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Project management tools mixin for Code Agent."""
+
+import ast
+import os
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+class ProjectManagementMixin:
+    """Mixin providing project-level management and creation tools.
+
+    This mixin provides tools for:
+    - Creating complete project structures from requirements
+    - Listing and validating project files
+    - Comprehensive project validation (structure, requirements, code quality)
+    - Multi-language support (Python, JavaScript/TypeScript, CSS, HTML)
+
+    Tools provided:
+    - list_files: List files and directories in a path
+    - validate_project: Comprehensive project validation with auto-fix capability
+    - create_project: Generate complete project from natural language description
+
+    Helper methods:
+    - _validate_project_structure: Validate project structure for consistency
+    """
+
+    def register_project_management_tools(self) -> None:
+        """Register project management tools."""
+        from gaia.agents.base.tools import tool
+
+        @tool
+        def list_files(path: str = ".") -> Dict[str, Any]:
+            """List files and directories in the specified path.
+
+            Args:
+                path: Directory path to list (default: current directory)
+
+            Returns:
+                Dictionary with list of files and directories
+            """
+            try:
+                items = os.listdir(path)
+                files = [
+                    item for item in items if os.path.isfile(os.path.join(path, item))
+                ]
+                dirs = [
+                    item for item in items if os.path.isdir(os.path.join(path, item))
+                ]
+
+                return {
+                    "status": "success",
+                    "path": path,
+                    "files": sorted(files),
+                    "directories": sorted(dirs),
+                    "total": len(items),
+                }
+            except FileNotFoundError:
+                return {"status": "error", "error": f"Directory not found: {path}"}
+            except PermissionError:
+                return {"status": "error", "error": f"Permission denied: {path}"}
+            except Exception as e:
+                return {"status": "error", "error": str(e)}
+
+        @tool
+        def validate_project(project_path: str, fix: bool = False) -> Dict[str, Any]:
+            """Comprehensive project validation for all file types and quality checks.
+
+            This is the unified validation entry point that checks:
+            - Python files: pylint, anti-patterns, Black formatting
+            - JavaScript/TypeScript: ESLint (if available)
+            - requirements.txt: hallucination detection
+            - Project structure: entry points, essential files
+            - CSS/HTML: basic validation
+
+            Args:
+                project_path: Path to the project directory
+                fix: Whether to auto-fix issues where possible
+
+            Returns:
+                Dictionary with comprehensive validation results
+            """
+            try:
+                path = Path(project_path)
+                if not path.exists():
+                    return {
+                        "status": "error",
+                        "error": f"Project not found: {project_path}",
+                    }
+
+                results = {
+                    "status": "success",
+                    "project": str(path),
+                    "validations": {},
+                    "total_errors": 0,
+                    "total_warnings": 0,
+                    "is_valid": True,
+                }
+
+                # Get all project files
+                all_files = list(path.rglob("*"))
+                py_files = [f for f in all_files if f.suffix == ".py"]
+                js_files = [
+                    f for f in all_files if f.suffix in [".js", ".jsx", ".ts", ".tsx"]
+                ]
+                css_files = [f for f in all_files if f.suffix in [".css", ".scss"]]
+                html_files = [f for f in all_files if f.suffix in [".html", ".htm"]]
+
+                # 1. Check project structure
+                structure_result = self._validate_project_structure(path, all_files)
+                results["validations"]["structure"] = structure_result
+                results["total_errors"] += len(structure_result.get("errors", []))
+                results["total_warnings"] += len(structure_result.get("warnings", []))
+
+                # 2. Validate requirements.txt
+                req_file = path / "requirements.txt"
+                if req_file.exists():
+                    req_result = self._validate_requirements(req_file, fix)
+                    results["validations"]["requirements"] = req_result
+                    results["total_errors"] += len(req_result.get("errors", []))
+                    results["total_warnings"] += len(req_result.get("warnings", []))
+
+                # 3. Validate Python files
+                if py_files:
+                    py_result = self._validate_python_files(py_files, fix)
+                    results["validations"]["python"] = py_result
+                    results["total_errors"] += py_result.get("total_errors", 0)
+                    results["total_warnings"] += py_result.get("total_warnings", 0)
+
+                # 4. Validate JavaScript/TypeScript files
+                if js_files:
+                    js_result = self._validate_javascript_files(js_files, fix)
+                    results["validations"]["javascript"] = js_result
+                    results["total_errors"] += js_result.get("total_errors", 0)
+                    results["total_warnings"] += js_result.get("total_warnings", 0)
+
+                # 5. Basic validation for CSS files
+                if css_files:
+                    css_result = self._validate_css_files(css_files)
+                    results["validations"]["css"] = css_result
+                    results["total_warnings"] += css_result.get("warnings", 0)
+
+                # 6. Basic validation for HTML files
+                if html_files:
+                    html_result = self._validate_html_files(html_files)
+                    results["validations"]["html"] = html_result
+                    results["total_warnings"] += html_result.get("warnings", 0)
+
+                # Overall status
+                results["is_valid"] = results["total_errors"] == 0
+                if results["is_valid"]:
+                    if results["total_warnings"] > 0:
+                        results["message"] = (
+                            f"Validation passed with {results['total_warnings']} warnings"
+                        )
+                    else:
+                        results["message"] = "All validations passed!"
+                else:
+                    results["message"] = (
+                        f"Validation failed: {results['total_errors']} errors, "
+                        f"{results['total_warnings']} warnings"
+                    )
+
+                return results
+
+            except Exception as e:
+                return {"status": "error", "error": str(e)}
+
+        @tool
+        def create_project(query: str) -> Dict[str, Any]:
+            """Create a complete Python project from requirements.
+
+            Workflow:
+            1. Generate detailed plan with architecture and class/function outlines
+            2. Implement files one-by-one with validation
+            3. Generate comprehensive tests
+            4. Run tests and fix issues
+            5. Final validation and fixes
+            6. Summary report
+
+            Args:
+                query: The project requirements/description
+
+            Returns:
+                Dictionary with project creation results
+            """
+            try:
+                self.console.print_header("🚀 Starting Project Generation")
+
+                # Phase 1: Generate detailed architectural plan
+                self.console.print_info("📋 Phase 1: Creating architectural plan...")
+
+                plan_prompt = f"""Create a detailed architectural plan for: {query}
+
+Generate a comprehensive JSON response with:
+{{
+  "project_name": "short_snake_case_name",
+  "architecture": {{
+    "overview": "Detailed description of what this application does",
+    "patterns": ["List", "of", "design", "patterns"],
+    "technologies": ["List", "of", "frameworks", "libraries", "databases"]
+  }},
+  "modules": [
+    {{
+      "name": "filename.py",
+      "purpose": "What this module does",
+      "classes": [
+        {{"name": "ClassName", "purpose": "What this class handles", "methods": ["method1", "method2"]}}
+      ],
+      "functions": [
+        {{"name": "function_name", "signature": "function_name(args) -> ReturnType", "purpose": "What it does"}}
+      ]
+    }}
+  ],
+  "tests": [
+    {{"name": "test_filename.py", "coverage": "What this test file covers"}}
+  ]
+}}
+
+IMPORTANT: Include ALL modules needed for a complete, working application.
+For the given requirements, think about:
+- Entry points and main application flow
+- Data models and database structure
+- Business logic and services
+- API endpoints or user interface
+- Authentication and security
+- Configuration and utilities
+- Comprehensive test coverage
+
+Return ONLY valid JSON."""
+
+                plan_response = self.chat.send(plan_prompt, max_tokens=3000).text
+
+                import json
+
+                try:
+                    # Clean the response if it has markdown code blocks
+                    if "```json" in plan_response:
+                        plan_response = plan_response.split("```json")[1].split("```")[
+                            0
+                        ]
+                    elif "```" in plan_response:
+                        plan_response = plan_response.split("```")[1].split("```")[0]
+
+                    plan_data = json.loads(plan_response)
+                    project_name = plan_data.get("project_name", "my_project")
+
+                    # Basic sanitization - lowercase and replace spaces
+                    project_name = (
+                        project_name.lower().strip().replace(" ", "_").replace("-", "_")
+                    )
+
+                    # Check if name is valid (not too long, no special chars, doesn't already exist)
+                    max_retries = 3
+                    for retry in range(max_retries):
+                        issues = []
+
+                        # Check if folder already exists
+                        if os.path.exists(project_name):
+                            issues.append(f"folder '{project_name}' already exists")
+
+                        # Check if name is too long
+                        if len(project_name) > 30:
+                            issues.append(
+                                f"name too long ({len(project_name)} chars, max 30)"
+                            )
+
+                        # Check if name has invalid characters
+                        if not project_name.replace("_", "").replace(".", "").isalnum():
+                            issues.append(
+                                "name contains invalid characters (only a-z, 0-9, _ allowed)"
+                            )
+
+                        # Check if name is empty
+                        if not project_name or project_name == "_":
+                            issues.append("name is empty or invalid")
+
+                        # If valid, break
+                        if not issues:
+                            break
+
+                        # Ask LLM to fix the name
+                        if retry < max_retries - 1:
+                            fix_prompt = f"""The project name "{project_name}" has issues: {', '.join(issues)}
+
+Please provide a new, valid project name that:
+- Is short and descriptive (max 30 characters)
+- Uses snake_case (lowercase with underscores)
+- Doesn't already exist
+- Only contains letters, numbers, and underscores
+
+Original project description: {query}
+
+Respond with ONLY the new project name, nothing else."""
+
+                            new_name = self.chat.send(
+                                fix_prompt, max_tokens=50
+                            ).text.strip()
+                            # Clean the response
+                            new_name = (
+                                new_name.lower()
+                                .strip()
+                                .replace(" ", "_")
+                                .replace("-", "_")
+                            )
+                            # Remove quotes if present
+                            new_name = new_name.strip('"').strip("'")
+
+                            self.console.print_warning(
+                                f"⚠️  Project name '{project_name}' invalid: {', '.join(issues)}"
+                            )
+                            self.console.print_info(f"  Retrying with: '{new_name}'")
+                            project_name = new_name
+                        else:
+                            # Last resort - generate unique name
+                            import random
+
+                            project_name = f"project_{random.randint(1000, 9999)}"
+                            self.console.print_warning(
+                                f"⚠️  Using fallback name: '{project_name}'"
+                            )
+                            break
+
+                    modules = plan_data.get("modules", [])
+                    test_modules = plan_data.get("tests", [])
+                    architecture = plan_data.get("architecture", {})
+
+                    # Ensure we have at least basic files
+                    if not any(m["name"] == "requirements.txt" for m in modules):
+                        modules.append(
+                            {
+                                "name": "requirements.txt",
+                                "purpose": "Python dependencies",
+                            }
+                        )
+                    if not any(m["name"] == "README.md" for m in modules):
+                        modules.append(
+                            {"name": "README.md", "purpose": "Project documentation"}
+                        )
+
+                except (json.JSONDecodeError, TypeError) as e:
+                    self.console.print_warning(
+                        f"⚠️ Could not parse JSON plan, using fallback: {str(e)[:100]}"
+                    )
+                    # Fallback plan
+                    project_name = "my_project"
+                    modules = [
+                        {"name": "main.py", "purpose": "Entry point"},
+                        {"name": "core.py", "purpose": "Core logic"},
+                        {"name": "requirements.txt", "purpose": "Dependencies"},
+                        {"name": "README.md", "purpose": "Documentation"},
+                    ]
+                    test_modules = [{"name": "test_main.py", "coverage": "main tests"}]
+                    architecture = {"overview": query}
+
+                # Create project directory
+                os.makedirs(project_name, exist_ok=True)
+                created_files = []
+                implementation_issues = []
+                test_results = {}
+
+                # Write detailed PLAN.md with architecture and outlines
+                plan_content = f"""# {project_name} - Architectural Plan
+
+## Project Overview
+{architecture.get('overview', query)}
+
+## Architecture
+- **Patterns**: {', '.join(architecture.get('patterns', ['Modular']))}
+- **Technologies**: {', '.join(architecture.get('technologies', ['Python']))}
+
+## Implementation Tasks
+
+### Phase 1: Project Setup
+- [ ] Create project structure
+- [ ] Generate PLAN.md
+- [ ] Set up requirements.txt
+
+### Phase 2: Core Modules
+"""
+                for module in modules:
+                    plan_content += f"- [ ] Implement `{module['name']}` - {module.get('purpose', 'Core functionality')}\n"
+
+                plan_content += "\n### Phase 3: Test Suite\n"
+                for test in test_modules:
+                    plan_content += f"- [ ] Generate `{test['name']}` - {test.get('coverage', 'Unit tests')}\n"
+
+                plan_content += """
+### Phase 4: Quality Assurance
+- [ ] Run all tests
+- [ ] Fix any test failures
+- [ ] Apply Black formatting
+- [ ] Fix linting issues
+
+### Phase 5: Documentation
+- [ ] Verify README.md completeness
+- [ ] Add usage examples
+- [ ] Document API if applicable
+
+## Module Specifications
+"""
+                for module in modules:
+                    plan_content += f"\n### {module['name']}\n"
+                    plan_content += (
+                        f"**Purpose**: {module.get('purpose', 'Implementation')}\n\n"
+                    )
+
+                    if module.get("classes"):
+                        plan_content += "**Classes**:\n"
+                        for cls in module["classes"]:
+                            plan_content += (
+                                f"- `{cls['name']}`: {cls.get('purpose', '')}\n"
+                            )
+                            if cls.get("methods"):
+                                plan_content += (
+                                    f"  - Methods: {', '.join(cls['methods'])}\n"
+                                )
+
+                    if module.get("functions"):
+                        plan_content += "\n**Functions**:\n"
+                        for func in module["functions"]:
+                            plan_content += f"- `{func.get('signature', func['name'])}`: {func.get('purpose', '')}\n"
+
+                plan_content += "\n## Test Coverage\n"
+                for test in test_modules:
+                    plan_content += (
+                        f"- **{test['name']}**: {test.get('coverage', 'Tests')}\n"
+                    )
+
+                plan_content += "\n## Implementation Order\n"
+                plan_content += "1. Core modules and data structures\n"
+                plan_content += "2. Business logic implementation\n"
+                plan_content += "3. Integration and API layers\n"
+                plan_content += "4. Comprehensive test suite\n"
+                plan_content += "5. Documentation and examples\n"
+
+                # Start streaming preview for PLAN.md (markdown file)
+                self.console.start_file_preview(
+                    "PLAN.md", max_lines=20, title_prefix="📋"
+                )
+
+                # Stream the content in chunks for visual effect
+                plan_chunks = []
+                chunk_size = 500  # Characters per chunk
+                for i in range(0, len(plan_content), chunk_size):
+                    chunk = plan_content[i : i + chunk_size]
+                    plan_chunks.append(chunk)
+                    self.console.update_file_preview(chunk)
+                    # Small delay for visual streaming effect
+                    import time
+
+                    time.sleep(0.05)
+
+                # End the preview
+                self.console.stop_file_preview()
+
+                # Write PLAN.md
+                plan_path = os.path.join(project_name, "PLAN.md")
+                with open(plan_path, "w", encoding="utf-8") as f:
+                    f.write(plan_content)
+                created_files.append(plan_path)
+
+                plan_lines = plan_content.count("\n") + 1
+                self.console.print_success(
+                    f"✅ Created detailed PLAN.md with architecture ({plan_lines} lines)"
+                )
+
+                # Project setup phase complete - agent can now use update_plan_progress tool
+
+                # Phase 2: Implement files one-by-one with validation
+                self.console.print_info(
+                    "\n📝 Phase 2: Implementing modules one-by-one..."
+                )
+
+                # Sort modules to implement core/config files first
+                priority_order = ["config", "models", "database", "utils", "core"]
+                modules_sorted = sorted(
+                    modules,
+                    key=lambda m: (
+                        0
+                        if "requirements.txt" in m["name"]
+                        else (
+                            1
+                            if any(p in m["name"].lower() for p in priority_order)
+                            else 2 if "main.py" in m["name"] else 3
+                        )
+                    ),
+                )
+
+                # Initial load of PLAN.md
+                plan_path = os.path.join(project_name, "PLAN.md")
+
+                for i, module in enumerate(modules_sorted, 1):
+                    filename = module["name"]
+                    progress_pct = int((i / len(modules)) * 100)
+                    self.console.print_info(
+                        f"  [{i}/{len(modules)}] ({progress_pct}%) Generating {filename}..."
+                    )
+
+                    file_path = os.path.join(project_name, filename)
+
+                    # Create subdirectories if needed
+                    dir_path = os.path.dirname(file_path)
+                    if dir_path:
+                        os.makedirs(dir_path, exist_ok=True)
+
+                    # Re-read PLAN.md each time to get latest updates
+                    if os.path.exists(plan_path):
+                        with open(plan_path, "r", encoding="utf-8") as f:
+                            plan_context = f.read()
+                    else:
+                        plan_context = plan_content
+
+                    # Generate with architecture context including latest PLAN.md
+                    context = (
+                        f"{query}\n\nProject Plan (Current State):\n{plan_context}\n\n"
+                        f"Current Module:\n{json.dumps(module, indent=2)}"
+                    )
+                    code = self._generate_code_for_file(
+                        filename=filename,
+                        purpose=module.get("purpose", ""),
+                        context=context,
+                    )
+
+                    # Write initial version
+                    with open(file_path, "w", encoding="utf-8") as f:
+                        f.write(code)
+
+                    # Validate and fix iteratively (max 3 attempts)
+                    if filename.endswith(".py"):
+                        for attempt in range(3):
+                            try:
+                                # Syntax check
+
+                                ast.parse(code)
+
+                                # Anti-pattern check
+                                antipattern_result = self._check_antipatterns(
+                                    Path(file_path), code
+                                )
+                                if antipattern_result["errors"]:
+                                    self.console.print_warning(
+                                        f"    ⚠️  Anti-patterns detected: {len(antipattern_result['errors'])} issues"
+                                    )
+                                    implementation_issues.append(
+                                        {
+                                            "file": filename,
+                                            "type": "antipattern",
+                                            "issues": antipattern_result["errors"][:2],
+                                        }
+                                    )
+
+                                # If syntax is valid, we're done
+                                self.console.print_success(
+                                    f"    ✅ {filename} validated"
+                                )
+                                break
+
+                            except SyntaxError as e:
+                                if attempt < 2:
+                                    self.console.print_warning(
+                                        f"    🔧 Fixing syntax error (attempt {attempt+1}/3)"
+                                    )
+                                    code = self._fix_code_with_llm(
+                                        code, file_path, str(e)
+                                    )
+                                    with open(file_path, "w", encoding="utf-8") as f:
+                                        f.write(code)
+                                else:
+                                    self.console.print_error(
+                                        f"    ❌ Could not fix syntax in {filename}"
+                                    )
+                                    implementation_issues.append(
+                                        {
+                                            "file": filename,
+                                            "type": "syntax",
+                                            "error": str(e),
+                                        }
+                                    )
+
+                    created_files.append(file_path)
+
+                # Phase 3: Generate comprehensive tests
+                self.console.print_info("\n🧪 Phase 3: Generating test suite...")
+
+                for i, test in enumerate(test_modules, 1):
+                    test_filename = test["name"]
+                    progress_pct = int((i / len(test_modules)) * 100)
+                    self.console.print_info(
+                        f"  [{i}/{len(test_modules)}] ({progress_pct}%) Generating {test_filename}..."
+                    )
+
+                    test_path = os.path.join(project_name, test_filename)
+
+                    # Re-read PLAN.md to get latest updates
+                    if os.path.exists(plan_path):
+                        with open(plan_path, "r", encoding="utf-8") as f:
+                            plan_context = f.read()
+                    else:
+                        plan_context = plan_content
+
+                    # Generate test with context about what to test and latest PLAN.md
+                    test_context = f"{query}\n\nProject Plan (Current State):\n{plan_context}\n\nTest Coverage: {test.get('coverage', '')}\n\nModules to test:\n"
+                    for module in modules:
+                        if not module["name"].startswith("test_"):
+                            test_context += (
+                                f"- {module['name']}: {module.get('purpose', '')}\n"
+                            )
+
+                    # Add timeout handling for test generation
+                    try:
+                        import threading
+
+                        test_code = None
+                        generation_error = None
+
+                        def generate_with_timeout(
+                            test_filename_param, test_param, test_context_param
+                        ):
+                            nonlocal test_code, generation_error
+                            try:
+                                test_code = self._generate_code_for_file(
+                                    filename=test_filename_param,
+                                    purpose=f"Unit tests for {test_param.get('coverage', 'functionality')}",
+                                    context=test_context_param,
+                                )
+                            except Exception as e:
+                                generation_error = e
+
+                        # Run generation in a thread with timeout
+                        gen_thread = threading.Thread(
+                            target=generate_with_timeout,
+                            args=(test_filename, test, test_context),
+                        )
+                        gen_thread.daemon = True
+                        gen_thread.start()
+                        gen_thread.join(
+                            timeout=180
+                        )  # 180 second (3 min) timeout for test generation
+
+                        if gen_thread.is_alive():
+                            self.console.print_warning(
+                                f"    ⚠️  Test generation timeout for {test_filename}, using placeholder..."
+                            )
+                            # Generate a simple placeholder test
+                            test_code = f'''"""Unit tests for {test.get('coverage', 'functionality')}."""
+import unittest
+
+class TestPlaceholder(unittest.TestCase):
+    """Placeholder tests - generation timed out."""
+
+    def test_placeholder(self):
+        """Placeholder test - needs implementation."""
+        self.skipTest("Test generation timed out - needs manual implementation")
+
+if __name__ == "__main__":
+    unittest.main()
+'''
+                        elif generation_error is not None:
+                            if isinstance(generation_error, Exception):
+                                raise generation_error
+                            else:
+                                raise Exception(
+                                    f"Test generation error: {generation_error}"
+                                )
+                        elif not test_code:
+                            raise Exception("No test code generated")
+
+                    except Exception as e:
+                        self.console.print_warning(
+                            f"    ⚠️  Failed to generate {test_filename}: {str(e)[:100]}"
+                        )
+                        # Generate a simple placeholder test
+                        test_code = f'''"""Unit tests for {test.get('coverage', 'functionality')}."""
+import unittest
+
+class TestPlaceholder(unittest.TestCase):
+    """Placeholder tests - generation failed."""
+
+    def test_placeholder(self):
+        """Placeholder test - needs implementation."""
+        self.skipTest("Test generation failed - needs manual implementation")
+
+if __name__ == "__main__":
+    unittest.main()
+'''
+
+                    with open(test_path, "w", encoding="utf-8") as f:
+                        f.write(test_code)
+
+                    # Validate test file syntax
+                    try:
+
+                        ast.parse(test_code)
+                        self.console.print_success(f"    ✅ {test_filename} validated")
+                    except SyntaxError as e:
+                        self.console.print_warning(
+                            f"    ⚠️  Syntax issues in {test_filename}, attempting fix..."
+                        )
+                        test_code = self._fix_code_with_llm(
+                            test_code, test_path, str(e)
+                        )
+                        with open(test_path, "w", encoding="utf-8") as f:
+                            f.write(test_code)
+
+                    created_files.append(test_path)
+
+                # Phase 3.5: Apply Black formatting to all Python files
+                self.console.print_info(
+                    "\n🎨 Phase 3.5: Applying Black formatting to all Python files..."
+                )
+
+                # Format all Python files in the project
+                python_files = []
+                for f in created_files:
+                    file_path = Path(f) if isinstance(f, str) else f
+                    if file_path.suffix == ".py":
+                        python_files.append(file_path)
+
+                formatted_count = 0
+
+                for py_file in python_files:
+                    if py_file.exists():
+                        format_result = self._execute_tool(
+                            "format_with_black", {"file_path": str(py_file)}
+                        )
+                        if format_result.get("formatted"):
+                            formatted_count += 1
+
+                if formatted_count > 0:
+                    self.console.print_success(
+                        f"✅ Formatted {formatted_count} Python file(s) with Black"
+                    )
+                else:
+                    self.console.print_info(
+                        "✓ All Python files already properly formatted"
+                    )
+
+                # Phase 4: Run tests and fix issues
+                self.console.print_info(
+                    "\n🏃 Phase 4: Running tests and fixing issues..."
+                )
+
+                test_run_result = self._execute_tool(
+                    "run_tests", {"project_path": project_name, "timeout": 30}
+                )
+                if test_run_result.get("status") == "success":
+                    if test_run_result.get("tests_passed"):
+                        self.console.print_success("✅ All tests passed!")
+                        test_results["status"] = "passed"
+                        test_results["details"] = "All tests executed successfully"
+                    else:
+                        # Show test failure details
+                        failure_summary = test_run_result.get("failure_summary", "")
+                        stdout = test_run_result.get("stdout", "")
+
+                        self.console.print_warning(
+                            f"⚠️  Some tests failed: {failure_summary}"
+                            if failure_summary
+                            else "⚠️  Some tests failed, attempting fixes..."
+                        )
+
+                        # Extract and show failed test names from pytest output
+                        if stdout:
+                            import re
+
+                            # Get command that was run
+                            test_command = test_run_result.get("command", "pytest")
+
+                            # Look for FAILED lines in pytest output
+                            failed_tests = re.findall(r"FAILED (.*?) -", stdout)
+                            if failed_tests:
+                                self.console.print_info(
+                                    f"\n  Failed tests ({len(failed_tests)}):"
+                                )
+                                for test in failed_tests[:5]:  # Show first 5
+                                    self.console.print_info(f"    • {test}")
+                                if len(failed_tests) > 5:
+                                    self.console.print_info(
+                                        f"    ... and {len(failed_tests) - 5} more"
+                                    )
+
+                            # Show terminal output preview - just raw output in a panel
+                            # Take first 20 lines of pytest output
+                            lines = stdout.split("\n")[:20]
+                            if lines:
+                                if (
+                                    hasattr(self.console, "console")
+                                    and self.console.console
+                                ):
+                                    from rich.panel import Panel
+
+                                    # Show command and raw output
+                                    preview_text = f"$ {test_command}\n\n" + "\n".join(
+                                        lines
+                                    )
+                                    self.console.console.print(
+                                        Panel(
+                                            preview_text,
+                                            title="Test Output Preview",
+                                            border_style="yellow",
+                                            expand=False,
+                                        )
+                                    )
+                                else:
+                                    print("\n  Test Output Preview:")
+                                    print("  " + "─" * 70)
+                                    print(f"  $ {test_command}\n")
+                                    for line in lines:
+                                        print(f"  {line}")
+                                    print("  " + "─" * 70)
+
+                        test_results["status"] = "partial"
+                        test_results["stderr"] = test_run_result.get("stderr", "")
+                        test_results["stdout"] = stdout
+                        test_results["failure_summary"] = failure_summary
+
+                        # Try to fix test failures
+                        for attempt in range(2):
+                            self.console.print_info(
+                                f"  🔧 Fix attempt {attempt+1}/2..."
+                            )
+
+                            # Run auto_fix_syntax_errors on the project
+                            fix_result = self._execute_tool(
+                                "auto_fix_syntax_errors", {"project_path": project_name}
+                            )
+                            if fix_result.get("files_fixed"):
+                                fixed_files = fix_result["files_fixed"]
+                                self.console.print_info(
+                                    f"    Fixed {len(fixed_files)} files:"
+                                )
+                                for file in fixed_files[:3]:  # Show first 3
+                                    self.console.print_info(f"      • {file}")
+                                if len(fixed_files) > 3:
+                                    self.console.print_info(
+                                        f"      ... and {len(fixed_files) - 3} more"
+                                    )
+
+                                # Re-run tests
+                                self.console.print_info("    Re-running tests...")
+                                test_run_result = self._execute_tool(
+                                    "run_tests",
+                                    {"project_path": project_name, "timeout": 30},
+                                )
+                                if test_run_result.get("tests_passed"):
+                                    self.console.print_success(
+                                        "    ✅ Tests now passing!"
+                                    )
+                                    test_results["status"] = "passed"
+                                    break
+                                else:
+                                    # Show what's still failing
+                                    new_failure_summary = test_run_result.get(
+                                        "failure_summary", ""
+                                    )
+                                    if new_failure_summary:
+                                        self.console.print_warning(
+                                            f"    Still failing: {new_failure_summary}"
+                                        )
+                            else:
+                                self.console.print_info(
+                                    "    No syntax errors found to fix"
+                                )
+                else:
+                    self.console.print_warning(
+                        f"⚠️  Could not run tests: {test_run_result.get('error', 'Unknown error')}"
+                    )
+                    test_results["status"] = "error"
+                    test_results["error"] = test_run_result.get("error", "")
+
+                # Phase 5: Final comprehensive validation
+                self.console.print_info("\n🔍 Phase 5: Final project validation...")
+
+                final_validation = self._execute_tool(
+                    "validate_project", {"project_path": project_name, "fix": True}
+                )
+
+                # Try to fix any remaining issues
+                if not final_validation.get("is_valid"):
+                    self.console.print_info("  🔧 Attempting final fixes...")
+
+                    for attempt in range(2):
+                        if final_validation.get("total_errors", 0) == 0:
+                            break
+
+                        # Run auto-fix
+                        auto_fix_result = self._execute_tool(
+                            "auto_fix_syntax_errors", {"project_path": project_name}
+                        )
+                        if auto_fix_result.get("files_fixed"):
+                            self.console.print_info(
+                                f"    Fixed {len(auto_fix_result['files_fixed'])} files"
+                            )
+
+                        # Re-validate
+                        final_validation = self._execute_tool(
+                            "validate_project",
+                            {"project_path": project_name, "fix": True},
+                        )
+                        if final_validation.get("is_valid"):
+                            self.console.print_success(
+                                "✅ All validation checks passed!"
+                            )
+                            break
+
+                # Phase 6: Generate summary
+                self.console.print_header("\n📊 Project Generation Complete!")
+
+                # Build summary message
+                summary = f"""
+## Project: {project_name}
+
+### 📋 Architecture
+- **Overview**: {architecture.get('overview', query)[:100]}...
+- **Technologies**: {', '.join(architecture.get('technologies', ['Python']))}
+- **Patterns**: {', '.join(architecture.get('patterns', ['Modular']))}
+
+### 📁 Generated Files ({len(created_files)} total)
+- **Core Modules**: {len([f for f in created_files if f.endswith('.py') and 'test' not in f])}
+- **Test Files**: {len([f for f in created_files if 'test' in f])}
+- **Documentation**: {len([f for f in created_files if f.endswith('.md')])}
+- **Configuration**: {len([f for f in created_files if f.endswith(('.txt', '.yml', '.yaml', '.json'))])}
+
+### ✅ Quality Metrics
+- **Syntax Validation**: {'✅ Passed' if not implementation_issues else f'⚠️  {len(implementation_issues)} issues'}
+- **Test Results**: {test_results.get('status', 'Not run').title()}
+- **Code Quality**: {final_validation.get('total_errors', 0)} errors, {final_validation.get('total_warnings', 0)} warnings
+- **Anti-patterns**: {'None detected' if not any(i['type'] == 'antipattern' for i in implementation_issues) else 'Some detected'}
+
+### 🎯 Ready to Use
+The project is structured and ready for development. Key features:
+{chr(10).join(f"- {module['name']}: {module.get('purpose', '')}" for module in modules[:5])}
+
+### 🚀 Next Steps
+1. Review PLAN.md for architecture details
+2. Install dependencies: `pip install -r requirements.txt`
+3. Run the application: `python main.py`
+4. Run tests: `pytest`
+"""
+
+                if hasattr(self.console, "console") and self.console.console:
+                    from rich.panel import Panel
+
+                    self.console.console.print(
+                        Panel(summary, title="Project Summary", expand=False)
+                    )
+                else:
+                    print(summary)
+
+                return {
+                    "status": "success",
+                    "project_name": project_name,
+                    "files_created": created_files,
+                    "validation": final_validation,
+                    "test_results": test_results,
+                    "implementation_issues": implementation_issues,
+                    "summary": summary,
+                    "message": f"✅ Successfully created {project_name} with {len(created_files)} files",
+                }
+
+            except Exception as e:
+                return {"status": "error", "error": str(e)}
+
+    def _validate_project_structure(
+        self, _project_path: Path, files: List[Path]
+    ) -> Dict[str, Any]:
+        """Validate project structure for consistency issues.
+
+        Args:
+            _project_path: Path to the project directory (unused currently)
+            files: List of Path objects for all files in the project
+
+        Returns:
+            Dictionary with validation results including errors and warnings
+        """
+        errors = []
+        warnings = []
+
+        filenames = [f.name for f in files if f.is_file()]
+
+        # Check for multiple entry points (common issue)
+        entry_points = ["main.py", "app.py", "run.py", "__main__.py", "wsgi.py"]
+        found_entries = [ep for ep in entry_points if ep in filenames]
+
+        if len(found_entries) > 1:
+            errors.append(
+                f"Multiple entry points found: {', '.join(found_entries)}. "
+                "Choose ONE pattern: either monolithic or modular."
+            )
+
+        # Check for essential files
+        if "README.md" not in filenames and "readme.md" not in filenames:
+            errors.append("Missing README.md")
+
+        if "requirements.txt" not in filenames and "pyproject.toml" not in filenames:
+            warnings.append("Missing requirements.txt or pyproject.toml")
+
+        # Check for PLAN.md
+        if "PLAN.md" not in filenames and "plan.md" not in filenames:
+            warnings.append(
+                "No PLAN.md found (architectural plan should be created first)"
+            )
+
+        # Check for duplicate models (common issue)
+        model_files = [
+            f for f in files if "model" in f.name.lower() and f.suffix == ".py"
+        ]
+        if len(model_files) > 2:
+            warnings.append(
+                f"Multiple model files found ({len(model_files)}). "
+                "Check for duplicate definitions."
+            )
+
+        return {"is_valid": len(errors) == 0, "errors": errors, "warnings": warnings}