devagent-ai 0.3.1__py3-none-any.whl

devagent/tasking.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import re
+
+from devagent.models import (
+    AcceptanceCriterion,
+    RiskLevel,
+    TaskSpec,
+    TaskType,
+)
+
+
+_CLASSIFIERS: tuple[tuple[TaskType, tuple[str, ...]], ...] = (
+    (TaskType.BUILD_FAILURE, ("build fail", "compile error", "won't build", "does not build")),
+    (TaskType.TEST_FAILURE, ("test fail", "failing test", "pytest error")),
+    (TaskType.RUNTIME_ERROR, ("traceback", "exception", "runtime error", "crash")),
+    (TaskType.PERFORMANCE, ("performance", "optimize", "slow", "latency", "n+1")),
+    (TaskType.REFACTOR, ("refactor", "restructure", "cleanup")),
+    (TaskType.UNIT_TEST, ("add unit test", "write tests", "test coverage")),
+    (TaskType.BUG_FIX, ("fix", "bug", "incorrect", "broken", "regression")),
+    (TaskType.FEATURE, ("add ", "implement", "support ", "feature")),
+)
+
+_HIGH_RISK = {
+    "auth",
+    "authentication",
+    "authorization",
+    "permission",
+    "payment",
+    "migration",
+    "crypto",
+    "credential",
+    "public api",
+    "concurrency",
+}
+
+
+def _classify(text: str) -> TaskType:
+    lowered = text.lower()
+    for task_type, needles in _CLASSIFIERS:
+        if any(needle in lowered for needle in needles):
+            return task_type
+    return TaskType.GENERAL_ENGINEERING_TASK
+
+
+def _risk(text: str, task_type: TaskType) -> RiskLevel:
+    lowered = text.lower()
+    if any(term in lowered for term in _HIGH_RISK):
+        return RiskLevel.HIGH
+    if task_type in {TaskType.FEATURE, TaskType.PERFORMANCE, TaskType.REFACTOR}:
+        return RiskLevel.MEDIUM
+    return RiskLevel.LOW
+
+
+def compile_task(requirement: str) -> TaskSpec:
+    goal = re.sub(r"\s+", " ", requirement).strip()
+    if not goal:
+        raise ValueError("Engineering requirement cannot be empty")
+    task_type = _classify(goal)
+    code_change = task_type is not TaskType.UNIT_TEST or "only" not in goal.lower()
+    requires_tests = task_type not in {TaskType.BUILD_FAILURE, TaskType.REFACTOR}
+
+    criteria = [AcceptanceCriterion(goal), AcceptanceCriterion("No unrelated behavior changes")]
+    if task_type in {TaskType.BUG_FIX, TaskType.RUNTIME_ERROR, TaskType.TEST_FAILURE}:
+        criteria.insert(1, AcceptanceCriterion("The root cause is addressed, not merely masked"))
+        criteria.insert(2, AcceptanceCriterion("Regression coverage exercises the failing case"))
+    elif task_type is TaskType.FEATURE:
+        criteria.insert(1, AcceptanceCriterion("The feature follows existing repository conventions"))
+        criteria.insert(2, AcceptanceCriterion("Normal and relevant edge-case behavior are covered"))
+    elif task_type is TaskType.UNIT_TEST:
+        criteria.insert(1, AcceptanceCriterion("Tests assert externally meaningful behavior"))
+    if requires_tests:
+        criteria.append(AcceptanceCriterion("Relevant automated tests pass"))
+    criteria.append(AcceptanceCriterion("Final diff and independent review pass"))
+
+    return TaskSpec(
+        task_type=task_type,
+        goal=goal,
+        requires_code_change=code_change,
+        requires_tests=requires_tests,
+        acceptance_criteria=criteria,
+        risk=_risk(goal, task_type),
+    )

