amd-gaia 0.14.1__py3-none-any.whl

gaia/agents/code/orchestration/project_analyzer.py

@@ -0,0 +1,391 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Project Analyzer for Understanding Current Project State.
+
+This module analyzes the current state of a project directory to provide
+context for the LLM during checklist generation. It detects:
+- Whether the project exists
+- What framework/tools are configured
+- What models/routes/pages already exist
+
+This information helps the LLM generate a checklist that:
+- Doesn't recreate things that already exist
+- Builds on existing infrastructure
+- Fills in missing pieces
+"""
+
+import json
+import logging
+import re
+from pathlib import Path
+from typing import List
+
+from .checklist_generator import ProjectState
+
+logger = logging.getLogger(__name__)
+
+
+class ProjectAnalyzer:
+    """Analyze project state for LLM context.
+
+    Provides detailed information about what exists in a project
+    so the LLM can generate appropriate checklists.
+    """
+
+    def analyze(self, project_dir: str) -> ProjectState:
+        """Analyze a project directory.
+
+        Args:
+            project_dir: Path to project directory
+
+        Returns:
+            ProjectState with analysis results
+        """
+        project_path = Path(project_dir)
+
+        if not project_path.exists():
+            logger.info(f"Project directory does not exist: {project_dir}")
+            return ProjectState(exists=False)
+
+        state = ProjectState(exists=True)
+
+        # Check for package.json (Node.js project)
+        package_json = project_path / "package.json"
+        if package_json.exists():
+            state.has_package_json = True
+            self._analyze_package_json(package_json, state)
+
+        # Check for Next.js config
+        next_config = project_path / "next.config.ts"
+        if not next_config.exists():
+            next_config = project_path / "next.config.js"
+        if not next_config.exists():
+            next_config = project_path / "next.config.mjs"
+        state.has_next_config = next_config.exists()
+
+        # Check for Prisma
+        prisma_schema = project_path / "prisma" / "schema.prisma"
+        if prisma_schema.exists():
+            state.has_prisma = True
+            state.existing_models = self._analyze_prisma_schema(prisma_schema)
+
+        # Analyze existing routes
+        api_dir = project_path / "src" / "app" / "api"
+        if api_dir.exists():
+            state.existing_routes = self._analyze_api_routes(api_dir)
+
+        # Analyze existing pages
+        app_dir = project_path / "src" / "app"
+        if app_dir.exists():
+            state.existing_pages = self._analyze_pages(app_dir)
+
+        logger.debug(f"Project analysis complete: {state.to_prompt()}")
+        return state
+
+    def _analyze_package_json(self, package_path: Path, state: ProjectState) -> None:
+        """Analyze package.json for dependencies.
+
+        Args:
+            package_path: Path to package.json
+            state: ProjectState to update
+        """
+        try:
+            content = json.loads(package_path.read_text())
+            deps = content.get("dependencies", {})
+            dev_deps = content.get("devDependencies", {})
+            all_deps = {**deps, **dev_deps}
+
+            # Check for common dependencies
+            if "prisma" in all_deps or "@prisma/client" in all_deps:
+                state.has_prisma = True
+
+        except json.JSONDecodeError:
+            logger.warning(f"Could not parse package.json: {package_path}")
+
+    def _analyze_prisma_schema(self, schema_path: Path) -> List[str]:
+        """Extract model names from Prisma schema.
+
+        Args:
+            schema_path: Path to schema.prisma
+
+        Returns:
+            List of model names
+        """
+        models = []
+        try:
+            content = schema_path.read_text()
+
+            # Find all model definitions
+            model_pattern = r"model\s+(\w+)\s*\{"
+            matches = re.findall(model_pattern, content)
+            models = list(matches)
+
+            logger.debug(f"Found Prisma models: {models}")
+
+        except Exception as e:
+            logger.warning(f"Could not parse Prisma schema: {e}")
+
+        return models
+
+    def _analyze_api_routes(self, api_dir: Path) -> List[str]:
+        """Find existing API routes.
+
+        Args:
+            api_dir: Path to src/app/api directory
+
+        Returns:
+            List of route paths (e.g., ["/todos", "/users"])
+        """
+        routes = []
+
+        try:
+            for route_file in api_dir.rglob("route.ts"):
+                # Extract route path from file location
+                relative = route_file.relative_to(api_dir)
+                parts = list(relative.parts[:-1])  # Remove "route.ts"
+
+                if parts:
+                    route_path = "/" + "/".join(parts)
+                    routes.append(route_path)
+
+            logger.debug(f"Found API routes: {routes}")
+
+        except Exception as e:
+            logger.warning(f"Could not analyze API routes: {e}")
+
+        return routes
+
+    def _analyze_pages(self, app_dir: Path) -> List[str]:
+        """Find existing pages.
+
+        Args:
+            app_dir: Path to src/app directory
+
+        Returns:
+            List of page paths (e.g., ["/", "/todos", "/todos/new"])
+        """
+        pages = []
+
+        try:
+            for page_file in app_dir.rglob("page.tsx"):
+                # Extract page path from file location
+                relative = page_file.relative_to(app_dir)
+                parts = list(relative.parts[:-1])  # Remove "page.tsx"
+
+                if not parts:
+                    pages.append("/")
+                else:
+                    # Skip API routes
+                    if parts[0] == "api":
+                        continue
+                    page_path = "/" + "/".join(parts)
+                    pages.append(page_path)
+
+            logger.debug(f"Found pages: {pages}")
+
+        except Exception as e:
+            logger.warning(f"Could not analyze pages: {e}")
+
+        return pages
+
+
+def analyze_project(project_dir: str) -> ProjectState:
+    """Convenience function to analyze a project.
+
+    Args:
+        project_dir: Path to project directory
+
+    Returns:
+        ProjectState with analysis results
+    """
+    analyzer = ProjectAnalyzer()
+    return analyzer.analyze(project_dir)
+
+
+def get_missing_crud_parts(
+    state: ProjectState,
+    resource_name: str,
+) -> List[str]:
+    """Determine what CRUD parts are missing for a resource.
+
+    Args:
+        state: Current project state
+        resource_name: Resource to check (singular, lowercase)
+
+    Returns:
+        List of missing parts (e.g., ["api_collection", "list_page"])
+    """
+    missing = []
+    resource_plural = resource_name + "s"  # Simple pluralization
+
+    # Check model
+    model_name = resource_name.capitalize()
+    if model_name not in state.existing_models:
+        missing.append("prisma_model")
+
+    # Check API routes
+    collection_route = f"/{resource_plural}"
+    item_route = f"/{resource_plural}/[id]"
+
+    if collection_route not in state.existing_routes:
+        missing.append("api_collection")
+    if item_route not in state.existing_routes:
+        missing.append("api_item")
+
+    # Check pages
+    list_page = f"/{resource_plural}"
+    new_page = f"/{resource_plural}/new"
+    detail_page = f"/{resource_plural}/[id]"
+
+    if list_page not in state.existing_pages:
+        missing.append("list_page")
+    if new_page not in state.existing_pages:
+        missing.append("new_page")
+    if detail_page not in state.existing_pages:
+        missing.append("detail_page")
+
+    return missing
+
+
+def suggest_checklist_items(
+    state: ProjectState,
+    resource_name: str,
+    fields: dict,
+) -> List[dict]:
+    """Suggest checklist items based on project state.
+
+    This is a helper for testing/comparison with LLM-generated checklists.
+
+    Args:
+        state: Current project state
+        resource_name: Resource to create
+        fields: Field definitions for the resource
+
+    Returns:
+        List of suggested checklist item dictionaries
+    """
+    items = []
+    resource = resource_name.lower()
+    Resource = resource_name.capitalize()
+
+    # Check what's missing
+    missing = get_missing_crud_parts(state, resource)
+
+    # Setup items (if project doesn't exist or is incomplete)
+    if not state.has_package_json:
+        items.append(
+            {
+                "template": "create_next_app",
+                "params": {"project_name": f"{resource}-app"},
+                "description": "Initialize Next.js project",
+            }
+        )
+        items.append(
+            {
+                "template": "setup_app_styling",
+                "params": {"app_title": f"{Resource} App"},
+                "description": "Configure modern styling",
+            }
+        )
+
+    if not state.has_prisma:
+        items.append(
+            {
+                "template": "setup_prisma",
+                "params": {},
+                "description": "Initialize Prisma ORM",
+            }
+        )
+
+    # Data model
+    if "prisma_model" in missing:
+        items.append(
+            {
+                "template": "generate_prisma_model",
+                "params": {"model_name": Resource, "fields": fields},
+                "description": f"Define {Resource} database model",
+            }
+        )
+
+    # API routes
+    if "api_collection" in missing:
+        items.append(
+            {
+                "template": "generate_api_route",
+                "params": {
+                    "resource": resource,
+                    "operations": ["GET", "POST"],
+                    "type": "collection",
+                },
+                "description": f"Create API for listing and creating {resource}s",
+            }
+        )
+
+    if "api_item" in missing:
+        items.append(
+            {
+                "template": "generate_api_route",
+                "params": {
+                    "resource": resource,
+                    "operations": ["GET", "PATCH", "DELETE"],
+                    "type": "item",
+                },
+                "description": f"Create API for single {resource} operations",
+            }
+        )
+
+    # UI components
+    if "list_page" in missing:
+        items.append(
+            {
+                "template": "generate_react_component",
+                "params": {"resource": resource, "variant": "list"},
+                "description": f"List page showing all {resource}s",
+            }
+        )
+
+    # Form component (always needed if any UI is missing)
+    if any(p in missing for p in ["new_page", "detail_page"]):
+        items.append(
+            {
+                "template": "generate_react_component",
+                "params": {"resource": resource, "variant": "form"},
+                "description": "Form component for create/edit",
+            }
+        )
+
+    if "new_page" in missing:
+        items.append(
+            {
+                "template": "generate_react_component",
+                "params": {"resource": resource, "variant": "new"},
+                "description": f"Create new {resource} page",
+            }
+        )
+
+    if "detail_page" in missing:
+        items.append(
+            {
+                "template": "generate_react_component",
+                "params": {"resource": resource, "variant": "detail"},
+                "description": f"View/edit {resource} page",
+            }
+        )
+        items.append(
+            {
+                "template": "generate_react_component",
+                "params": {"resource": resource, "variant": "actions"},
+                "description": "Edit/delete buttons component",
+            }
+        )
+
+    # Landing page update
+    items.append(
+        {
+            "template": "update_landing_page",
+            "params": {"resource": resource},
+            "description": f"Add navigation to {resource}s",
+        }
+    )
+
+    return items

gaia/agents/code/orchestration/steps/__init__.py

@@ -0,0 +1,67 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Step implementations for orchestration workflows."""
+
+from .base import BaseStep, ErrorCategory, StepResult, StepStatus, UserContext
+from .error_handler import ErrorHandler, RecoveryAction
+
+# Next.js steps
+from .nextjs import (
+    CreateNextAppStep,
+    InstallDependenciesStep,
+    ManageApiEndpointDynamicStep,
+    ManageApiEndpointStep,
+    ManageDataModelStep,
+    ManageReactComponentStep,
+    PrismaInitStep,
+    RunTestsStep,
+    SetupTestingStep,
+    TestCrudApiStep,
+    UpdateLandingPageStep,
+    ValidateCrudStructureStep,
+    ValidateTypescriptStep,
+)
+
+# Python steps
+from .python import (
+    AnalyzePylintStep,
+    AutoFixSyntaxStep,
+    CreateProjectStep,
+    FixLintingStep,
+    ListFilesStep,
+    RunPytestStep,
+    ValidateProjectStep,
+)
+
+__all__ = [
+    # Base
+    "BaseStep",
+    "StepResult",
+    "StepStatus",
+    "ErrorCategory",
+    "UserContext",
+    "ErrorHandler",
+    "RecoveryAction",
+    # Next.js steps
+    "CreateNextAppStep",
+    "InstallDependenciesStep",
+    "PrismaInitStep",
+    "ManageDataModelStep",
+    "ManageApiEndpointStep",
+    "ManageApiEndpointDynamicStep",
+    "ManageReactComponentStep",
+    "ValidateCrudStructureStep",
+    "ValidateTypescriptStep",
+    "TestCrudApiStep",
+    "UpdateLandingPageStep",
+    "SetupTestingStep",
+    "RunTestsStep",
+    # Python steps
+    "CreateProjectStep",
+    "ListFilesStep",
+    "ValidateProjectStep",
+    "AutoFixSyntaxStep",
+    "AnalyzePylintStep",
+    "FixLintingStep",
+    "RunPytestStep",
+]

