acra-cli 0.1.1__py3-none-any.whl

acra/agents/critic/critic_chain.py

@@ -0,0 +1,268 @@
+from langchain_core.prompts import ChatPromptTemplate
+from acra.agents.llm import llm
+
+from acra.schemas.critic_schema import CriticOutput
+
+
+#create critic chain
+
+def create_critic_chain():
+    """
+    Creates the Critic Agent chain.
+
+    Responsibilities:
+    - Review generated code
+    - Analyze execution results
+    - Detect vulnerabilities
+    - Evaluate architecture quality
+    - Validate implementation correctness
+    - Suggest improvements
+    """
+
+    model = llm()
+
+    critic_prompt = ChatPromptTemplate.from_messages([
+
+        (
+            "system",
+
+            """
+You are the Critic Agent inside an autonomous AI system called OMNIAGENT.
+
+You are a senior AI software architect and security reviewer.
+
+Your responsibilities:
+- Review generated code quality
+- Evaluate runtime execution results
+- Detect architectural problems
+- Identify security vulnerabilities
+- Detect hallucinated libraries/APIs
+- Validate implementation correctness
+- Suggest improvements
+- Decide workflow continuation
+
+==================================================
+FIRST: DETECT PROJECT TYPE
+==================================================
+
+BEFORE REVIEWING, detect if this is a web application:
+
+WEB APPLICATION KEYWORDS:
+- Flask, FastAPI, Django, Tornado, etc.
+- User request mentions: website, web app, web interface, portfolio, blog, dashboard
+- Generated files include: templates/, static/, html files, CSS, JavaScript
+- Main app file uses: Flask(), FastAPI(), Django
+
+If this is a WEB APPLICATION:
+- Follow the "WEB SERVER EXECUTION RULES" section below
+- Evaluate based on code structure, NOT execution_success
+- Remember: web apps cannot finish executing (servers block indefinitely)
+
+==================================================
+YOUR ROLE
+==================================================
+
+You are NOT a coding agent.
+
+You DO NOT generate code directly.
+
+You ONLY:
+- analyze
+- evaluate
+- validate
+- critique
+- review
+
+==================================================
+REVIEW OBJECTIVES
+==================================================
+
+You must evaluate:
+
+1. CODE QUALITY
+   - readability
+   - maintainability
+   - modularity
+   - consistency
+
+2. EXECUTION QUALITY
+   - runtime success
+   - runtime stability
+   - error handling
+
+3. ARCHITECTURE
+   - clean structure
+   - scalability
+   - separation of concerns
+
+4. SECURITY
+   - hardcoded secrets
+   - dangerous subprocess usage
+   - shell injection risks
+   - unsafe eval/exec usage
+   - insecure configurations
+
+5. RELIABILITY
+   - missing dependencies
+   - broken imports
+   - incomplete implementations
+
+6. TESTING
+   - validation logic
+   - testability
+   - coverage awareness
+
+==================================================
+CURRENT WORKFLOW STATE
+==================================================
+
+USER REQUEST:
+{user_request}
+
+CURRENT TASK:
+{current_step}
+
+GENERATED FILES:
+{generated_files}
+
+EXECUTION SUCCESS:
+{execution_success}
+
+EXECUTION LOGS:
+{execution_logs}
+
+EXECUTION OUTPUT:
+{execution_output}
+
+ERROR MESSAGE:
+{error_message}
+
+RETRY COUNT:
+{retry_count}
+
+==================================================
+REVIEW RULES
+==================================================
+
+- If execution failed:
+  strongly recommend returning to coder.
+
+- If security vulnerabilities exist:
+  mark review_status as "unsafe".
+
+- If implementation is acceptable:
+  mark review_status as "approved".
+
+- If implementation works but needs refinement:
+  mark review_status as "needs_improvement".
+
+- If implementation is fundamentally broken:
+  mark review_status as "failed".
+
+==================================================
+WEB SERVER EXECUTION RULES
+==================================================
+
+CRITICAL: Web applications (Flask, FastAPI, Django, etc.) CANNOT be validated
+by running them to completion. They run indefinitely by design.
+
+When evaluating web applications:
+
+1. IGNORE execution_success = False if it's a web server app
+   - Validation script success means the app is structurally sound
+
+2. EVALUATE WEB APPS BASED ON:
+   - Directory structure (templates/, static/ folders present)
+   - HTML templates properly structured and syntactically valid
+   - CSS files with proper styling rules
+   - JavaScript files present and valid
+   - Flask/FastAPI application entry point (app.py or main.py) well-formed
+   - requirements.txt listing correct dependencies
+   - All imports and syntax are valid
+
+3. SCORING WEB APPLICATIONS:
+   - Score 8-9: Complete structure, all files present, no security issues, follows conventions
+   - Score 7-8: Most files present, minor structural issues, good architecture
+   - Score below 7: Missing critical files, incomplete implementation, or security risks
+
+4. APPROVE WEB APPLICATIONS IF:
+   - All expected files are generated (templates, static assets, main app file)
+   - No hardcoded secrets or security vulnerabilities
+   - Proper folder structure for Flask/FastAPI (templates/, static/ dirs)
+   - Requirements.txt exists with valid syntax
+   - Application file has valid Flask/FastAPI app definition
+
+==================================================
+NEXT AGENT RULES
+==================================================
+
+- approved → end
+- needs_improvement → coder
+- failed → coder
+- unsafe → human
+
+==================================================
+OUTPUT REQUIREMENTS
+==================================================
+
+Return ONLY structured output.
+
+==================================================
+QUALITY SCORING
+==================================================
+
+Score from 0 → 10
+
+STANDARD PROJECTS (CLI, Libraries, Scripts):
+0-3: Broken or unsafe implementation
+4-6: Partially working but significant issues
+7-8: Good implementation with minor improvements needed
+9-10: Production-quality implementation
+
+WEB APPLICATIONS (Flask, FastAPI, Django, etc.):
+0-3: Broken structure, missing critical files
+4-5: Incomplete - major components missing
+6-7: Functional structure but needs refinement
+8-9: Well-structured, all components present, good architecture
+10: Production-ready with perfect structure and styling
+
+CRITICAL: For web apps that validated successfully (exit code 0),
+minimum score should be 7-8 if structure is correct.
+
+==================================================
+IMPORTANT
+==================================================
+
+Be extremely critical and realistic.
+
+Do NOT approve weak implementations.
+
+Your job is to ensure:
+- reliability
+- correctness
+- maintainability
+- security
+"""
+        ),
+
+        (
+            "human",
+
+            """
+Review the generated implementation and determine workflow quality.
+"""
+        )
+
+    ])
+
+
+    #structure output
+
+    structured_llm = model.with_structured_output(
+        CriticOutput
+    )
+
+
+    #return chain
+
+    return critic_prompt | structured_llm

