amd-gaia 0.14.1__py3-none-any.whl

gaia/agents/code/prompts/nextjs_prompt.py

@@ -0,0 +1,40 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Next.js CRUD app builder prompt for Code Agent."""
+
+# Package version matrix for Next.js 14 compatibility
+NEXTJS_VERSION = "14.2.33"
+PRISMA_VERSION = "5.22.0"
+ZOD_VERSION = "3.23.8"
+
+NEXTJS_PROMPT = """=== NEXT.JS DEVELOPMENT ===
+
+## Role
+You are a Next.js full-stack developer creating CRUD applications.
+
+## Output Format
+Respond with JSON: {"thought": "...", "tool": "...", "tool_args": {...}}
+
+## Quality Standards
+- Components must have loading states and error boundaries
+- Forms must validate input before submission
+- Empty states must show helpful guidance
+- All CRUD operations must be tested
+
+## Technical Rules
+- Server components: `import { prisma } from '@/lib/prisma'`
+- Client components: `import type { ModelName } from '@prisma/client'`
+- NEVER import prisma client directly in client components
+- Run `prisma generate` after schema changes
+
+## Field Consistency
+Use the SAME fields dict across all tools:
+- manage_data_model(fields=...) → Prisma schema
+- manage_api_endpoint(fields=...) → Zod validation
+- manage_react_component(fields=...) → Form fields
+
+## Conventions
+- Models: Singular PascalCase (Todo, Post)
+- Fields: camelCase (firstName, createdAt)
+- Routes: Plural kebab-case (/api/todos)
+"""

gaia/agents/code/prompts/python_prompt.py

@@ -0,0 +1,109 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Python-specific prompt module for Code Agent."""
+
+from typing import Optional
+
+from .base_prompt import get_base_prompt
+
+
+def get_python_prompt(gaia_md_path: Optional[str] = None) -> str:
+    """Get complete Python development prompt (base + Python-specific).
+
+    Args:
+        gaia_md_path: Optional path to GAIA.md file for project context
+
+    Returns:
+        Complete prompt with base universal guidance + Python-specific workflow
+    """
+    base = get_base_prompt(gaia_md_path)
+
+    python_specific = """
+========== PYTHON DEVELOPMENT WORKFLOW ==========
+
+FOR PYTHON PROJECT CREATION REQUESTS:
+When the user asks to create a complete Python project/application, your plan should be:
+"plan": [
+  {"tool": "create_project", "tool_args": {"query": "user's complete project description"}}
+]
+
+The create_project tool will:
+1. Design the project structure
+2. Generate ALL necessary files
+3. Return the actual project name and files created
+
+After create_project completes successfully, you MUST create a NEW plan to validate and test:
+1. Examine the tool result to see the actual project_name (e.g., "calculator_app")
+2. Use list_files to discover the actual project structure
+3. Create a NEW plan with these steps (using the ACTUAL project name):
+   - list_files(project_name) - See what was created
+   - validate_project(project_name, fix=true) - Check project structure and fix issues
+   - auto_fix_syntax_errors(project_name) - Fix any syntax issues
+   - analyze_with_pylint(project_name) - Check code quality
+   - fix_code(project_name/file.py) - Fix any errors found by pylint (if needed)
+
+4. Run TESTS to validate (DO NOT run main.py as it may wait for input and timeout):
+   - Use run_tests tool to run pytest on the entire test suite
+   - Check the "tests_passed" field in the result - if FALSE, tests have FAILED
+   - If "tests_passed": false OR "return_code": 1, examine the errors and fix them
+   - Re-run tests until "tests_passed": true
+
+CRITICAL: DO NOT execute main.py - it may be a web server or interactive app that hangs!
+CRITICAL: Use run_tests tool to validate ALL tests at once with pytest!
+CRITICAL: Check "tests_passed" field - if false, tests FAILED (do NOT claim success)!
+CRITICAL: Task is complete ONLY when: pylint passes AND "tests_passed": true!
+
+Example validation plan:
+{"plan": [
+  {"tool": "list_files", "tool_args": {"path": "todo_app"}},
+  {"tool": "validate_project", "tool_args": {"project_path": "todo_app", "fix": true}},
+  {"tool": "auto_fix_syntax_errors", "tool_args": {"project_path": "todo_app"}},
+  {"tool": "analyze_with_pylint", "tool_args": {"file_path": "todo_app"}},
+  {"tool": "run_tests", "tool_args": {"project_path": "todo_app"}}
+]}
+
+If run_tests fails, create a NEW plan to fix the errors and re-run tests!
+
+IMPORTANT: When creating any Python project, ALWAYS include:
+1. README.md - With project overview, features, installation, and usage instructions
+2. requirements.txt - List all required packages with versions
+
+PYTHON TOOL USAGE:
+For project creation: Use create_project to generate files, then CONTINUE with validation.
+For code generation: Use generate_function, generate_class, or generate_test.
+For file operations: Use read_file, write_python_file, edit_python_file.
+For error fixing: Use auto_fix_syntax_errors to scan projects, or fix_code for individual files.
+
+CRITICAL: After creating any Python project or code:
+1. Run validate_project to check structure and fix common issues
+2. Run auto_fix_syntax_errors to fix any truncated or broken files
+3. Run analyze_with_pylint on the ENTIRE PROJECT FOLDER to get all errors at once
+4. Use fix_code on each file that has errors (based on pylint results)
+5. Run execute_python_file on main.py to test the application
+6. Run execute_python_file on test files to verify tests pass
+7. If execution fails (has_errors: true), read the stderr output and fix the errors
+
+PYLINT STRATEGY: Always run pylint on the project directory, not individual files.
+
+MANDATORY TEST REQUIREMENTS:
+- ALWAYS create test_*.py files for all main modules
+- Use generate_test tool to create comprehensive unit tests
+- Test all major functions and classes
+- Include edge cases and error handling tests
+
+PYTHON-SPECIFIC ERROR PATTERNS:
+- "is_valid": false in read_python_file → Fix the syntax error shown in "errors"
+- "has_errors": true in execute_python_file → Fix the error shown in "stderr"
+- Issues in analyze_with_pylint → Use fix_linting_errors or edit_python_file
+- "status": "error" in any tool result → READ the error message and fix the issue:
+  * If pylint has invalid arguments, retry with valid values (e.g., confidence=HIGH)
+  * If a command fails, check stderr and adjust parameters
+  * ALWAYS recover from tool errors - don't ignore them!
+
+PYTHON MANDATORY WORKFLOW: Create → Check Syntax → Fix → Write Tests → Lint → Test → Verify.
+DO NOT STOP after create_project! Continue with ALL validation steps until verified working.
+
+========== END PYTHON DEVELOPMENT WORKFLOW ==========
+"""
+
+    return base + python_specific

