devagent-cli 3.3.0__tar.gz → 3.7.5__tar.gz

devagent_cli-3.7.5/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: devagent-cli
+Version: 3.7.5
+Summary: A local autonomous coding agent CLI powered by Ollama.
+Author: Vedant Jadhav
+License: MIT
+Keywords: ai,agent,coding,ollama,local,devagent,devagent-cli
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich
+Requires-Dist: pytest
+Requires-Dist: requests
+Requires-Dist: ollama
+Requires-Dist: faiss-cpu
+Provides-Extra: semantic
+Requires-Dist: sentence-transformers; extra == "semantic"
+Provides-Extra: lint
+Requires-Dist: flake8; extra == "lint"
+Dynamic: license-file
+
+# 🧠 DevAgent
+### Execution-Grounded Orchestration for Autonomous Local Coding.
+
+![DevAgent Showcase](readme-image.png)
+
+[**🌐 Live Site**](https://devagent-cli.vercel.app/) • [**📦 PyPI**](https://pypi.org/project/devagent-cli/) • [**📜 Docs**](https://devagent-cli.vercel.app/docs)
+
+[![PyPI version](https://badge.fury.io/py/devagent-cli.svg)](https://badge.fury.io/py/devagent-cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Ollama](https://img.shields.io/badge/Ollama-Local%20LLM-black.svg?logo=ollama)](https://ollama.ai)
+[![Safety: Sandboxed](https://img.shields.io/badge/Safety-Sandboxed-success.svg)](https://devagent-cli.vercel.app/benchmarks)
+
+**DevAgent** is a research-grade, local-first coding agent runtime designed to bridge the gap between LLM-generated logic and production-ready execution integrity.
+
+[Quick Start](#-quick-start) • [Architecture](#-high-integrity-architecture) • [Safety & Containment](#-safety-first-containment) • [Benchmarks](#-empirical-validation) • [Troubleshooting](docs/troubleshooting.md)
+
+</div>
+
+---
+
+## 🛡️ The Problem: The "LLM-Execution Gap"
+Most autonomous coding agents fail because they operate in a vacuum. They generate code that looks correct but fails at runtime due to **environment drift**, **dependency conflicts**, or **invalid execution assumptions**.
+
+DevAgent is **Execution-Grounded Orchestration**. It doesn't just guess code; it manages the entire lifecycle of a fix:
+1.  **Discovery**: Scans and maps the environment.
+2.  **Isolation**: Provisions a clean, sandboxed virtual environment.
+3.  **Repair**: Autonomously resolves missing dependencies.
+4.  **Validation**: Verifies patches against your actual test suite.
+
+---
+
+## 🏗️ High-Integrity Architecture
+DevAgent v3.4.1 implements a multi-layer orchestration stack designed for reliability over hype.
+
+```mermaid
+graph TD
+    subgraph "Orchestration Layer"
+    CLI[DevAgent CLI] --> Planner[Task Planner]
+    Planner --> Retrieval[Hierarchical Retrieval: FAISS + Ripgrep]
+    Retrieval --> Agent[ReAct Agent: Thought/Action/Observation]
+    end
+
+    subgraph "Execution Layer"
+    Agent --> Patch[Surgical Patch Engine: Line-Level Diffs]
+    Patch --> Reviewer[Self-Review Loop: APPROVED/REVISE]
+    Reviewer --> Runtime[Environment Runtime]
+    end
+
+    subgraph "The Maturity Layer"
+    Runtime --> Discovery[Auto-Dependency Discovery]
+    Discovery --> Isolation[Venv Isolation: .tmp_envs]
+    Isolation --> Repair[Autonomous Repair Loop: repair_environment]
+    Repair --> Validation[Validation Engine: pytest]
+    end
+
+    Validation -- Pass --> Apply[Apply to Root Repo]
+    Validation -- Fail --> Agent
+```
+
+---
+
+## 🚀 Quick Start
+
+### 1. Installation
+Install the CLI via PyPI. Ensure [Ollama](https://ollama.ai) is running locally.
+
+```bash
+pip install devagent-cli
+```
+
+### 2. Verify Infrastructure
+Check your local environment, connectivity, and dependency health.
+```bash
+devagent doctor
+```
+
+### 3. Run Your First Task
+Execute an autonomous fix on any repository.
+```bash
+devagent run --task "Implement input validation for the user login" --root ./my-project
+```
+
+---
+
+## ✨ Advanced Features
+
+### 🔍 Hierarchical Retrieval
+Instead of dumping your entire codebase into a context window, DevAgent uses a multi-tier search:
+- **Global Map**: Scans the file structure to identify relevant modules.
+- **Semantic Tier**: FAISS-powered vector search for conceptual matching.
+- **Precision Tier**: Ripgrep for exact symbol/error discovery.
+
+### 🏖️ Environment Isolation & Repair
+DevAgent is the first local agent to treat the environment as a first-class citizen. It detects `requirements.txt` or `pyproject.toml`, creates an isolated `.tmp_envs/` runtime, and **autonomously installs missing packages** if it encounters a `ModuleNotFoundError`.
+
+### 🩹 Surgical Patch Engine
+Most agents ruin git history by rewriting entire files. DevAgent generates **line-level unified diffs**, applying only the necessary changes while preserving your code style, comments, and structure.
+
+---
+
+## 🔐 Safety-First Containment
+We built DevAgent for engineers who care about their host systems.
+- **Dry-Run Mode**: Visualize every change before it happens.
+- **Atomic Snapshots**: A safety restore point is created before every execution.
+- **Instant Rollback**: Revert any agent intervention with `devagent rollback`.
+- **Sandbox Isolation**: Every run is contained in a separate workspace until validation passes 100%.
+
+---
+
+## 📊 Empirical Validation
+We don't fake our success rates. DevAgent is evaluated against a public, messy benchmark suite.
+
+| Metric | Result | Infrastructure Status |
+| :--- | :--- | :--- |
+| **Dependency Repair** | 95% | ✅ Production Ready |
+| **Unit Bugfixes** | 80% | ✅ Highly Reliable |
+| **Refactoring** | 20% | 📈 Improving (Model Bounded) |
+| **Isolation Safety** | 100% | ✅ Absolute Containment |
+
+> **Full Report**: [v3.4.1 Benchmark Analysis](docs/benchmarks.md)
+
+---
+
+## 🤝 Contributing
+Built with a focus on **Systems Thinking**. PRs that improve orchestration reliability, environment detection, or patch precision are highly encouraged.
+
+```bash
+# Clone and Install in Editable Mode
+git clone https://github.com/VedantJadhav701/Developer-Code-Intelligence-Agent.git
+pip install -e .
+```
+
+---
+
+<div align="center">
+**DevAgent — Local-First. Execution-Grounded. Infrastructure-Grade.**
+</div>

devagent_cli-3.7.5/README.md

@@ -0,0 +1,137 @@
+# 🧠 DevAgent
+### Execution-Grounded Orchestration for Autonomous Local Coding.
+
+![DevAgent Showcase](readme-image.png)
+
+[**🌐 Live Site**](https://devagent-cli.vercel.app/) • [**📦 PyPI**](https://pypi.org/project/devagent-cli/) • [**📜 Docs**](https://devagent-cli.vercel.app/docs)
+
+[![PyPI version](https://badge.fury.io/py/devagent-cli.svg)](https://badge.fury.io/py/devagent-cli)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Ollama](https://img.shields.io/badge/Ollama-Local%20LLM-black.svg?logo=ollama)](https://ollama.ai)
+[![Safety: Sandboxed](https://img.shields.io/badge/Safety-Sandboxed-success.svg)](https://devagent-cli.vercel.app/benchmarks)
+
+**DevAgent** is a research-grade, local-first coding agent runtime designed to bridge the gap between LLM-generated logic and production-ready execution integrity.
+
+[Quick Start](#-quick-start) • [Architecture](#-high-integrity-architecture) • [Safety & Containment](#-safety-first-containment) • [Benchmarks](#-empirical-validation) • [Troubleshooting](docs/troubleshooting.md)
+
+</div>
+
+---
+
+## 🛡️ The Problem: The "LLM-Execution Gap"
+Most autonomous coding agents fail because they operate in a vacuum. They generate code that looks correct but fails at runtime due to **environment drift**, **dependency conflicts**, or **invalid execution assumptions**.
+
+DevAgent is **Execution-Grounded Orchestration**. It doesn't just guess code; it manages the entire lifecycle of a fix:
+1.  **Discovery**: Scans and maps the environment.
+2.  **Isolation**: Provisions a clean, sandboxed virtual environment.
+3.  **Repair**: Autonomously resolves missing dependencies.
+4.  **Validation**: Verifies patches against your actual test suite.
+
+---
+
+## 🏗️ High-Integrity Architecture
+DevAgent v3.4.1 implements a multi-layer orchestration stack designed for reliability over hype.
+
+```mermaid
+graph TD
+    subgraph "Orchestration Layer"
+    CLI[DevAgent CLI] --> Planner[Task Planner]
+    Planner --> Retrieval[Hierarchical Retrieval: FAISS + Ripgrep]
+    Retrieval --> Agent[ReAct Agent: Thought/Action/Observation]
+    end
+
+    subgraph "Execution Layer"
+    Agent --> Patch[Surgical Patch Engine: Line-Level Diffs]
+    Patch --> Reviewer[Self-Review Loop: APPROVED/REVISE]
+    Reviewer --> Runtime[Environment Runtime]
+    end
+
+    subgraph "The Maturity Layer"
+    Runtime --> Discovery[Auto-Dependency Discovery]
+    Discovery --> Isolation[Venv Isolation: .tmp_envs]
+    Isolation --> Repair[Autonomous Repair Loop: repair_environment]
+    Repair --> Validation[Validation Engine: pytest]
+    end
+
+    Validation -- Pass --> Apply[Apply to Root Repo]
+    Validation -- Fail --> Agent
+```
+
+---
+
+## 🚀 Quick Start
+
+### 1. Installation
+Install the CLI via PyPI. Ensure [Ollama](https://ollama.ai) is running locally.
+
+```bash
+pip install devagent-cli
+```
+
+### 2. Verify Infrastructure
+Check your local environment, connectivity, and dependency health.
+```bash
+devagent doctor
+```
+
+### 3. Run Your First Task
+Execute an autonomous fix on any repository.
+```bash
+devagent run --task "Implement input validation for the user login" --root ./my-project
+```
+
+---
+
+## ✨ Advanced Features
+
+### 🔍 Hierarchical Retrieval
+Instead of dumping your entire codebase into a context window, DevAgent uses a multi-tier search:
+- **Global Map**: Scans the file structure to identify relevant modules.
+- **Semantic Tier**: FAISS-powered vector search for conceptual matching.
+- **Precision Tier**: Ripgrep for exact symbol/error discovery.
+
+### 🏖️ Environment Isolation & Repair
+DevAgent is the first local agent to treat the environment as a first-class citizen. It detects `requirements.txt` or `pyproject.toml`, creates an isolated `.tmp_envs/` runtime, and **autonomously installs missing packages** if it encounters a `ModuleNotFoundError`.
+
+### 🩹 Surgical Patch Engine
+Most agents ruin git history by rewriting entire files. DevAgent generates **line-level unified diffs**, applying only the necessary changes while preserving your code style, comments, and structure.
+
+---
+
+## 🔐 Safety-First Containment
+We built DevAgent for engineers who care about their host systems.
+- **Dry-Run Mode**: Visualize every change before it happens.
+- **Atomic Snapshots**: A safety restore point is created before every execution.
+- **Instant Rollback**: Revert any agent intervention with `devagent rollback`.
+- **Sandbox Isolation**: Every run is contained in a separate workspace until validation passes 100%.
+
+---
+
+## 📊 Empirical Validation
+We don't fake our success rates. DevAgent is evaluated against a public, messy benchmark suite.
+
+| Metric | Result | Infrastructure Status |
+| :--- | :--- | :--- |
+| **Dependency Repair** | 95% | ✅ Production Ready |
+| **Unit Bugfixes** | 80% | ✅ Highly Reliable |
+| **Refactoring** | 20% | 📈 Improving (Model Bounded) |
+| **Isolation Safety** | 100% | ✅ Absolute Containment |
+
+> **Full Report**: [v3.4.1 Benchmark Analysis](docs/benchmarks.md)
+
+---
+
+## 🤝 Contributing
+Built with a focus on **Systems Thinking**. PRs that improve orchestration reliability, environment detection, or patch precision are highly encouraged.
+
+```bash
+# Clone and Install in Editable Mode
+git clone https://github.com/VedantJadhav701/Developer-Code-Intelligence-Agent.git
+pip install -e .
+```
+
+---
+
+<div align="center">
+**DevAgent — Local-First. Execution-Grounded. Infrastructure-Grade.**
+</div>

devagent_cli-3.7.5/devagent/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.4.1"

{devagent_cli-3.3.0 → devagent_cli-3.7.5}/devagent/app/agent.py

@@ -21,6 +21,10 @@ import re
 import os
 import time
 from typing import Any
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
 
 from devagent.app.llm import query, query_with_context
 from devagent.app.reviewer import review_code, revise_code
@@ -31,6 +35,7 @@ from devagent.app.memory import WorkingMemory, chunk_project, SemanticIndex
 from devagent.tools.search import search_code
 from devagent.tools.file_ops import read_file, write_file, list_files
 from devagent.tools.file_map import get_file_map
+from devagent.tools.env_detector import get_environment_info, repair_environment
 from devagent.tools.test_runner import run_tests
 from devagent.tools.linter import lint_code
 from devagent.tools.git_tools import git_diff, git_status
@@ -60,6 +65,8 @@ Current step: {step}/{max_steps}
 Decide the SINGLE next action. Choose ONE:
 - list_files: <relative_path>
 - get_file_map: <relative_path>
+- get_environment_info: <relative_path>
+- repair_environment: <package_name>
 - search_code: <keyword>
 - semantic_search: <query>
 - read_file: <relative_path>[:L<start>-<end>]
@@ -70,11 +77,13 @@ Decide the SINGLE next action. Choose ONE:
 - git_diff
 
 STRATEGY:
-1. START by using 'run_tests' to identify the failure.
-2. For large files (>50 lines), use 'get_file_map' FIRST to see the structure.
-3. USE 'read_file' with line ranges (e.g. file.py:L10-L50) for targeted reading.
-4. USE 'surgical_patch' for logic fixes. Format: file.py | <SEARCH> | <REPLACE>
-5. ALWAYS use full relative paths.
+1. START by using 'get_environment_info' to understand the project runtime.
+2. If tests fail with ModuleNotFoundError, use 'repair_environment' to fix the environment.
+3. USE 'run_tests' to identify logic failures.
+4. For large files (>50 lines), use 'get_file_map' FIRST to see the structure.
+5. USE 'read_file' with line ranges (e.g. file.py:L10-L50) for targeted reading.
+6. USE 'surgical_patch' for logic fixes. Format: file.py | <SEARCH> | <REPLACE>
+7. ALWAYS use full relative paths.
 
 Reply in this EXACT format (two lines only):
 THOUGHT: <your reasoning>
@@ -96,7 +105,7 @@ Fix the bug. Output ONLY the COMPLETE Python code.
 """
 
 EXTRACT_ACTION_PATTERN = re.compile(
-    r"ACTION:\s*(get_file_map|search_code|semantic_search|read_file|write_file|surgical_patch|run_tests|lint_code|list_files|git_diff)\s*:?\s*(.*)",
+    r"ACTION:\s*(get_file_map|get_environment_info|repair_environment|search_code|semantic_search|read_file|write_file|surgical_patch|run_tests|lint_code|list_files|git_diff)\s*:?\s*(.*)",
     re.IGNORECASE,
 )
 
@@ -268,8 +277,10 @@ class Agent:
 
         # STEP 2 — EXECUTE ACTION → OBSERVATION
         observation = self._execute_action(action_name, action_arg)
-        self.state.last_observation = observation
-        self.state.observations.append(observation[:2000])
+        self.state.last_observation = observation # Store and display result
+        obs_text = str(observation) if isinstance(observation, dict) else observation
+        self.state.observations.append(obs_text[:2000])
+        console.print(Panel(obs_text[:1000], title="Observation", border_style="green"))
         
         self.state.explanations.append({
             "type": "action",
@@ -329,10 +340,11 @@ class Agent:
         )
 
         # Store in history
+        obs_text = str(observation) if isinstance(observation, dict) else observation
         self.state.history.append({
             "step": step, "thought": thought,
             "action": action_name, "action_arg": action_arg,
-            "observation": observation[:500],
+            "observation": obs_text[:500],
             "review": review_text, "test_status": status,
         })
 
@@ -463,6 +475,12 @@ class Agent:
         elif action_name == "get_file_map":
             return get_file_map(action_arg, root)
 
+        elif action_name == "get_environment_info":
+            return get_environment_info(root)
+
+        elif action_name == "repair_environment":
+            return repair_environment(action_arg, root)
+
         elif action_name == "semantic_search":
             result = semantic_search(action_arg, root)
             # Try to extract file from results

{devagent_cli-3.3.0 → devagent_cli-3.7.5}/devagent/cli.py

@@ -142,7 +142,7 @@ def cmd_run(args):
     if final_state.confidence_reasons:
         console.print("\n[bold]Confidence Breakdown:[/bold]")
         for reason in final_state.confidence_reasons:
-            console.print(f"  [green]✓[/green] {reason}")
+            console.print(f"  [green]OK[/green] {reason}")
 
     # Explain Mode
     if config.explain and final_state.explanations:
@@ -187,7 +187,7 @@ def cmd_run(args):
             result = sandbox.apply_to_project()
             if result["applied"]:
                 for f in result["applied"]:
-                    console.print(f"  [green]✓[/green] {f}")
+                    console.print(f"  [green]OK[/green] {f}")
         sandbox.destroy()
 
     # Git operations
@@ -246,6 +246,14 @@ def cmd_doctor(args):
     except:
         checks.append(("[yellow]WARN[/yellow]", "FAISS not found (keyword search fallback active)"))
 
+    # Venv Check
+    try:
+        import venv
+        import ensurepip
+        checks.append(("[green]OK[/green]", "Virtual environment runtime (venv + pip) available"))
+    except:
+        checks.append(("[red]FAIL[/red]", "venv or ensurepip missing (required for Environment Isolation)"))
+
     for status, msg in checks:
         console.print(f" {status} {msg}")
     

devagent_cli-3.7.5/devagent/tools/env_detector.py

@@ -0,0 +1,44 @@
+import os
+from devagent.utils.environment import EnvironmentDetector
+
+def get_environment_info(project_path: str):
+    """
+    Detects the project environment (pip, poetry, etc.) and lists dependencies.
+    Useful for understanding what the project needs to run.
+    """
+    project_path = os.path.abspath(project_path)
+    detector = EnvironmentDetector(project_path)
+    info = detector.detect()
+    
+    # Auto-setup venv if it's the first run or fingerprint missing install_success
+    fingerprint = detector.load_fingerprint(project_path)
+    if not fingerprint or not fingerprint.get("install_success"):
+        detector.setup_isolated_env()
+        info = detector.detect() # Refresh info
+    
+    # Save fingerprint for observability
+    detector.save_fingerprint(info)
+    
+    return {
+        "status": "success",
+        "environment": {
+            "type": info.type,
+            "markers_found": info.markers,
+            "dependency_count": len(info.dependencies),
+            "dependencies": info.dependencies[:20] # Limit output
+        }
+    }
+
+def repair_environment(package_name: str, project_path: str):
+    """
+    Attempts to install a missing package into the project environment.
+    Use this if you see ModuleNotFoundError or missing dependency errors.
+    """
+    project_path = os.path.abspath(project_path)
+    detector = EnvironmentDetector(project_path)
+    success = detector.repair_dependencies(package_name)
+    
+    if success:
+        return {"status": "success", "message": f"Successfully installed {package_name}"}
+    else:
+        return {"status": "error", "message": f"Failed to install {package_name}"}

{devagent_cli-3.3.0 → devagent_cli-3.7.5}/devagent/tools/test_runner.py

@@ -45,7 +45,28 @@ def run_tests(project_root: str = ".", test_path: str = "") -> tuple[int, str]:
         tf.write(config_content)
         temp_config = tf.name
 
-    cmd = ["python", "-m", "pytest", "-v", "--tb=short", "-c", temp_config]
+    # ENVIRONMENT AWARENESS: Use venv python if available
+    python_exe = "python"
+    fingerprint_path = os.path.join(project_root, ".devagent_env.json")
+    if os.path.exists(fingerprint_path):
+        try:
+            import json
+            with open(fingerprint_path, 'r') as f:
+                data = json.load(f)
+                # Look for a valid python exe in .tmp_envs
+                env_path = os.path.join(project_root, ".tmp_envs", "validation_env")
+                if not os.path.exists(env_path):
+                    # Fallback to test_env if that's what we used in the test
+                    env_path = os.path.join(project_root, ".tmp_envs", "test_env")
+                
+                v_exe = os.path.join(env_path, "Scripts", "python.exe") if os.name == "nt" else os.path.join(env_path, "bin", "python")
+                if os.path.exists(v_exe):
+                    python_exe = v_exe
+                    print(f"  [ENV] Using isolated runtime: {python_exe}")
+        except:
+            pass
+
+    cmd = [python_exe, "-m", "pytest", "-v", "--tb=short", "-c", temp_config]
     if test_path:
         cmd.append(test_path)
     else:

devagent_cli-3.7.5/devagent/utils/environment.py

@@ -0,0 +1,129 @@
+import os
+import json
+from dataclasses import dataclass, field, asdict
+from typing import List, Optional, Dict
+
+@dataclass
+class EnvironmentInfo:
+    type: str = "unknown"  # pip, poetry, conda, etc.
+    python_version: str = "unknown"
+    dependencies: List[str] = field(default_factory=list)
+    markers: List[str] = field(default_factory=list)
+    install_success: bool = False
+    last_fingerprint: Optional[float] = None
+    failures: List[str] = field(default_factory=list)
+
+class EnvironmentDetector:
+    def __init__(self, project_path: str):
+        self.project_path = os.path.abspath(project_path)
+        self.markers = {
+            "requirements.txt": "pip",
+            "pyproject.toml": "modern/poetry/flit",
+            "poetry.lock": "poetry",
+            "Pipfile": "pipenv",
+            "environment.yml": "conda",
+            "setup.py": "setuptools"
+        }
+
+    def detect(self) -> EnvironmentInfo:
+        info = EnvironmentInfo()
+        found_markers = []
+
+        for marker, env_type in self.markers.items():
+            marker_path = os.path.join(self.project_path, marker)
+            if os.path.exists(marker_path):
+                found_markers.append(marker)
+                # Primary type detection (prioritize modern tools)
+                if info.type == "unknown" or env_type in ["poetry", "modern/poetry/flit"]:
+                    info.type = env_type
+        
+        info.markers = found_markers
+        
+        # Try to parse dependencies from common files
+        if "requirements.txt" in found_markers:
+            info.dependencies.extend(self._parse_requirements())
+        
+        return info
+
+    def _parse_requirements(self) -> List[str]:
+        req_path = os.path.join(self.project_path, "requirements.txt")
+        deps = []
+        try:
+            with open(req_path, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#"):
+                        deps.append(line)
+        except Exception:
+            pass
+        return deps
+
+    def setup_isolated_env(self, env_name: str = "validation_env") -> str:
+        """Creates a venv and installs dependencies."""
+        env_path = os.path.join(self.project_path, ".tmp_envs", env_name)
+        python_exe = os.path.join(env_path, "Scripts", "python.exe") if os.name == "nt" else os.path.join(env_path, "bin", "python")
+        
+        if os.path.exists(python_exe):
+            print(f"[ENV] Found existing virtual environment at {env_path}")
+            return python_exe
+
+        os.makedirs(os.path.dirname(env_path), exist_ok=True)
+        
+        import venv
+        import subprocess
+        
+        print(f"[ENV] Creating virtual environment at {env_path}...")
+        venv.create(env_path, with_pip=True)
+        
+        info = self.detect()
+        
+        # Install dependencies
+        if info.type == "pip":
+            req_path = os.path.join(self.project_path, "requirements.txt")
+            print(f"[ENV] Installing dependencies from {req_path}...")
+            try:
+                subprocess.check_call([python_exe, "-m", "pip", "install", "-r", req_path])
+                info.install_success = True
+            except subprocess.CalledProcessError as e:
+                info.failures.append(f"Install failed: {str(e)}")
+                info.install_success = False
+        
+        # Validate installation
+        try:
+            subprocess.check_call([python_exe, "-m", "pip", "check"])
+            print("[ENV] Runtime health check passed.")
+        except subprocess.CalledProcessError:
+            print("[ENV] Runtime health check found conflicts.")
+            info.failures.append("Dependency conflicts detected.")
+            
+        self.save_fingerprint(info)
+        return python_exe
+
+    def repair_dependencies(self, missing_package: str, env_name: str = "validation_env") -> bool:
+        """Attempts to install a missing package into the venv."""
+        env_path = os.path.join(self.project_path, ".tmp_envs", env_name)
+        python_exe = os.path.join(env_path, "Scripts", "python.exe") if os.name == "nt" else os.path.join(env_path, "bin", "python")
+        
+        if not os.path.exists(python_exe):
+            return False
+            
+        import subprocess
+        print(f"[ENV] Repairing environment: Installing missing package '{missing_package}'...")
+        try:
+            subprocess.check_call([python_exe, "-m", "pip", "install", missing_package])
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def save_fingerprint(self, info: EnvironmentInfo):
+        fingerprint_path = os.path.join(self.project_path, ".devagent_env.json")
+        with open(fingerprint_path, 'w') as f:
+            json.dump(asdict(info), f, indent=2)
+
+    @staticmethod
+    def load_fingerprint(project_path: str) -> Optional[Dict]:
+        fingerprint_path = os.path.join(project_path, ".devagent_env.json")
+        if os.path.exists(fingerprint_path):
+            with open(fingerprint_path, 'r') as f:
+                return json.load(f)
+        return None

{devagent_cli-3.3.0 → devagent_cli-3.7.5}/devagent/utils/logger.py

@@ -38,12 +38,13 @@ class AgentLogger:
         patch_summary: str = "",
     ) -> None:
         """Log a complete agent iteration step."""
+        obs_text = str(observation) if isinstance(observation, dict) else observation
         entry = {
             "timestamp": datetime.now(timezone.utc).isoformat(),
             "step": step,
             "thought": thought,
             "action": action,
-            "observation": observation[:2000],
+            "observation": obs_text[:2000],
             "review": review,
             "test_result": test_result[:2000],
             "latency": f"{latency:.2f}s" if latency else "",