gaia/agents/code/orchestration/steps/base.py

@@ -0,0 +1,188 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""
+Base step classes for orchestration workflows.
+
+Provides unified interfaces for workflow steps with standardized results.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+
+class StepStatus(Enum):
+    """Status of a step execution."""
+
+    SUCCESS = auto()
+    WARNING = auto()  # Succeeded with warnings
+    ERROR = auto()
+    SKIPPED = auto()  # Step was skipped (e.g., already done)
+
+
+class ErrorCategory(Enum):
+    """Categories of errors for recovery routing."""
+
+    UNKNOWN = auto()
+    NETWORK = auto()  # Transient network errors
+    RESOURCE = auto()  # Resource unavailable (disk, memory)
+    DEPENDENCY = auto()  # Missing dependency
+    COMPILATION = auto()  # TypeScript, build errors
+    SYNTAX = auto()  # Code syntax errors
+    RUNTIME = auto()  # Runtime execution errors
+    VALIDATION = auto()  # Lint, type check failures
+    CONFIGURATION = auto()  # Config file issues
+
+
+@dataclass
+class StepResult:
+    """Unified result format for all step executions.
+
+    Replaces inconsistent patterns like:
+    - {"success": True, "files": [...]}
+    - {"status": "ok", "output": "..."}
+    - {"has_errors": False, "return_code": 0}
+
+    With a single consistent interface.
+    """
+
+    status: StepStatus
+    message: str
+    error_message: Optional[str] = None
+    error_category: ErrorCategory = ErrorCategory.UNKNOWN
+    output: Dict[str, Any] = field(default_factory=dict)
+    retryable: bool = True
+
+    @property
+    def success(self) -> bool:
+        """Check if step completed successfully (including with warnings)."""
+        return self.status in (StepStatus.SUCCESS, StepStatus.WARNING)
+
+    @property
+    def error(self) -> Optional[str]:
+        """Get error message (alias for error_message)."""
+        return self.error_message
+
+    @classmethod
+    def ok(cls, message: str, **output) -> "StepResult":
+        """Create a successful result."""
+        return cls(status=StepStatus.SUCCESS, message=message, output=output)
+
+    @classmethod
+    def warning(cls, message: str, **output) -> "StepResult":
+        """Create a warning result (success with caveats)."""
+        return cls(status=StepStatus.WARNING, message=message, output=output)
+
+    @classmethod
+    def make_error(
+        cls,
+        message: str,
+        error_msg: str,
+        category: ErrorCategory = ErrorCategory.UNKNOWN,
+        retryable: bool = True,
+        **output,
+    ) -> "StepResult":
+        """Create an error result."""
+        return cls(
+            status=StepStatus.ERROR,
+            message=message,
+            error_message=error_msg,
+            error_category=category,
+            retryable=retryable,
+            output=output,
+        )
+
+    @classmethod
+    def skipped(cls, message: str, **output) -> "StepResult":
+        """Create a skipped result."""
+        return cls(status=StepStatus.SKIPPED, message=message, output=output)
+
+
+@dataclass
+class UserContext:
+    """Context passed through workflow execution.
+
+    Contains user request info and accumulated state from previous steps.
+    """
+
+    user_request: str
+    project_dir: str
+    language: str = "typescript"
+    project_type: str = "fullstack"
+    entity_name: Optional[str] = None  # e.g., "Todo", "User"
+    schema_fields: Optional[Dict[str, str]] = None  # e.g., {"title": "string"}
+    accumulated_files: Dict[str, str] = field(default_factory=dict)
+    step_outputs: Dict[str, Any] = field(default_factory=dict)
+    fix_feedback: List[str] = field(default_factory=list)
+    validation_reports: List[Dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass
+class BaseStep(ABC):
+    """Abstract base class for workflow steps.
+
+    Steps wrap tool invocations with standardized result handling.
+    The orchestrator calls steps, which return tool invocation specs.
+    The orchestrator executes the tool and passes results back to the step.
+    """
+
+    name: str
+    description: str = ""
+
+    @abstractmethod
+    def get_tool_invocation(
+        self, context: UserContext
+    ) -> Optional[Tuple[str, Dict[str, Any]]]:
+        """Return the tool name and arguments to execute.
+
+        Args:
+            context: Current workflow context with user request and state
+
+        Returns:
+            Tuple of (tool_name, tool_args) or None to skip this step
+        """
+
+    @abstractmethod
+    def handle_result(self, result: Any, context: UserContext) -> StepResult:
+        """Convert raw tool result to standardized StepResult.
+
+        Args:
+            result: Raw result from tool execution
+            context: Current workflow context
+
+        Returns:
+            Standardized StepResult
+        """
+
+    def should_skip(self, context: UserContext) -> Optional[str]:  # noqa: ARG002
+        """Check if this step should be skipped.
+
+        Args:
+            context: Current workflow context
+
+        Returns:
+            Reason string if should skip, None otherwise
+        """
+        # Default: don't skip. Subclasses override to add skip logic.
+        del context  # Unused in base class
+        return None
+
+    def validate_preconditions(
+        self, context: UserContext
+    ) -> Optional[str]:  # noqa: ARG002
+        """Validate that preconditions for this step are met.
+
+        Args:
+            context: Current workflow context
+
+        Returns:
+            Error message if preconditions not met, None otherwise
+        """
+        # Default: no preconditions. Subclasses override.
+        del context  # Unused in base class
+        return None
+
+
+# Type alias for tool executor function
+ToolExecutor = Callable[[str, Dict[str, Any]], Any]