gaia/agents/code/schema_inference.py

@@ -0,0 +1,365 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""AI-powered schema inference for Code Agent.
+
+This module provides dynamic schema inference using AI (Perplexity or local LLM)
+to understand what fields an application should have based on natural language
+descriptions. NO hardcoded app types or patterns - all inference is AI-driven.
+
+Example:
+    User: "Build me a task tracker"
+    AI Response: {"entity": "Task", "fields": [
+        {"name": "title", "type": "string", "required": true},
+        {"name": "completed", "type": "boolean", "required": true},
+        {"name": "dueDate", "type": "datetime", "required": false}
+    ]}
+"""
+
+import json
+import logging
+import os
+import re
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+# Schema inference prompt - instructs AI to return minimal, appropriate fields
+# NOTE: This prompt is optimized for both Perplexity and local LLMs
+SCHEMA_INFERENCE_PROMPT = """You are a database schema designer. Analyze the app description and return the schema for the MAIN entity only.
+
+CRITICAL RULES:
+1. Return ONLY ONE entity - the main data entity (NOT User, NOT Auth)
+2. Keep fields MINIMAL - only what's absolutely necessary
+3. DO NOT include: id, createdAt, updatedAt, userId (auto-generated)
+4. Think about INTUITIVE UX (e.g., Address Book apps NEED a "first name" string field)
+
+EXACT OUTPUT FORMAT (single JSON object, no array):
+{{"entity": "EntityName", "fields": [{{"name": "fieldName", "type": "type", "required": true}}]}}
+
+Valid types: string, text, number, boolean, datetime, email, url
+
+EXAMPLES:
+- "todo app" -> {{"entity": "Todo", "fields": [{{"name": "title", "type": "string", "required": true}}, {{"name": "completed", "type": "boolean", "required": true}}]}}
+- "contact manager" -> {{"entity": "Contact", "fields": [{{"name": "firstName", "type": "string", "required": true}}, {{"name": "lastName", "type": "string", "required": true}}, {{"name": "email", "type": "email", "required": false}}]}}
+
+App description: "{query}"
+
+Keep the schema dead simple, and focus on the most basic fields needed. For example, if the app is a contact manager, include "firstName" and "lastName" fields, but do NOT add address fields unless absolutely necessary.
+
+Return ONLY the JSON object for the MAIN entity:"""
+
+
+def infer_schema(
+    user_query: str,
+    chat_sdk: Optional[Any] = None,
+) -> Dict[str, Any]:
+    """Infer schema fields from user's natural language query using AI.
+
+    Uses cascading fallback: Perplexity API -> Local LLM -> Generic fallback.
+
+    Args:
+        user_query: The user's app description (e.g., "build me a todo app")
+        chat_sdk: Optional ChatSDK instance for local LLM fallback
+
+    Returns:
+        Dictionary with:
+        - entity: Suggested entity name (e.g., "Todo", "Task", "Contact")
+        - fields: List of field definitions with name, type, required
+        - source: Which method was used ("perplexity", "local_llm", "fallback")
+    """
+    # Check if this looks like an app creation request
+    if not _is_app_creation_request(user_query):
+        logger.debug(f"Query doesn't appear to be app creation: {user_query[:50]}...")
+        return {"entity": None, "fields": [], "source": "skipped"}
+
+    # Try Perplexity first (if API key is set)
+    perplexity_key = os.getenv("PERPLEXITY_API_KEY")
+    if perplexity_key:
+        logger.info("Attempting schema inference via Perplexity")
+        result = _infer_via_perplexity(user_query)
+        if result.get("entity"):
+            result["source"] = "perplexity"
+            logger.info(
+                f"Perplexity inferred schema: {result['entity']} with {len(result['fields'])} fields"
+            )
+            return result
+
+    # Fall back to local LLM
+    if chat_sdk:
+        logger.debug("Attempting schema inference via local LLM")
+        result = _infer_via_local_llm(user_query, chat_sdk)
+        if result.get("entity"):
+            result["source"] = "local_llm"
+            logger.debug(
+                f"Local LLM inferred schema: {result['entity']} with {len(result['fields'])} fields"
+            )
+            return result
+
+    # Final fallback - no schema inference available
+    logger.warning("No schema inference available - returning empty schema")
+    return {"entity": None, "fields": [], "source": "fallback"}
+
+
+def _is_app_creation_request(query: str) -> bool:
+    """Check if the query appears to be an app creation request.
+
+    Uses semantic patterns to detect app creation intent without hardcoding
+    specific app types.
+    """
+    query_lower = query.lower()
+
+    # App creation indicators (verbs + objects)
+    creation_verbs = [
+        "build",
+        "create",
+        "make",
+        "develop",
+        "generate",
+        "design",
+        "implement",
+    ]
+    app_objects = [
+        "app",
+        "application",
+        "crud",
+        "website",
+        "site",
+        "system",
+        "tracker",
+        "manager",
+        "dashboard",
+    ]
+
+    # Check for creation verb + app object pattern
+    has_creation_verb = any(verb in query_lower for verb in creation_verbs)
+    has_app_object = any(obj in query_lower for obj in app_objects)
+
+    # Also check for "for managing X" or "to track X" patterns
+    management_patterns = [
+        "for managing",
+        "to manage",
+        "to track",
+        "for tracking",
+        "to organize",
+        "for organizing",
+    ]
+    has_management_pattern = any(
+        pattern in query_lower for pattern in management_patterns
+    )
+
+    return (has_creation_verb and has_app_object) or has_management_pattern
+
+
+def _infer_via_perplexity(query: str) -> Dict[str, Any]:
+    """Infer schema using Perplexity API.
+
+    Args:
+        query: User's app description
+
+    Returns:
+        Schema result or empty dict on failure
+    """
+    try:
+        from gaia.mcp.external_services import get_perplexity_service
+
+        service = get_perplexity_service()
+        prompt = SCHEMA_INFERENCE_PROMPT.format(query=query)
+        result = service.search_web(prompt)
+
+        if result.get("success") and result.get("answer"):
+            return _parse_schema_response(result["answer"])
+
+        logger.warning(
+            f"Perplexity inference failed: {result.get('error', 'No answer')}"
+        )
+        return {"entity": None, "fields": []}
+
+    except Exception as e:
+        logger.warning(f"Perplexity inference error: {e}")
+        return {"entity": None, "fields": []}
+
+
+def _infer_via_local_llm(query: str, chat_sdk: Any) -> Dict[str, Any]:
+    """Infer schema using local LLM via ChatSDK.
+
+    Args:
+        query: User's app description
+        chat_sdk: ChatSDK instance for LLM calls
+
+    Returns:
+        Schema result or empty dict on failure
+    """
+    try:
+        prompt = SCHEMA_INFERENCE_PROMPT.format(query=query)
+        response = chat_sdk.send(prompt, max_tokens=500)
+
+        if response and response.text:
+            return _parse_schema_response(response.text)
+
+        logger.warning("Local LLM returned empty response")
+        return {"entity": None, "fields": []}
+
+    except Exception as e:
+        logger.warning(f"Local LLM inference error: {e}")
+        return {"entity": None, "fields": []}
+
+
+def _parse_schema_response(response: str) -> Dict[str, Any]:
+    """Parse schema JSON from AI response.
+
+    Handles various response formats including:
+    - Clean JSON object
+    - JSON array (takes first non-User entity)
+    - JSON in markdown code blocks
+    - JSON with surrounding text
+
+    Args:
+        response: Raw AI response text
+
+    Returns:
+        Parsed schema or empty dict on failure
+    """
+    try:
+        # Try to extract JSON from the response
+        json_str = _extract_json(response)
+        if not json_str:
+            logger.warning(f"Could not extract JSON from response: {response[:100]}...")
+            return {"entity": None, "fields": []}
+
+        logger.debug(f"Extracted JSON: {json_str[:200]}...")
+        data = json.loads(json_str)
+
+        # Handle array response - take first non-User/Auth entity
+        if isinstance(data, list):
+            logger.debug(
+                f"Response is array with {len(data)} items, selecting main entity"
+            )
+            skip_names = {"user", "auth", "session", "account"}
+            for item in data:
+                if isinstance(item, dict):
+                    name = item.get("entity", "").lower()
+                    if name and name not in skip_names:
+                        data = item
+                        break
+            else:
+                # No suitable entity found, take first if available
+                data = data[0] if data else {}
+
+        # Validate it's a dict
+        if not isinstance(data, dict):
+            logger.warning(f"Expected dict but got {type(data).__name__}")
+            return {"entity": None, "fields": []}
+
+        # Validate required fields
+        entity = data.get("entity")
+        fields = data.get("fields", [])
+
+        if not entity or not isinstance(fields, list):
+            logger.warning(f"Invalid schema format: {data}")
+            return {"entity": None, "fields": []}
+
+        # Normalize fields, filter out auto-generated ones
+        normalized_fields = []
+        skip_fields = {"id", "createdat", "updatedat", "userid"}
+        for field in fields:
+            if isinstance(field, dict) and "name" in field:
+                if field["name"].lower() in skip_fields:
+                    continue
+                normalized_fields.append(
+                    {
+                        "name": field["name"],
+                        "type": field.get("type", "string"),
+                        "required": field.get("required", False),
+                    }
+                )
+
+        logger.debug(f"Parsed schema: {entity} with {len(normalized_fields)} fields")
+        return {"entity": entity, "fields": normalized_fields}
+
+    except json.JSONDecodeError as e:
+        logger.warning(f"JSON parse error: {e}")
+        return {"entity": None, "fields": []}
+    except Exception as e:
+        logger.warning(f"Schema parse error: {e}")
+        return {"entity": None, "fields": []}
+
+
+def _extract_json(text: str) -> Optional[str]:
+    """Extract JSON from text, handling various formats.
+
+    Args:
+        text: Raw text possibly containing JSON
+
+    Returns:
+        Extracted JSON string or None
+    """
+    # Try to find JSON in code blocks first
+    code_block_patterns = [
+        r"```json\s*([\s\S]*?)\s*```",
+        r"```\s*([\s\S]*?)\s*```",
+    ]
+
+    for pattern in code_block_patterns:
+        match = re.search(pattern, text)
+        if match:
+            return match.group(1).strip()
+
+    # Check if text starts with array or object to pick correct pattern
+    stripped = text.strip()
+    if stripped.startswith("["):
+        # JSON array - extract it
+        bracket_match = re.search(r"\[[\s\S]*\]", text)
+        if bracket_match:
+            return bracket_match.group(0)
+
+    # Try to find JSON object directly
+    brace_match = re.search(r"\{[\s\S]*\}", text)
+    if brace_match:
+        return brace_match.group(0)
+
+    # Return stripped text as last resort
+    return text.strip()
+
+
+def format_schema_context(schema_result: Dict[str, Any]) -> str:
+    """Format inferred schema for injection into system prompt.
+
+    Args:
+        schema_result: Result from infer_schema()
+
+    Returns:
+        Formatted string for system prompt, or empty string if no schema
+    """
+    entity = schema_result.get("entity")
+    fields = schema_result.get("fields", [])
+    source = schema_result.get("source", "unknown")
+
+    if not entity or not fields:
+        return ""
+
+    # Format fields for prompt
+    field_lines = []
+    for field in fields:
+        name = field["name"]
+        field_type = field["type"]
+        required = "required" if field.get("required") else "optional"
+        field_lines.append(f"  - {name}: {field_type} ({required})")
+
+    fields_str = "\n".join(field_lines)
+
+    context = f"""
+## AI-Inferred Schema (source: {source})
+
+Based on the user's request, the following schema has been determined:
+
+**Entity:** {entity}
+**Fields:**
+{fields_str}
+
+IMPORTANT: Use these fields when creating the data model and components.
+- Use `manage_data_model` with these field names and types
+- Use the same fields consistently across all tools (API, components, forms)
+- Boolean fields (like 'completed') should render as checkboxes in forms and lists
+"""
+
+    return context

gaia/agents/code/system_prompt.py

@@ -0,0 +1,41 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""
+System prompt configuration for the Code Agent.
+
+This module orchestrates loading the appropriate language-specific prompts
+based on the language and project_type provided by RoutingAgent.
+"""
+
+from typing import Optional
+
+from .prompts.base_prompt import get_base_prompt
+from .prompts.nextjs_prompt import NEXTJS_PROMPT
+from .prompts.python_prompt import get_python_prompt
+
+
+def get_system_prompt(
+    language: str = "python",
+    project_type: str = "script",  # pylint: disable=unused-argument
+    gaia_md_path: Optional[str] = None,
+) -> str:
+    """Get the appropriate system prompt based on language and project type.
+
+    Language and project type are determined by RoutingAgent before CodeAgent
+    is instantiated, so this function no longer performs detection.
+
+    Args:
+        language: Programming language ('python' or 'typescript')
+        project_type: Project type ('frontend', 'backend', 'fullstack', or 'script')
+        gaia_md_path: Optional path to GAIA.md file for project context
+
+    Returns:
+        Complete system prompt string (base + language-specific instructions)
+    """
+    if language == "typescript":
+        # All TypeScript projects use Next.js unified approach
+        base = get_base_prompt(gaia_md_path)
+        return base + NEXTJS_PROMPT
+    else:
+        # Python prompt (default)
+        return get_python_prompt(gaia_md_path)

