devagent-ai 0.3.1__py3-none-any.whl

agent/__init__.py

@@ -0,0 +1,5 @@
+"""Compatibility imports for the pre-0.2 package layout."""
+
+from devagent import __version__
+
+__all__ = ["__version__"]

agent/llm.py

@@ -0,0 +1,6 @@
+"""Compatibility exports for provider abstractions."""
+
+from devagent.providers import ModelProvider as LLMClient
+from devagent.providers import ProviderError as LLMError
+
+__all__ = ["LLMClient", "LLMError"]

agent/loop.py

@@ -0,0 +1,16 @@
+"""Compatibility wrapper around the deterministic DevAgent orchestrator."""
+
+from pathlib import Path
+from typing import Optional
+
+from devagent.config import ProviderConfig, load_config
+from devagent.orchestrator import run_devagent
+from devagent.providers import create_provider
+
+
+def run_bugfix_loop(repo_path: str, task: str, max_steps: int = 8, provider: Optional[str] = None) -> str:
+    del max_steps  # The deterministic lifecycle owns bounded correction budgets.
+    configured = load_config()
+    selected = ProviderConfig(provider or configured.provider, configured.model, configured.base_url, configured.api_key_env, configured.timeout_seconds)
+    _, report = run_devagent(Path(repo_path), task, create_provider(selected))
+    return report

agent/memory.py

@@ -0,0 +1,5 @@
+"""Compatibility export for repository memory."""
+
+from devagent.memory import RepositoryMemory as AgentMemory
+
+__all__ = ["AgentMemory"]

agent/prompts.py

@@ -0,0 +1,3 @@
+"""Prompts now use strict state-specific schemas in :mod:`devagent.orchestrator`."""
+
+SYSTEM_PROMPT = "DevAgent uses deterministic state-specific JSON schemas."

agent/tools.py

@@ -0,0 +1,6 @@
+"""Compatibility exports for workspace safety types."""
+
+from devagent.safety import SafetyError as ToolError
+from devagent.workspace import Workspace as WorkspaceTools
+
+__all__ = ["ToolError", "WorkspaceTools"]

devagent/__init__.py

@@ -0,0 +1,3 @@
+"""DevAgent: evidence-driven local software engineering automation."""
+
+__version__ = "0.3.1"

devagent/__main__.py

@@ -0,0 +1,4 @@
+from devagent.cli import main
+
+raise SystemExit(main())
+