devagent/workspace.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+import fnmatch
+import os
+import re
+import subprocess
+import time
+from pathlib import Path
+from typing import Sequence
+
+from devagent.artifacts import RunArtifacts
+from devagent.models import FailureClass, VerificationResult
+from devagent.safety import CommandPolicy, PathPolicy, SKIP_DIRECTORIES, SafetyError, is_secret_path
+
+
+class Workspace:
+    def __init__(self, root: Path | str, artifacts: RunArtifacts, dirty_files: Sequence[str] = ()) -> None:
+        self.root = Path(root).resolve()
+        self.paths = PathPolicy(self.root)
+        self.artifacts = artifacts
+        self.dirty_files = frozenset(dirty_files)
+        self.revision = 0
+        self.modified_paths: set[str] = set()
+
+    def _relative(self, target: Path) -> str:
+        return target.relative_to(self.root).as_posix()
+
+    def _writable(self, relative: str) -> Path:
+        target = self.paths.resolve(relative)
+        normalized = self._relative(target)
+        if normalized in self.dirty_files:
+            raise SafetyError(f"Refusing to overwrite pre-existing developer modification: {normalized}")
+        return target
+
+    def list_files(self, path: str = ".", pattern: str = "*", limit: int = 250) -> list[str]:
+        base = self.paths.resolve(path, allow_missing=False)
+        candidates = [base] if base.is_file() else base.rglob("*")
+        results: list[str] = []
+        for candidate in candidates:
+            if len(results) >= min(limit, 12_000):
+                break
+            relative = candidate.relative_to(self.root)
+            try:
+                resolved = candidate.resolve()
+                resolved_relative = resolved.relative_to(self.root)
+            except (OSError, ValueError):
+                continue
+            if (
+                not resolved.is_file()
+                or any(part in SKIP_DIRECTORIES for part in relative.parts)
+                or is_secret_path(relative)
+                or is_secret_path(resolved_relative)
+            ):
+                continue
+            rendered = relative.as_posix()
+            if fnmatch.fnmatch(candidate.name, pattern) or fnmatch.fnmatch(rendered, pattern):
+                results.append(rendered)
+        return results
+
+    def read_file(self, path: str, max_chars: int = 60_000) -> str:
+        target = self.paths.resolve(path, allow_missing=False)
+        if not target.is_file() or target.stat().st_size > 2_000_000:
+            raise SafetyError(f"File is not safe bounded text: {path}")
+        try:
+            text = target.read_text(encoding="utf-8")
+        except UnicodeDecodeError as exc:
+            raise SafetyError(f"File is not UTF-8 text: {path}") from exc
+        return text[:max_chars] + (f"\n... truncated at {max_chars} characters" if len(text) > max_chars else "")
+
+    def search_text(self, query: str, path: str = ".", limit: int = 100) -> list[str]:
+        if not query.strip():
+            raise SafetyError("Search query cannot be empty")
+        matches: list[str] = []
+        for relative in self.list_files(path, "*", limit=1000):
+            try:
+                target = self.paths.resolve(relative, allow_missing=False)
+            except SafetyError:
+                continue
+            if target.stat().st_size > 2_000_000:
+                continue
+            try:
+                lines = target.read_text(encoding="utf-8").splitlines()
+            except (OSError, UnicodeDecodeError):
+                continue
+            for line_number, line in enumerate(lines, 1):
+                if query.casefold() in line.casefold():
+                    matches.append(f"{relative}:{line_number}: {line[:500]}")
+                    if len(matches) >= limit:
+                        return matches
+        return matches
+
+    def write_file(self, path: str, content: str) -> None:
+        target = self._writable(path)
+        if target.exists() and not target.is_file():
+            raise SafetyError(f"Write target is not a file: {path}")
+        self.artifacts.backup(target, relative_to=self.root)
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(content, encoding="utf-8")
+        self.revision += 1
+        self.modified_paths.add(self._relative(target))
+        self.artifacts.record("file_written", path=path, revision=self.revision)
+
+    def replace_text(self, path: str, old: str, new: str, count: int = 1) -> None:
+        if not old or count < 1:
+            raise SafetyError("replace_text requires non-empty old text and count >= 1")
+        target = self._writable(path)
+        if not target.is_file():
+            raise SafetyError(f"Replace target is not a file: {path}")
+        source = target.read_text(encoding="utf-8")
+        occurrences = source.count(old)
+        if occurrences < count:
+            raise SafetyError(f"Expected {count} exact occurrence(s), found {occurrences}: {path}")
+        self.artifacts.backup(target, relative_to=self.root)
+        target.write_text(source.replace(old, new, count), encoding="utf-8")
+        self.revision += 1
+        self.modified_paths.add(self._relative(target))
+        self.artifacts.record("text_replaced", path=path, count=count, revision=self.revision)
+
+    def run(self, command: str | Sequence[str], *, timeout: int = 300, phase: str, baseline: bool = False) -> VerificationResult:
+        argv = CommandPolicy.validate(command)
+        timeout = max(1, min(int(timeout), 1800))
+        started = time.monotonic()
+        timed_out = False
+        sandbox_home = self.artifacts.root / "command-home"
+        sandbox_home.mkdir(exist_ok=True)
+        environment = {
+            key: value
+            for key, value in os.environ.items()
+            if key in {"PATH", "LANG", "LC_ALL", "TERM", "TMPDIR", "VIRTUAL_ENV", "PYTHONPATH", "SYSTEMROOT", "WINDIR"}
+        }
+        environment.update({"HOME": str(sandbox_home), "CI": "true", "DEVAGENT_RUN_ID": self.artifacts.run_id})
+        try:
+            completed = subprocess.run(
+                argv, cwd=self.root, env=environment, capture_output=True, text=True, timeout=timeout, check=False
+            )
+            exit_code: int | None = completed.returncode
+            stdout, stderr = completed.stdout[-24_000:], completed.stderr[-24_000:]
+        except subprocess.TimeoutExpired as exc:
+            timed_out = True
+            exit_code = None
+            stdout = (exc.stdout or "")[-24_000:] if isinstance(exc.stdout, str) else ""
+            stderr = (exc.stderr or "")[-24_000:] if isinstance(exc.stderr, str) else ""
+        duration = time.monotonic() - started
+        classification = None if exit_code == 0 else classify_failure(stdout, stderr, timed_out)
+        tests_run, tests_passed = _test_counts(stdout, stderr, exit_code)
+        result = VerificationResult(
+            command=argv,
+            exit_code=exit_code,
+            duration_seconds=duration,
+            stdout=stdout,
+            stderr=stderr,
+            classification=classification,
+            revision=self.revision,
+            phase=phase,
+            timed_out=timed_out,
+            baseline=baseline,
+            tests_run=tests_run,
+            tests_passed=tests_passed,
+        )
+        self.artifacts.record("command_finished", result=result)
+        return result
+
+
+def _test_counts(stdout: str, stderr: str, exit_code: int | None) -> tuple[int | None, int | None]:
+    text = f"{stdout}\n{stderr}"
+    summary = "\n".join(text.splitlines()[-8:])
+    counts: dict[str, int] = {}
+    for value, status in re.findall(
+        r"(\d+)\s+(passed|failed|errors?|skipped|xfailed|xpassed)(?:\b|$)", summary, re.IGNORECASE
+    ):
+        normalized = "error" if status.casefold().startswith("error") else status.casefold()
+        counts[normalized] = max(counts.get(normalized, 0), int(value))
+    if counts:
+        tests_run = sum(counts.get(name, 0) for name in ("passed", "failed", "error", "skipped", "xfailed", "xpassed"))
+        return tests_run, counts.get("passed", 0)
+    unittest_match = re.search(r"Ran\s+(\d+)\s+tests?", text)
+    if unittest_match:
+        tests_run = int(unittest_match.group(1))
+        return tests_run, tests_run if exit_code == 0 else None
+    return None, None
+
+
+def classify_failure(stdout: str, stderr: str, timed_out: bool = False) -> FailureClass:
+    if timed_out:
+        return FailureClass.TIMEOUT
+    text = f"{stdout}\n{stderr}".lower()
+    patterns = (
+        (FailureClass.SYNTAX_ERROR, ("syntaxerror", "syntax error")),
+        (FailureClass.IMPORT_ERROR, ("importerror", "modulenotfounderror", "cannot find module", "no module named")),
+        (FailureClass.TYPE_ERROR, ("typeerror", "type error", "mypy")),
+        (FailureClass.ASSERTION_FAILURE, ("assertionerror", "assertion failed", " failed")),
+        (FailureClass.DEPENDENCY_ERROR, ("command not found", "could not resolve", "package is not installed")),
+        (FailureClass.BUILD_ERROR, ("build failed", "compilation failed", "linker")),
+        (FailureClass.ENVIRONMENT_ERROR, ("permission denied", "connection refused", "credentials", "not installed")),
+    )
+    for classification, needles in patterns:
+        if any(needle in text for needle in needles):
+            return classification
+    return FailureClass.UNKNOWN