acra/agents/executor/docker_runner.py

@@ -0,0 +1,114 @@
+import subprocess
+import time
+import shlex
+import os
+from pathlib import Path
+from typing import List, Union
+from acra.schemas.execution_schema import ExecutionResult
+
+
+Command = Union[str, List[str]]
+
+
+def _normalize_command(command: Command) -> List[str]:
+    if isinstance(command, str):
+        return shlex.split(command)
+    return command
+
+
+def run_in_docker(
+        project_path: str,
+        command: Command = "python app.py",
+        timeout: int = 60,
+) -> ExecutionResult:
+    """
+    executes generated prject in side docker container."""
+
+    start_time = time.time()
+    resolved_project_path = str(Path(project_path).resolve())
+    command_args = _normalize_command(command)
+    docker_command = [
+        "docker",
+        "run",
+        "--rm",
+        "--network",
+        "none",
+        "--user",
+        f"{os.getuid()}:{os.getgid()}",
+        "--memory",
+        "256m",
+        "--cpus",
+        "1",
+        "--pids-limit",
+        "128",
+        "--cap-drop",
+        "ALL",
+        "--security-opt",
+        "no-new-privileges",
+        "-v",
+        f"{resolved_project_path}:/app:rw",
+        "-w",
+        "/app",
+        "python:3.11",
+        *command_args
+    ]
+    
+    try:
+        result = subprocess.run(
+            docker_command,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+
+        execution_time = time.time() - start_time
+        success = result.returncode == 0
+
+        return ExecutionResult(
+            execution_status=(
+                "success" if success else "failed"
+                ),
+
+            execution_success=success,
+
+            stdout=result.stdout,
+
+            stderr=result.stderr,
+
+            error_message=(
+                result.stderr if not success else None
+                ),
+
+            executed_command=" ".join(command_args),
+
+            execution_time=execution_time,
+
+            next_agent=(
+                "critic" if success else "coder"
+                )
+        )
+    
+    except subprocess.TimeoutExpired:
+        return ExecutionResult(
+            execution_status="timeout",
+            execution_success=False,
+            stdout="",
+            stderr="Execution timed out.",
+            error_message="Execution exceeded the timeout limit.",
+            executed_command=" ".join(command_args),
+            execution_time=timeout,
+            next_agent="coder"
+        )
+    
+    except Exception as e:
+        
+        return ExecutionResult(
+            execution_status="crashed",
+            execution_success=False,
+            stdout="",
+            stderr=str(e),
+            error_message=str(e),
+            executed_command=" ".join(command_args),
+            execution_time=time.time() - start_time,
+            next_agent="human"
+        )

acra/agents/executor/executor_agent.py

@@ -0,0 +1,142 @@
+from typing import Dict
+from langchain_core.messages import AIMessage
+from acra.graph.state import AgentState
+
+from acra.agents.executor.sandbox_runner import (
+    execute_generated_project
+)
+
+def executor_agent(state: AgentState) -> Dict:
+    """
+    Execution Agent
+
+    Responsibilities:
+    - Save generated files.
+    - Execute generated code
+    - Capture runtime logs/errors
+    - Detect failures
+    - Route workflow intelligently
+    """
+
+    # Extract state
+    generated_files = state.get(
+        "generated_files",
+        {}
+    )
+
+    project_name = state.get(
+        "project_name",
+        "current_project"
+    )
+
+    entry_point = state.get("entry_point", "app.py") or "app.py"
+
+    retry_count = state.get(
+        "retry_count",
+        0
+    )
+
+    #Validate generated files
+
+    if not generated_files:
+        return {
+            "messages": [
+                AIMessage(
+                    content=(
+                        "Execution Agent: "
+                        "No generated files found."
+                    )
+                )
+            ],  
+
+            "execution_success": False,
+
+            "error_message": (
+                "No files available for execution."
+                ),
+
+            "next_agent": "coder",
+            "current_agent": "executor",
+            "project_name": project_name,
+
+            "retry_count": retry_count + 1
+
+        }
+
+    # Execute generated project
+    execution_result = execute_generated_project(
+        generated_files=generated_files,
+        project_name=project_name,
+        entry_point=entry_point,
+    )
+
+    # Detect if this is a web server app
+    all_content = " ".join(generated_files.values())
+    is_web_server = any(kw in all_content for kw in [
+        "app.run(", "uvicorn", "Flask(", "FastAPI(", "django", "tornado"
+    ])
+
+    # For web servers that validate successfully, consider it a success
+    # (validation passes = syntax OK + dependencies OK)
+    execution_success = execution_result.execution_success
+    if is_web_server and execution_result.execution_status == "success":
+        execution_success = True
+
+    if execution_success:
+        if is_web_server:
+            executor_message = (
+                "Execution Agent: "
+                "Web application structure validated successfully.\n\n"
+                f"Execution time: {execution_result.execution_time:.2f} seconds."
+            )
+        else:
+            executor_message = (
+                "Execution Agent: "
+                "Project executed successfully.\n\n"
+                f"Execution time: {execution_result.execution_time:.2f} seconds."
+            )
+        next_agent = "critic"
+    else:
+        executor_message = (
+            "Execution Agent: "
+            "Project execution failed.\n\n"
+            f"Error: {execution_result.error_message or 'Unknown error.'}"
+        )
+        next_agent = "coder" if retry_count < 3 else "critic"
+
+    # Detect if failure was a web server timeout (not a real code error)
+    is_timeout = execution_result.execution_status == "timeout"
+    is_expected_timeout = is_web_server and is_timeout
+
+    # Only increment retry_count for real failures, not expected web server timeouts
+    retry_increment = 0 if is_expected_timeout else (
+        0 if execution_success else 1
+    )
+
+    # Return updated state
+    return {
+        "messages": [
+            AIMessage(
+                content=executor_message
+            )
+        ],
+
+        #execution results
+        "execution_success": execution_success,
+        "execution_status": execution_result.execution_status,
+        "execution_output": execution_result.stdout,
+        "execution_logs": (
+            f"STDOUT:\n{execution_result.stdout}\n\n"
+            f"STDERR:\n{execution_result.stderr}"
+        ),
+        "error_message": execution_result.error_message,
+        "execution_time": execution_result.execution_time,
+
+        #workflow
+        "next_agent": next_agent,
+        "current_agent": "executor",
+        "project_name": project_name,
+
+        #retry tracking
+        "retry_count": retry_count + retry_increment
+    }

acra/agents/executor/sandbox_runner.py

@@ -0,0 +1,144 @@
+import logging
+from typing import Dict
+from pathlib import Path
+
+from acra.agents.executor.docker_runner import run_in_docker
+from acra.schemas.execution_schema import ExecutionResult
+from acra.config import GENERATED_PROJECT_DIR
+
+
+logger = logging.getLogger(__name__)
+
+
+def _safe_child_path(base_path: Path, relative_path: str) -> Path:
+    """
+    Resolve a user/model supplied child path and ensure it stays under base_path.
+    """
+    candidate = Path(relative_path)
+    if candidate.is_absolute() or ".." in candidate.parts:
+        raise ValueError(f"Unsafe generated file path: {relative_path}")
+
+    resolved_base = base_path.resolve()
+    resolved_candidate = (resolved_base / candidate).resolve()
+    if not resolved_candidate.is_relative_to(resolved_base):
+        raise ValueError(f"Generated file escapes project directory: {relative_path}")
+
+    return resolved_candidate
+
+
+def save_generated_files(
+        generated_files: Dict[str, str],
+        project_name: str = "current_project"
+) -> str:
+    """
+    Save generated files to sandbox project directory.
+    """
+    project_path = _safe_child_path(
+        Path(GENERATED_PROJECT_DIR),
+        project_name or "current_project"
+    )
+    
+    logger.info(f"Creating project directory: {project_path}")
+    
+    project_path.mkdir(parents=True, exist_ok=True)
+
+    for filename, content in generated_files.items():
+
+        file_path = _safe_child_path(project_path, filename)
+        
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        
+        logger.debug(f"Saved file: {file_path} ({len(content)} bytes)")
+
+    logger.info(f"Project '{project_name}' saved with {len(generated_files)} files")
+    
+    return str(project_path)
+
+def execute_generated_project(
+        generated_files: Dict[str, str],
+        project_name: str = "current_project",
+        command: str = None,
+        entry_point: str = "app.py"
+) -> ExecutionResult:
+    
+    """
+    Save generated project and execute inside a sandbox.
+    Auto-detects web server frameworks and validates them without running the server.
+    """
+    project_path = save_generated_files(
+        generated_files=generated_files,
+        project_name=project_name
+        )
+    
+    # Auto-detect web server frameworks
+    all_content = " ".join(generated_files.values())
+    is_web_server = any(kw in all_content for kw in [
+        "app.run(", "uvicorn", "Flask(", "FastAPI(", "django", "tornado"
+    ])
+
+    if command is None:
+        if is_web_server:
+            # For web servers, create and run a validation script
+            validation_script = """import ast
+import sys
+from pathlib import Path
+
+try:
+    from pip._vendor.packaging.requirements import Requirement
+except Exception:
+    Requirement = None
+
+# Validate Python syntax for all .py files recursively.
+errors = []
+for path in Path('.').rglob('*.py'):
+    if any(part.startswith('.') for part in path.parts):
+        continue
+    try:
+        source = path.read_text(encoding='utf-8')
+        ast.parse(source, filename=str(path))
+    except SyntaxError as e:
+        errors.append(f"{path}: {e}")
+    except UnicodeDecodeError as e:
+        errors.append(f"{path}: {e}")
+
+requirements = Path('requirements.txt')
+if requirements.exists():
+    for line_number, line in enumerate(requirements.read_text(encoding='utf-8').splitlines(), 1):
+        stripped = line.strip()
+        if not stripped or stripped.startswith('#'):
+            continue
+        if Requirement is None:
+            continue
+        try:
+            Requirement(stripped)
+        except Exception as e:
+            errors.append(f"requirements.txt:{line_number}: invalid requirement {stripped!r}: {e}")
+
+if errors:
+    print("Validation errors found:")
+    for err in errors:
+        print(f"  {err}")
+    sys.exit(1)
+
+print("Web application validation passed: all files have valid syntax")
+sys.exit(0)
+"""
+            # Save validation script to project
+            validation_path = _safe_child_path(Path(project_path), "_validate.py")
+            with open(validation_path, "w", encoding="utf-8") as f:
+                f.write(validation_script)
+            
+            command = "python _validate.py"
+        else:
+            resolved_entry_point = (entry_point or "app.py").strip() or "app.py"
+            command = f"python {resolved_entry_point}"
+
+    result = run_in_docker(
+        project_path=project_path, 
+        command=command
+        )
+
+    return result