devagent/artifacts.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import json
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+from secrets import token_hex
+from typing import Any
+
+from devagent.models import jsonable
+
+
+def new_run_id() -> str:
+    return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ-") + token_hex(3)
+
+
+class RunArtifacts:
+    def __init__(self, repository_root: Path | str, run_id: str | None = None) -> None:
+        self.repository_root = Path(repository_root).resolve()
+        self.run_id = run_id or new_run_id()
+        self.root = self.repository_root / ".devagent" / "runs" / self.run_id
+        self.backups = self.root / "backups"
+        self.backups.mkdir(parents=True, exist_ok=False)
+        self.observations = self.root / "observations.jsonl"
+        self.verification = self.root / "verification.json"
+        self.report = self.root / "report.json"
+
+    def write_json(self, name: str, value: Any) -> None:
+        target = self.root / name
+        target.write_text(json.dumps(jsonable(value), indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+    def record(self, event: str, **data: Any) -> None:
+        entry = {"timestamp": datetime.now(timezone.utc).isoformat(), "event": event, **jsonable(data)}
+        with self.observations.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(entry, sort_keys=True) + "\n")
+
+    def backup(self, target: Path, *, relative_to: Path | None = None) -> Path | None:
+        if not target.exists():
+            return None
+        relative = target.resolve().relative_to((relative_to or self.repository_root).resolve())
+        destination = self.backups / relative
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        if not destination.exists():
+            shutil.copy2(target, destination)
+            self.record("backup_created", path=relative.as_posix(), backup=str(destination))
+        return destination

devagent/cli.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Sequence
+
+from devagent import __version__
+from devagent.config import ProviderConfig, config_path, load_config, save_config
+from devagent.models import Outcome
+from devagent.orchestrator import run_devagent
+from devagent.providers import ProviderError, create_provider
+from devagent.safety import is_secret_path
+
+
+def _top_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="devagent", description="Evidence-driven local software engineering agent")
+    parser.add_argument("--version", action="version", version=f"DevAgent {__version__}")
+    parser.add_argument("task", nargs="?", help="Engineering requirement; reads stdin or prompts when omitted")
+    parser.add_argument("--repo", "-r", type=Path, default=Path.cwd(), help="Target repository (default: current directory)")
+    parser.add_argument("--input", "-i", type=Path, help="Read the requirement/error context from a file")
+    parser.add_argument("--provider", choices=("openai", "anthropic", "claude", "xai", "grok", "compatible"))
+    parser.add_argument("--model")
+    parser.add_argument("--base-url")
+    parser.add_argument("--verbose", action="store_true", help="Show state transitions")
+    parser.add_argument("--no-isolation", action="store_true", help="Work in place instead of creating a local detached worktree")
+    return parser
+
+
+def _setup_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="devagent setup", description="Configure the default model provider")
+    parser.add_argument("--provider", choices=("openai", "anthropic", "xai", "compatible"), default="openai")
+    parser.add_argument("--model")
+    parser.add_argument("--base-url")
+    parser.add_argument("--api-key-env")
+    return parser
+
+
+def _defaults(provider: str) -> tuple[str, str]:
+    provider = {"claude": "anthropic", "grok": "xai"}.get(provider, provider)
+    return {
+        "openai": ("gpt-5", "OPENAI_API_KEY"),
+        "anthropic": ("claude-sonnet-4-20250514", "ANTHROPIC_API_KEY"),
+        "xai": ("grok-4", "XAI_API_KEY"),
+        "compatible": ("local-model", "DEVAGENT_API_KEY"),
+    }[provider]
+
+
+def _setup(argv: Sequence[str]) -> int:
+    args = _setup_parser().parse_args(argv)
+    model, key_env = _defaults(args.provider)
+    target = save_config(ProviderConfig(args.provider, args.model or model, args.base_url, args.api_key_env or key_env))
+    print(f"Configured {args.provider} in {target}")
+    print(f"API keys are not stored; set {args.api_key_env or key_env} in your environment.")
+    return 0
+
+
+def _doctor() -> int:
+    config = load_config()
+    checks = {
+        "git": shutil.which("git") is not None,
+        "configuration": config_path().is_file(),
+        "provider_sdk": importlib.util.find_spec("anthropic" if config.provider in {"anthropic", "claude"} else "openai") is not None,
+        "api_key": config.provider == "compatible" or not config.api_key_env or bool(os.getenv(config.api_key_env)),
+    }
+    print("DEVAGENT DOCTOR")
+    for name, okay in checks.items():
+        print(f"{'OK' if okay else 'WARN'}  {name}")
+    if not checks["configuration"]:
+        print("Run `devagent setup` before a cloud-provider engineering run.")
+    return 0
+
+
+def _status(repo: Path) -> int:
+    runs = repo.resolve() / ".devagent" / "runs"
+    reports = sorted(runs.glob("*/report.json")) if runs.is_dir() else []
+    if not reports:
+        print("No DevAgent runs found for this repository.")
+        return 0
+    latest = reports[-1]
+    try:
+        data = json.loads(latest.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        print(f"Latest run report is unreadable: {latest}")
+        return 1
+    print(f"Run: {data.get('run_id', latest.parent.name)}")
+    print(f"Status: {data.get('outcome', 'UNKNOWN')}")
+    print(f"Report: {latest}")
+    return 0
+
+
+def _requirement(args: argparse.Namespace) -> str:
+    if args.input:
+        if is_secret_path(args.input):
+            raise ValueError("Refusing to read a sensitive input file")
+        if not args.input.is_file() or args.input.stat().st_size > 2_000_000:
+            raise ValueError("Input must be a bounded local text file")
+        return args.input.read_text(encoding="utf-8").strip()
+    if args.task:
+        return args.task.strip()
+    if not sys.stdin.isatty():
+        return sys.stdin.read(2_000_001).strip()
+    return input("Engineering requirement: ").strip()
+
+
+def _run(argv: Sequence[str]) -> int:
+    args = _top_parser().parse_args(argv)
+    try:
+        requirement = _requirement(args)
+        if not requirement:
+            raise ValueError("Engineering requirement cannot be empty")
+        if not args.repo.resolve().is_dir():
+            raise ValueError(f"Repository does not exist: {args.repo}")
+        configured = load_config()
+        selected_provider = args.provider or configured.provider
+        if args.provider and args.provider != configured.provider:
+            default_model, default_key_env = _defaults(args.provider)
+        else:
+            default_model, default_key_env = configured.model, configured.api_key_env
+        config = ProviderConfig(
+            provider=selected_provider,
+            model=args.model or default_model,
+            base_url=args.base_url or configured.base_url,
+            api_key_env=default_key_env,
+            timeout_seconds=configured.timeout_seconds,
+        )
+        print("DevAgent is working...")
+        from devagent.orchestrator import DevAgent
+        from devagent.report import render_report
+
+        result = DevAgent(
+            create_provider(config),
+            isolate=not args.no_isolation,
+            verbose=args.verbose,
+            status=print,
+        ).run(args.repo, requirement)
+        report = render_report(result)
+        print(report)
+        return {Outcome.VERIFIED: 0, Outcome.PARTIALLY_VERIFIED: 2, Outcome.BLOCKED: 1}[result.outcome]
+    except (ValueError, OSError, ProviderError) as exc:
+        print(f"DevAgent failed: {exc}", file=sys.stderr)
+        return 1
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    arguments = list(sys.argv[1:] if argv is None else argv)
+    if arguments and arguments[0] == "setup":
+        return _setup(arguments[1:])
+    if arguments and arguments[0] == "doctor":
+        argparse.ArgumentParser(prog="devagent doctor", description="Check local DevAgent readiness").parse_args(arguments[1:])
+        return _doctor()
+    if arguments and arguments[0] == "status":
+        parser = argparse.ArgumentParser(prog="devagent status", description="Show the latest local run")
+        parser.add_argument("--repo", "-r", type=Path, default=Path.cwd())
+        return _status(parser.parse_args(arguments[1:]).repo)
+    return _run(arguments)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

devagent/config.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import os
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # pragma: no cover - Python 3.10 only
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+@dataclass(frozen=True)
+class ProviderConfig:
+    provider: str = "openai"
+    model: str = "gpt-5"
+    base_url: str | None = None
+    api_key_env: str = "OPENAI_API_KEY"
+    timeout_seconds: int = 120
+
+
+def config_path() -> Path:
+    override = os.getenv("DEVAGENT_CONFIG")
+    if override:
+        return Path(override).expanduser()
+    base = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
+    return base / "devagent" / "config.toml"
+
+
+def load_config(path: Path | None = None) -> ProviderConfig:
+    target = path or config_path()
+    data: dict[str, Any] = {}
+    if target.is_file():
+        with target.open("rb") as handle:
+            loaded = tomllib.load(handle)
+        data = loaded.get("provider", loaded)
+    provider = os.getenv("DEVAGENT_PROVIDER", str(data.get("name", "openai"))).lower()
+    defaults = {
+        "openai": ("gpt-5", "OPENAI_API_KEY"),
+        "anthropic": ("claude-sonnet-4-20250514", "ANTHROPIC_API_KEY"),
+        "claude": ("claude-sonnet-4-20250514", "ANTHROPIC_API_KEY"),
+        "xai": ("grok-4", "XAI_API_KEY"),
+        "grok": ("grok-4", "XAI_API_KEY"),
+        "compatible": ("local-model", "DEVAGENT_API_KEY"),
+        "fake": ("fake", ""),
+    }
+    default_model, default_env = defaults.get(provider, defaults["compatible"])
+    return ProviderConfig(
+        provider=provider,
+        model=os.getenv("DEVAGENT_MODEL", str(data.get("model", default_model))),
+        base_url=os.getenv("DEVAGENT_BASE_URL") or data.get("base_url"),
+        api_key_env=str(data.get("api_key_env", default_env)),
+        timeout_seconds=int(data.get("timeout_seconds", 120)),
+    )
+
+
+def save_config(config: ProviderConfig, path: Path | None = None) -> Path:
+    target = path or config_path()
+    target.parent.mkdir(parents=True, exist_ok=True)
+    lines = [
+        "[provider]",
+        f"name = {json.dumps(config.provider)}",
+        f"model = {json.dumps(config.model)}",
+        f"api_key_env = {json.dumps(config.api_key_env)}",
+        f"timeout_seconds = {config.timeout_seconds}",
+    ]
+    if config.base_url:
+        lines.append(f"base_url = {json.dumps(config.base_url)}")
+    target.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    return target