acra-cli 0.1.1__py3-none-any.whl

acra/config/profile_manager.py

@@ -0,0 +1,87 @@
+"""Profile management for acra."""
+
+import json
+import os
+from getpass import getpass
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+CONFIG_DIR = Path.home() / ".acra"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+DEFAULT_PROFILE_NAME = "default"
+
+
+def _ensure_config_dir() -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _safe_load_config() -> Dict[str, Any]:
+    _ensure_config_dir()
+    if not CONFIG_FILE.exists():
+        return {"profiles": {DEFAULT_PROFILE_NAME: {}}, "active": DEFAULT_PROFILE_NAME}
+    try:
+        with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {"profiles": {DEFAULT_PROFILE_NAME: {}}, "active": DEFAULT_PROFILE_NAME}
+
+
+def _save_config(data: Dict[str, Any]) -> None:
+    _ensure_config_dir()
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+
+class ProfileManager:
+    """Manage named acra configuration profiles."""
+
+    def __init__(self) -> None:
+        self._data = _safe_load_config()
+
+    def list_profiles(self) -> Dict[str, Any]:
+        return self._data.get("profiles", {})
+
+    def load_profile(self, profile_name: Optional[str] = None) -> Dict[str, Any]:
+        if profile_name is None:
+            profile_name = self._data.get("active", DEFAULT_PROFILE_NAME)
+        profiles = self._data.get("profiles", {})
+        return profiles.get(profile_name, profiles.get(DEFAULT_PROFILE_NAME, {}))
+
+    def save_profile(self, profile_name: str, profile_data: Dict[str, Any]) -> None:
+        profiles = self._data.setdefault("profiles", {})
+        profiles[profile_name] = profile_data
+        self._data["active"] = profile_name
+        _save_config(self._data)
+
+    def set_active(self, profile_name: str) -> None:
+        profiles = self._data.setdefault("profiles", {})
+        if profile_name in profiles:
+            self._data["active"] = profile_name
+            _save_config(self._data)
+        else:
+            raise ValueError(f"Profile not found: {profile_name}")
+
+    def run_wizard(self, profile_name: Optional[str] = None) -> str:
+        profile_name = profile_name or DEFAULT_PROFILE_NAME
+        print("Welcome to acra setup wizard")
+        provider = input("Choose provider (gemini/openai/groq/ollama/huggingface_cloud/huggingface_local): ").strip() or "gemini"
+        model = input("Model name: ").strip() or "gemini-2.5-flash"
+        api_key = getpass("Provider API key (hidden): ")
+        theme = input("Theme (dark-orange/dark-blue/dark-green): ").strip() or "dark-orange"
+        workspace = input("Workspace path (default=current directory): ").strip() or os.getcwd()
+        research_keys = {}
+        print("Configure research keys. Press enter to skip a source.")
+        for source in ["web", "github", "docs", "arxiv"]:
+            prompt = f"Research {source} API key (if required): "
+            value = getpass(prompt) if source != "arxiv" else input(prompt).strip()
+            research_keys[source] = value or None
+
+        profile = {
+            "provider": provider,
+            "model": model,
+            "theme": theme,
+            "workspace": workspace,
+            "research_keys": research_keys,
+        }
+        self.save_profile(profile_name, profile)
+        return profile_name

acra/execution/__init__.py

@@ -0,0 +1 @@
+# Package acra/execution

acra/execution/logs/__init__.py

@@ -0,0 +1 @@
+# Package acra/execution/logs

acra/execution/logs/error_logs/__init__.py

@@ -0,0 +1 @@
+# Package acra/execution/logs/error_logs

acra/execution/logs/execution_logs/__init__.py

@@ -0,0 +1 @@
+# Package acra/execution/logs/execution_logs

acra/execution/sandbox/__init__.py

@@ -0,0 +1 @@
+# Package acra/execution/sandbox

acra/execution/sandbox/docker_executor.py

@@ -0,0 +1,209 @@
+import subprocess
+import shlex
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+
+# docker executer 
+
+class DockerExecutor:
+    """
+    Docker-based isolated code execution.
+
+    Responsibilities:
+    - execute code safely
+    - isolate runtime environment
+    - prevent host contamination
+    - support autonomous execution
+    """
+
+
+    # run python file 
+
+    @staticmethod
+    def run_python_file(
+        file_path: str,
+        working_directory: str,
+        timeout: int = 60
+    ) -> Dict:
+        """
+        Execute Python file inside Docker.
+        """
+
+        try:
+
+            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"{Path(working_directory).resolve()}:/app:rw",
+
+                "-w",
+                "/app",
+
+                "python:3.11-slim",
+
+                "python",
+                file_path
+            ]
+
+            result = subprocess.run(
+
+                command,
+
+                capture_output=True,
+
+                text=True,
+
+                timeout=timeout
+            )
+
+            success = (
+                result.returncode == 0
+            )
+
+            return {
+
+                "success": success,
+
+                "stdout": result.stdout,
+
+                "stderr": result.stderr,
+
+                "return_code": (
+                    result.returncode
+                )
+            }
+
+        except subprocess.TimeoutExpired:
+
+            return {
+
+                "success": False,
+
+                "stdout": "",
+
+                "stderr": (
+                    "Execution timed out."
+                )
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "stdout": "",
+
+                "stderr": str(e)
+            }
+
+
+    # run shell command 
+
+    @staticmethod
+    def run_command(
+        command: Union[str, List[str]],
+        working_directory: str,
+        timeout: int = 60
+    ) -> Dict:
+        """
+        Execute shell command in Docker.
+        """
+
+        try:
+            command_args = shlex.split(command) if isinstance(command, str) else 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"{Path(working_directory).resolve()}:/app:rw",
+
+                "-w",
+                "/app",
+
+                "python:3.11-slim",
+
+                *command_args
+            ]
+
+            result = subprocess.run(
+
+                docker_command,
+
+                capture_output=True,
+
+                text=True,
+
+                timeout=timeout
+            )
+
+            return {
+
+                "success": (
+                    result.returncode == 0
+                ),
+
+                "stdout": result.stdout,
+
+                "stderr": result.stderr,
+
+                "return_code": (
+                    result.returncode
+                )
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "stdout": "",
+
+                "stderr": str(e)
+            }
+
+
+# global executer 
+
+docker_executor = DockerExecutor()

