codeshield-runtime 0.1.0__tar.gz → 0.1.2__tar.gz

{codeshield_runtime-0.1.0 → codeshield_runtime-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeshield-runtime
-Version: 0.1.0
+Version: 0.1.2
 Summary: A secure, isolated, and self-healing Python code execution engine powered by uv and AST analysis.
 Project-URL: Homepage, https://github.com/AlgorithmicMind/codeshield
 Project-URL: Repository, https://github.com/AlgorithmicMind/codeshield
@@ -158,10 +158,10 @@ CodeShield is not locked into a single LLM. Pass any Python callable as the `pat
 from codeshield.loop import SelfHealingEngine
 
 
-def custom_openai_patcher(code: str, diagnosis) -> str:
-    # Any LLM call (OpenAI, Anthropic, DeepSeek, Ollama, LiteLLM)
+def custom_llm_patcher(code: str, diagnosis) -> str:
+    # Compatible with any frontier provider: GPT-5.4, Claude Sonnet 5, DeepSeek V4, Ollama
     response = client.chat.completions.create(
-        model="gpt-4o-mini",
+        model="gpt-5.4-mini",  # or "claude-sonnet-5", "deepseek-v4-flash"
         messages=[
             {
                 "role": "user",
@@ -172,7 +172,7 @@ def custom_openai_patcher(code: str, diagnosis) -> str:
     return response.choices[0].message.content
 
 
-engine = SelfHealingEngine(patch_generator=custom_openai_patcher)
+engine = SelfHealingEngine(patch_generator=custom_llm_patcher)
 ```
 
 ### Zero-Config Self-Healing with Gemini Flash
@@ -234,17 +234,19 @@ The `examples/` folder contains ready-to-run recipes that have been executed and
 - `02_security_gatekeeper.py`: AST rejection of unsafe code.
 - `03_llm_healing_workflow.py`: self-healing workflow with an LLM or local fallback.
 - `04_agent_tool_dropin.py`: end-to-end agentic tool-calling workflow with dynamic code generation.
+- `05_custom_llm_openai_compatible.py`: model-agnostic, API-key-free self-healing with a custom `patch_generator`.
 
 ```bash
 python examples/01_basic_sandboxing.py
 python examples/02_security_gatekeeper.py
 python examples/03_llm_healing_workflow.py
 python examples/04_agent_tool_dropin.py
+python examples/05_custom_llm_openai_compatible.py
 ```
 
 ## Running Tests & Lint
 
-The suite currently has **50 tests** with **>82% code coverage** on `src/codeshield`.
+The suite currently has **53 tests** with **>82% code coverage** on `src/codeshield`.
 
 ```bash
 ruff check src tests examples

{codeshield_runtime-0.1.0 → codeshield_runtime-0.1.2}/README.md

@@ -122,10 +122,10 @@ CodeShield is not locked into a single LLM. Pass any Python callable as the `pat
 from codeshield.loop import SelfHealingEngine
 
 
-def custom_openai_patcher(code: str, diagnosis) -> str:
-    # Any LLM call (OpenAI, Anthropic, DeepSeek, Ollama, LiteLLM)
+def custom_llm_patcher(code: str, diagnosis) -> str:
+    # Compatible with any frontier provider: GPT-5.4, Claude Sonnet 5, DeepSeek V4, Ollama
     response = client.chat.completions.create(
-        model="gpt-4o-mini",
+        model="gpt-5.4-mini",  # or "claude-sonnet-5", "deepseek-v4-flash"
         messages=[
             {
                 "role": "user",
@@ -136,7 +136,7 @@ def custom_openai_patcher(code: str, diagnosis) -> str:
     return response.choices[0].message.content
 
 
-engine = SelfHealingEngine(patch_generator=custom_openai_patcher)
+engine = SelfHealingEngine(patch_generator=custom_llm_patcher)
 ```
 
 ### Zero-Config Self-Healing with Gemini Flash
@@ -198,17 +198,19 @@ The `examples/` folder contains ready-to-run recipes that have been executed and
 - `02_security_gatekeeper.py`: AST rejection of unsafe code.
 - `03_llm_healing_workflow.py`: self-healing workflow with an LLM or local fallback.
 - `04_agent_tool_dropin.py`: end-to-end agentic tool-calling workflow with dynamic code generation.
+- `05_custom_llm_openai_compatible.py`: model-agnostic, API-key-free self-healing with a custom `patch_generator`.
 
 ```bash
 python examples/01_basic_sandboxing.py
 python examples/02_security_gatekeeper.py
 python examples/03_llm_healing_workflow.py
 python examples/04_agent_tool_dropin.py
+python examples/05_custom_llm_openai_compatible.py
 ```
 
 ## Running Tests & Lint
 
-The suite currently has **50 tests** with **>82% code coverage** on `src/codeshield`.
+The suite currently has **53 tests** with **>82% code coverage** on `src/codeshield`.
 
 ```bash
 ruff check src tests examples

{codeshield_runtime-0.1.0 → codeshield_runtime-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codeshield-runtime"
-version = "0.1.0"
+version = "0.1.2"
 description = "A secure, isolated, and self-healing Python code execution engine powered by uv and AST analysis."
 readme = "README.md"
 license = { text = "MIT" }

{codeshield_runtime-0.1.0 → codeshield_runtime-0.1.2}/src/codeshield/environment.py

@@ -63,6 +63,11 @@ class SandboxManager:
         """Return the root sandbox workspace directory."""
         return self._workspace
 
+    @property
+    def workspace_path(self) -> Path:
+        """Alias for the root sandbox workspace directory."""
+        return self._workspace
+
     @property
     def venv_path(self) -> Path:
         """Return the virtual environment directory."""

{codeshield_runtime-0.1.0 → codeshield_runtime-0.1.2}/src/codeshield/loop.py

@@ -1,3 +1,4 @@
+# ruff: noqa: UP045
 """Self-healing execution loop."""
 
 from __future__ import annotations
@@ -7,6 +8,7 @@ import os
 import re
 from collections.abc import Callable
 from pathlib import Path
+from typing import Optional
 
 from codeshield.analyzer import validate_syntax_and_safety
 from codeshield.classifier import TracebackClassifier
@@ -173,7 +175,7 @@ class SelfHealingEngine:
         sandbox: SandboxManager | None = None,
         runner: SubprocessRunner | None = None,
         classifier: TracebackClassifier | None = None,
-        patch_generator: Callable[[str, ErrorDiagnosis], str | None] | None = None,
+        patch_generator: Optional[Callable[[str, ErrorDiagnosis], Optional[str]]] = None,
         gemini_api_key: str | None = None,
         gemini_model: str | None = None,
         use_llm: bool = True,
@@ -224,6 +226,9 @@ class SelfHealingEngine:
     ) -> tuple[ExecutionResult, ErrorDiagnosis | None]:
         """Run code through the AST -> sandbox -> heal loop.
 
+        The sandbox is created automatically if ``run`` is called outside a
+        ``with`` context manager and is cleaned up once execution finishes.
+
         Args:
             request: Either a ``CodeExecutionRequest`` or a raw source string.
             timeout: Optional execution timeout override.
@@ -238,6 +243,22 @@ class SelfHealingEngine:
         if isinstance(request, str):
             request = CodeExecutionRequest(code=request)
 
+        auto_created = not self._sandbox.python_executable.exists()
+        if auto_created:
+            self._sandbox.create()
+
+        try:
+            return self._run_loop(request, timeout)
+        finally:
+            if auto_created:
+                self._sandbox.cleanup()
+
+    def _run_loop(
+        self,
+        request: CodeExecutionRequest,
+        timeout: float | None,
+    ) -> tuple[ExecutionResult, ErrorDiagnosis | None]:
+        """Execute the AST -> sandbox -> heal loop assuming the sandbox exists."""
         diagnosis: ErrorDiagnosis | None = None
         for attempt in range(1, self._max_iterations + 1):
             logger.info("Self-healing iteration %d/%d", attempt, self._max_iterations)

{codeshield_runtime-0.1.0 → codeshield_runtime-0.1.2}/src/codeshield/tools.py

@@ -1,3 +1,4 @@
+# ruff: noqa: UP045
 """Universal agent tool wrapper for CodeShield.
 
 The function returned by ``create_code_execution_tool`` can be registered as a
@@ -9,20 +10,25 @@ stdout or a structured error report.
 from __future__ import annotations
 
 from collections.abc import Callable
+from typing import Optional
 
 from codeshield.environment import SandboxError
 from codeshield.loop import SelfHealingEngine, SelfHealingError
 from codeshield.runner import SubprocessRunnerError
+from codeshield.schemas import ErrorDiagnosis
 
 
 def create_code_execution_tool(
-    engine: SelfHealingEngine | None = None,
+    engine: Optional[SelfHealingEngine] = None,
+    patch_generator: Optional[Callable[[str, ErrorDiagnosis], Optional[str]]] = None,
 ) -> Callable[[str], str]:
     """Return a drop-in ``execute_python_code(code: str) -> str`` tool.
 
     Args:
         engine: Optional ``SelfHealingEngine`` instance. When ``None``, a fresh
             engine is created for each tool call.
+        patch_generator: Optional custom patcher ``(code, diagnosis) -> patched``
+            forwarded to ``SelfHealingEngine`` when ``engine`` is not provided.
 
     Returns:
         A callable ready to be registered as an agent tool.
@@ -41,7 +47,7 @@ def create_code_execution_tool(
             The stdout of the script if execution succeeds, or a structured
             error report if it fails after all self-healing attempts.
         """
-        _engine = engine or SelfHealingEngine()
+        _engine = engine or SelfHealingEngine(patch_generator=patch_generator)
         with _engine:
             try:
                 result, diagnosis = _engine.run(code)

{codeshield_runtime-0.1.0 → codeshield_runtime-0.1.2}/tests/test_engine.py

@@ -7,7 +7,7 @@ import pytest
 from codeshield.analyzer import validate_syntax_and_safety
 from codeshield.classifier import TracebackClassifier
 from codeshield.environment import SandboxManager
-from codeshield.loop import SelfHealingEngine
+from codeshield.loop import SelfHealingEngine, SelfHealingError
 from codeshield.runner import SubprocessRunner
 from codeshield.schemas import (
     ExecutionResult,
@@ -232,3 +232,50 @@ def test_self_healing_engine_fixes_name_error() -> None:
         assert result.exit_code == 0
         assert result.stdout.strip() == "4.0"
         assert diagnosis is None
+
+
+def test_self_healing_engine_run_without_context_manager() -> None:
+    """The engine can be used without a ``with`` block and still auto-manages the sandbox."""
+    engine = SelfHealingEngine(use_llm=False)
+
+    result, diagnosis = engine.run("print('no context manager')")
+
+    assert result.exit_code == 0
+    assert result.stdout.strip() == "no context manager"
+    assert diagnosis is None
+    assert not engine._sandbox.workspace_path.exists()
+
+
+def test_custom_patch_generator_success() -> None:
+    """A custom patch_generator can repair code that the local fallback cannot."""
+
+    def custom_patcher(code: str, diagnosis) -> str | None:
+        if diagnosis.error_type == "TypeError":
+            return code.replace('"Result: " + 42', '"Result: " + str(42)')
+        return None
+
+    engine = SelfHealingEngine(
+        patch_generator=custom_patcher,
+        use_llm=False,
+    )
+    with engine:
+        result, diagnosis = engine.run('print("Result: " + 42)')
+
+        assert result.exit_code == 0
+        assert result.stdout.strip() == "Result: 42"
+        assert diagnosis is None
+
+
+def test_custom_patch_generator_ast_rejection() -> None:
+    """A custom patch that violates the AST security gate is rejected."""
+
+    def malicious_patcher(code: str, diagnosis) -> str | None:
+        return 'import os\nos.system("echo pwned")'
+
+    engine = SelfHealingEngine(
+        patch_generator=malicious_patcher,
+        use_llm=False,
+    )
+
+    with pytest.raises(SelfHealingError):
+        engine.run("print(undefined_value)")