devagent/worktree.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class WorktreeSelection:
+    root: Path
+    isolated: bool
+    reason: str
+    creation_failed: bool = False
+
+
+def _repository_identifier(source_root: Path) -> str:
+    identity = str(source_root.resolve()).encode("utf-8", errors="surrogatepass")
+    return "repo-" + hashlib.sha256(identity).hexdigest()[:20]
+
+
+def _state_root() -> Path:
+    configured = os.environ.get("XDG_STATE_HOME")
+    if configured:
+        return Path(configured).expanduser().resolve()
+    return (Path.home() / ".local" / "state").resolve()
+
+
+def _active_worktrees(source_root: Path) -> tuple[list[Path], str | None]:
+    try:
+        completed = subprocess.run(
+            ["git", "worktree", "list", "--porcelain"],
+            cwd=source_root,
+            capture_output=True,
+            text=True,
+            timeout=15,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return [], str(exc)
+    if completed.returncode != 0:
+        reason = completed.stderr.strip() or completed.stdout.strip() or "git worktree list failed"
+        return [], reason
+    return (
+        [
+            Path(line.removeprefix("worktree ")).resolve()
+            for line in completed.stdout.splitlines()
+            if line.startswith("worktree ")
+        ],
+        None,
+    )
+
+
+def select_worktree(
+    source_root: Path,
+    run_id: str,
+    *,
+    enabled: bool,
+    git_head: str | None,
+    dirty_files: list[str],
+    state_root: Path | None = None,
+) -> WorktreeSelection:
+    """Create a retained detached worktree outside every active Git worktree."""
+    source_root = source_root.expanduser().resolve()
+    if not enabled:
+        return WorktreeSelection(source_root, False, "isolation disabled by caller")
+    if not git_head:
+        return WorktreeSelection(source_root, False, "repository is not a Git worktree")
+    if dirty_files:
+        return WorktreeSelection(
+            source_root,
+            False,
+            "repository has pre-existing changes; dirty files remain protected",
+        )
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}", run_id):
+        return WorktreeSelection(
+            source_root,
+            False,
+            "isolation unavailable: run identifier is not a safe path segment",
+            True,
+        )
+
+    base = (state_root or _state_root()).expanduser().resolve()
+    destination = (
+        base / "devagent" / "worktrees" / _repository_identifier(source_root) / run_id
+    ).resolve()
+    active_worktrees, enumeration_error = _active_worktrees(source_root)
+    if enumeration_error is not None:
+        return WorktreeSelection(
+            source_root,
+            False,
+            f"isolation unavailable: cannot enumerate active worktrees: {enumeration_error}",
+            True,
+        )
+    if any(
+        destination == active or destination.is_relative_to(active)
+        for active in active_worktrees
+    ):
+        return WorktreeSelection(
+            source_root,
+            False,
+            "isolation unavailable: retained worktree destination is inside an active worktree",
+            True,
+        )
+    if destination.exists():
+        return WorktreeSelection(
+            source_root,
+            False,
+            "isolation unavailable: retained worktree destination already exists",
+            True,
+        )
+    try:
+        destination.parent.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:
+        return WorktreeSelection(
+            source_root,
+            False,
+            f"isolation unavailable: cannot create retained worktree parent: {exc}",
+            True,
+        )
+    try:
+        completed = subprocess.run(
+            ["git", "worktree", "add", "--detach", str(destination), git_head],
+            cwd=source_root,
+            capture_output=True,
+            text=True,
+            timeout=30,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return WorktreeSelection(
+            source_root,
+            False,
+            f"isolation unavailable: git worktree add failed safely: {exc}",
+            True,
+        )
+    if completed.returncode != 0:
+        reason = completed.stderr.strip() or completed.stdout.strip() or "git worktree add failed"
+        return WorktreeSelection(
+            source_root,
+            False,
+            f"isolation unavailable: {reason}",
+            True,
+        )
+    return WorktreeSelection(
+        destination,
+        True,
+        "clean Git HEAD isolated in a retained external detached worktree",
+    )