acra/execution/sandbox/isolated_runner.py

@@ -0,0 +1,148 @@
+import subprocess
+from typing import Dict, Optional
+
+
+# isolated runner 
+
+class IsolatedRunner:
+    """
+    Lightweight isolated execution runner.
+
+    Responsibilities:
+    - local isolated execution
+    - rapid debugging workflows
+    - development-time execution
+    """
+
+    def __init__(
+        self,
+        timeout: int = 30
+    ):
+
+        self.timeout = timeout
+
+
+    # run python script
+
+    def run_python_script(
+        self,
+        script_path: str,
+        cwd: Optional[str] = None
+    ) -> Dict:
+        """
+        Execute local Python script.
+        """
+
+        try:
+
+            result = subprocess.run(
+
+                ["python", script_path],
+
+                capture_output=True,
+
+                text=True,
+
+                cwd=cwd,
+
+                timeout=self.timeout
+            )
+
+            return {
+
+                "success": (
+                    result.returncode == 0
+                ),
+
+                "stdout": result.stdout,
+
+                "stderr": result.stderr,
+
+                "return_code": (
+                    result.returncode
+                )
+            }
+
+        except subprocess.TimeoutExpired:
+
+            return {
+
+                "success": False,
+
+                "stdout": "",
+
+                "stderr": (
+                    "Execution timed out."
+                )
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "stdout": "",
+
+                "stderr": str(e)
+            }
+
+
+    # run terminal command 
+
+    def run_command(
+        self,
+        command: str,
+        cwd: Optional[str] = None
+    ) -> Dict:
+        """
+        Execute shell command locally.
+        """
+
+        try:
+
+            result = subprocess.run(
+
+                command,
+
+                shell=True,
+
+                capture_output=True,
+
+                text=True,
+
+                cwd=cwd,
+
+                timeout=self.timeout
+            )
+
+            return {
+
+                "success": (
+                    result.returncode == 0
+                ),
+
+                "stdout": result.stdout,
+
+                "stderr": result.stderr,
+
+                "return_code": (
+                    result.returncode
+                )
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "stdout": "",
+
+                "stderr": str(e)
+            }
+
+
+# global runner 
+
+isolated_runner = IsolatedRunner()

acra/execution/sandbox/sandbox_manager.py

@@ -0,0 +1,178 @@
+import os
+import uuid
+from pathlib import Path
+from typing import Dict
+
+
+# sandbox config 
+
+SANDBOX_ROOT = "execution/generated_projects"
+
+os.makedirs(SANDBOX_ROOT, exist_ok=True)
+
+
+# sandbox manager 
+
+class SandboxManager:
+    """
+    Sandbox environment manager.
+
+    Responsibilities:
+    - create isolated workspaces
+    - manage execution directories
+    - cleanup temporary projects
+    - support autonomous execution
+    """
+
+    def __init__(self):
+
+        self.sandbox_root = SANDBOX_ROOT
+
+
+    # create sandbox
+
+    def create_sandbox(
+        self,
+        prefix: str = "workflow"
+    ) -> Dict:
+        """
+        Create isolated execution workspace.
+        """
+
+        try:
+
+            sandbox_id = (
+                f"{prefix}_{uuid.uuid4().hex[:8]}"
+            )
+
+            sandbox_path = os.path.join(
+                self.sandbox_root,
+                sandbox_id
+            )
+
+            Path(sandbox_path).mkdir(
+                parents=True,
+                exist_ok=True
+            )
+
+            return {
+
+                "success": True,
+
+                "sandbox_id": sandbox_id,
+
+                "sandbox_path": sandbox_path
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "error": str(e)
+            }
+
+
+    # delete sandbox
+
+    def delete_sandbox(
+        self,
+        sandbox_path: str
+    ) -> Dict:
+        """
+        Remove sandbox workspace.
+        """
+
+        try:
+
+            if os.path.exists(
+                sandbox_path
+            ):
+
+                for root, dirs, files in os.walk(
+                    sandbox_path,
+                    topdown=False
+                ):
+
+                    for file in files:
+
+                        os.remove(
+                            os.path.join(
+                                root,
+                                file
+                            )
+                        )
+
+                    for directory in dirs:
+
+                        os.rmdir(
+                            os.path.join(
+                                root,
+                                directory
+                            )
+                        )
+
+                os.rmdir(sandbox_path)
+
+            return {
+
+                "success": True,
+
+                "sandbox_path": sandbox_path
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "error": str(e)
+            }
+
+
+    # list sandboxes
+
+    def list_sandboxes(self) -> Dict:
+        """
+        Retrieve active sandboxes.
+        """
+
+        try:
+
+            sandboxes = []
+
+            for item in os.listdir(
+                self.sandbox_root
+            ):
+
+                full_path = os.path.join(
+                    self.sandbox_root,
+                    item
+                )
+
+                if os.path.isdir(full_path):
+
+                    sandboxes.append(full_path)
+
+            return {
+
+                "success": True,
+
+                "sandboxes": sandboxes
+            }
+
+        except Exception as e:
+
+            return {
+
+                "success": False,
+
+                "error": str(e)
+            }
+
+
+# global sandbox manager 
+
+sandbox_manager = SandboxManager()