gaia/agents/code/tools/__init__.py

@@ -0,0 +1,42 @@
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Tool mixins for Code Agent."""
+
+from .code_formatting import CodeFormattingMixin
+
+# Consolidated mixins (new architecture)
+from .code_tools import CodeToolsMixin
+from .error_fixing import ErrorFixingMixin
+
+# External service tools
+from .external_tools import ExternalToolsMixin
+
+# Focused mixins (retained)
+from .file_io import FileIOToolsMixin
+from .project_management import ProjectManagementMixin
+from .testing import TestingMixin
+from .typescript_tools import TypeScriptToolsMixin
+from .validation_parsing import ValidationAndParsingMixin
+
+# Validation tools
+from .validation_tools import ValidationToolsMixin
+from .web_dev_tools import WebToolsMixin
+
+__all__ = [
+    # New consolidated mixins
+    "CodeToolsMixin",
+    "ValidationAndParsingMixin",
+    # Focused mixins
+    "FileIOToolsMixin",
+    "CodeFormattingMixin",
+    "ProjectManagementMixin",
+    "TestingMixin",
+    "ErrorFixingMixin",
+    # TypeScript/Web mixins
+    "TypeScriptToolsMixin",
+    "WebToolsMixin",
+    # External service mixins
+    "ExternalToolsMixin",
+    # Validation tools
+    "ValidationToolsMixin",
+]