codealmanac 0.1.0.dev0__py3-none-any.whl

codealmanac/integrations/command.py

@@ -0,0 +1,56 @@
+import subprocess
+from pathlib import Path
+from typing import Protocol
+
+from codealmanac.core.models import CodeAlmanacModel
+
+
+class CommandResult(CodeAlmanacModel):
+    returncode: int
+    stdout: str = ""
+    stderr: str = ""
+
+
+class CommandRunner(Protocol):
+    def run(
+        self,
+        command: str,
+        args: tuple[str, ...],
+        cwd: Path,
+        timeout_seconds: int,
+        stdin: str | None = None,
+    ) -> CommandResult:
+        """Run a local command and return captured text output."""
+
+
+class SubprocessCommandRunner:
+    def run(
+        self,
+        command: str,
+        args: tuple[str, ...],
+        cwd: Path,
+        timeout_seconds: int,
+        stdin: str | None = None,
+    ) -> CommandResult:
+        completed = subprocess.run(
+            (command, *args),
+            cwd=cwd,
+            text=True,
+            input=stdin,
+            capture_output=True,
+            timeout=timeout_seconds,
+            check=False,
+        )
+        return CommandResult(
+            returncode=completed.returncode,
+            stdout=completed.stdout,
+            stderr=completed.stderr,
+        )
+
+
+def first_line(*values: str) -> str:
+    for value in values:
+        lines = [line.strip() for line in value.splitlines() if line.strip()]
+        if lines:
+            return lines[0]
+    return ""

codealmanac/integrations/harnesses/__init__.py

@@ -0,0 +1,7 @@
+from codealmanac.integrations.harnesses.claude.adapter import ClaudeCliHarnessAdapter
+from codealmanac.integrations.harnesses.codex.adapter import CodexCliHarnessAdapter
+from codealmanac.services.harnesses.ports import HarnessAdapter
+
+
+def default_harness_adapters() -> tuple[HarnessAdapter, ...]:
+    return (ClaudeCliHarnessAdapter(), CodexCliHarnessAdapter())

codealmanac/integrations/harnesses/claude/__init__.py

@@ -0,0 +1 @@
+"""Claude Code CLI harness adapter."""

codealmanac/integrations/harnesses/claude/adapter.py

@@ -0,0 +1,217 @@
+import subprocess
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from codealmanac.core.text import required_text
+from codealmanac.integrations.command import (
+    CommandResult,
+    CommandRunner,
+    SubprocessCommandRunner,
+    first_line,
+)
+from codealmanac.integrations.harnesses.git_status import (
+    changed_paths,
+    git_status_snapshot,
+    parse_git_status_paths,
+)
+from codealmanac.services.harnesses.models import (
+    HarnessKind,
+    HarnessReadiness,
+    HarnessRunResult,
+    HarnessRunStatus,
+    HarnessTranscriptRef,
+    terminal_harness_event,
+)
+from codealmanac.services.harnesses.requests import RunHarnessRequest
+
+CLAUDE_COMMAND = "claude"
+CLAUDE_RUN_TIMEOUT_SECONDS = 900
+CLAUDE_STATUS_TIMEOUT_SECONDS = 10
+CLAUDE_ALLOWED_TOOLS = "Read,Write,Edit,MultiEdit,Glob,Grep,LS"
+
+
+class ClaudeAuthStatus(BaseModel):
+    model_config = ConfigDict(extra="ignore", frozen=True)
+
+    logged_in: bool = Field(validation_alias="loggedIn")
+    auth_method: str | None = Field(default=None, validation_alias="authMethod")
+
+    @classmethod
+    def from_json(cls, value: str) -> "ClaudeAuthStatus":
+        return cls.model_validate_json(value)
+
+
+class ClaudeCliResult(BaseModel):
+    model_config = ConfigDict(extra="ignore", frozen=True)
+
+    type: str
+    subtype: str | None = None
+    is_error: bool = False
+    result: str
+    session_id: str | None = None
+
+    @field_validator("result")
+    @classmethod
+    def require_result(cls, value: str) -> str:
+        return required_text(value, "Claude result")
+
+
+class ClaudeCliHarnessAdapter:
+    kind = HarnessKind.CLAUDE
+
+    def __init__(
+        self,
+        runner: CommandRunner | None = None,
+        command: str = CLAUDE_COMMAND,
+        run_timeout_seconds: int = CLAUDE_RUN_TIMEOUT_SECONDS,
+        status_timeout_seconds: int = CLAUDE_STATUS_TIMEOUT_SECONDS,
+    ):
+        self.runner = runner or SubprocessCommandRunner()
+        self.command = command
+        self.run_timeout_seconds = run_timeout_seconds
+        self.status_timeout_seconds = status_timeout_seconds
+
+    def check(self) -> HarnessReadiness:
+        try:
+            result = self.runner.run(
+                self.command,
+                ("auth", "status"),
+                Path.cwd(),
+                self.status_timeout_seconds,
+            )
+        except FileNotFoundError:
+            return HarnessReadiness(
+                kind=self.kind,
+                available=False,
+                message="claude not found on PATH",
+            )
+        except subprocess.TimeoutExpired:
+            return HarnessReadiness(
+                kind=self.kind,
+                available=False,
+                message="claude auth status timed out",
+            )
+        if result.returncode != 0:
+            return HarnessReadiness(
+                kind=self.kind,
+                available=False,
+                message=first_line(result.stderr, result.stdout)
+                or f"claude auth status exited {result.returncode}",
+            )
+        try:
+            status = ClaudeAuthStatus.from_json(result.stdout)
+        except ValueError as error:
+            return HarnessReadiness(
+                kind=self.kind,
+                available=False,
+                message=str(error),
+            )
+        if not status.logged_in:
+            return HarnessReadiness(
+                kind=self.kind,
+                available=False,
+                message="claude is not logged in",
+            )
+        return HarnessReadiness(
+            kind=self.kind,
+            available=True,
+            message=status.auth_method or "claude authenticated",
+        )
+
+    def run(self, request: RunHarnessRequest) -> HarnessRunResult:
+        before = git_status_snapshot(self.runner, request.cwd)
+        try:
+            result = self.runner.run(
+                self.command,
+                claude_print_args(),
+                request.cwd,
+                self.run_timeout_seconds,
+                request.prompt,
+            )
+        except FileNotFoundError:
+            return failed_result("claude not found on PATH")
+        except subprocess.TimeoutExpired:
+            return failed_result("claude run timed out")
+        after = git_status_snapshot(self.runner, request.cwd)
+        changed_files = changed_paths(request.cwd, before, after)
+        if result.returncode != 0:
+            return failed_result(
+                first_line(result.stderr, result.stdout)
+                or f"claude exited {result.returncode}",
+                changed_files,
+            )
+        try:
+            parsed = ClaudeCliResult.model_validate_json(result.stdout)
+        except ValueError as error:
+            return failed_result(
+                f"claude returned invalid JSON: {error}",
+                changed_files,
+            )
+        transcript = claude_transcript_ref(parsed.session_id)
+        if parsed.is_error or parsed.subtype not in {None, "success"}:
+            return failed_result(parsed.result, changed_files, transcript)
+        return HarnessRunResult(
+            kind=self.kind,
+            status=HarnessRunStatus.SUCCEEDED,
+            output_text=parsed.result,
+            summary=first_line(parsed.result),
+            changed_files=changed_files,
+            transcript=transcript,
+            events=(
+                terminal_harness_event(
+                    self.kind,
+                    HarnessRunStatus.SUCCEEDED,
+                    parsed.result,
+                ),
+            ),
+        )
+
+
+def claude_print_args() -> tuple[str, ...]:
+    return (
+        "-p",
+        "--output-format",
+        "json",
+        "--no-session-persistence",
+        "--permission-mode",
+        "acceptEdits",
+        "--tools",
+        CLAUDE_ALLOWED_TOOLS,
+    )
+
+
+def failed_result(
+    output_text: str,
+    changed_files: tuple[Path, ...] = (),
+    transcript: HarnessTranscriptRef | None = None,
+) -> HarnessRunResult:
+    return HarnessRunResult(
+        kind=HarnessKind.CLAUDE,
+        status=HarnessRunStatus.FAILED,
+        output_text=output_text,
+        changed_files=changed_files,
+        transcript=transcript,
+        events=(
+            terminal_harness_event(
+                HarnessKind.CLAUDE,
+                HarnessRunStatus.FAILED,
+                output_text,
+            ),
+        ),
+    )
+
+
+def claude_transcript_ref(session_id: str | None) -> HarnessTranscriptRef | None:
+    if session_id is None:
+        return None
+    return HarnessTranscriptRef(kind=HarnessKind.CLAUDE, session_id=session_id)
+
+
+__all__ = [
+    "CLAUDE_ALLOWED_TOOLS",
+    "ClaudeCliHarnessAdapter",
+    "CommandResult",
+    "claude_print_args",
+    "parse_git_status_paths",
+]

codealmanac/integrations/harnesses/codex/__init__.py

@@ -0,0 +1,3 @@
+from codealmanac.integrations.harnesses.codex.adapter import CodexCliHarnessAdapter
+
+__all__ = ["CodexCliHarnessAdapter"]

codealmanac/integrations/harnesses/codex/adapter.py

@@ -0,0 +1,221 @@
+import subprocess
+import tempfile
+from datetime import UTC, datetime
+from pathlib import Path
+
+from codealmanac.core.paths import normalize_path
+from codealmanac.integrations.command import (
+    CommandRunner,
+    SubprocessCommandRunner,
+    first_line,
+)
+from codealmanac.integrations.harnesses.git_status import (
+    changed_paths,
+    git_status_snapshot,
+)
+from codealmanac.integrations.sources.transcripts.codex import (
+    CODEX_SESSIONS_DIR,
+    read_codex_meta,
+)
+from codealmanac.services.harnesses.models import (
+    HarnessKind,
+    HarnessReadiness,
+    HarnessRunResult,
+    HarnessRunStatus,
+    HarnessTranscriptRef,
+    terminal_harness_event,
+)
+from codealmanac.services.harnesses.requests import RunHarnessRequest
+
+CODEX_COMMAND = "codex"
+CODEX_RUN_TIMEOUT_SECONDS = 900
+CODEX_STATUS_TIMEOUT_SECONDS = 10
+
+
+class CodexCliHarnessAdapter:
+    kind = HarnessKind.CODEX
+
+    def __init__(
+        self,
+        runner: CommandRunner | None = None,
+        command: str = CODEX_COMMAND,
+        run_timeout_seconds: int = CODEX_RUN_TIMEOUT_SECONDS,
+        status_timeout_seconds: int = CODEX_STATUS_TIMEOUT_SECONDS,
+        sessions_dir: Path | None = None,
+    ):
+        self.runner = runner or SubprocessCommandRunner()
+        self.command = command
+        self.run_timeout_seconds = run_timeout_seconds
+        self.status_timeout_seconds = status_timeout_seconds
+        self.sessions_dir = sessions_dir
+
+    def check(self) -> HarnessReadiness:
+        try:
+            result = self.runner.run(
+                self.command,
+                ("login", "status"),
+                Path.cwd(),
+                self.status_timeout_seconds,
+            )
+        except FileNotFoundError:
+            return HarnessReadiness(
+                kind=self.kind,
+                available=False,
+                message="codex not found on PATH",
+            )
+        except subprocess.TimeoutExpired:
+            return HarnessReadiness(
+                kind=self.kind,
+                available=False,
+                message="codex login status timed out",
+            )
+        if result.returncode != 0:
+            return HarnessReadiness(
+                kind=self.kind,
+                available=False,
+                message=first_line(result.stderr, result.stdout)
+                or f"codex login status exited {result.returncode}",
+            )
+        return HarnessReadiness(
+            kind=self.kind,
+            available=True,
+            message=first_line(result.stdout, result.stderr) or "codex authenticated",
+        )
+
+    def run(self, request: RunHarnessRequest) -> HarnessRunResult:
+        before = git_status_snapshot(self.runner, request.cwd)
+        started_at = datetime.now(UTC)
+        try:
+            with tempfile.TemporaryDirectory(prefix="codealmanac-codex-") as tempdir:
+                output_path = Path(tempdir) / "last-message.txt"
+                result = self.runner.run(
+                    self.command,
+                    codex_exec_args(request.cwd, output_path),
+                    request.cwd,
+                    self.run_timeout_seconds,
+                    request.prompt,
+                )
+                output_text = output_file_text(output_path)
+        except FileNotFoundError:
+            return failed_result("codex not found on PATH")
+        except subprocess.TimeoutExpired:
+            return failed_result("codex run timed out")
+        after = git_status_snapshot(self.runner, request.cwd)
+        changed_files = changed_paths(request.cwd, before, after)
+        transcript = locate_codex_transcript(
+            request.cwd,
+            self.sessions_dir,
+            started_at,
+        )
+        if result.returncode != 0:
+            return failed_result(
+                first_line(result.stderr, result.stdout)
+                or f"codex exited {result.returncode}",
+                changed_files,
+                transcript,
+            )
+        if output_text == "":
+            return failed_result(
+                first_line(result.stdout, result.stderr)
+                or "codex produced no final message",
+                changed_files,
+                transcript,
+            )
+        return HarnessRunResult(
+            kind=self.kind,
+            status=HarnessRunStatus.SUCCEEDED,
+            output_text=output_text,
+            summary=first_line(output_text),
+            changed_files=changed_files,
+            transcript=transcript,
+            events=(
+                terminal_harness_event(
+                    self.kind,
+                    HarnessRunStatus.SUCCEEDED,
+                    output_text,
+                ),
+            ),
+        )
+
+
+def codex_exec_args(cwd: Path, output_path: Path) -> tuple[str, ...]:
+    return (
+        "exec",
+        "--config",
+        "mcp_servers={}",
+        "--config",
+        'approval_policy="never"',
+        "--cd",
+        str(cwd),
+        "--ephemeral",
+        "--sandbox",
+        "workspace-write",
+        "--ignore-rules",
+        "--color",
+        "never",
+        "--output-last-message",
+        str(output_path),
+        "-",
+    )
+
+
+def output_file_text(path: Path) -> str:
+    if not path.is_file():
+        return ""
+    return path.read_text(encoding="utf-8").strip()
+
+
+def failed_result(
+    output_text: str,
+    changed_files: tuple[Path, ...] = (),
+    transcript: HarnessTranscriptRef | None = None,
+) -> HarnessRunResult:
+    return HarnessRunResult(
+        kind=HarnessKind.CODEX,
+        status=HarnessRunStatus.FAILED,
+        output_text=output_text,
+        changed_files=changed_files,
+        transcript=transcript,
+        events=(
+            terminal_harness_event(
+                HarnessKind.CODEX,
+                HarnessRunStatus.FAILED,
+                output_text,
+            ),
+        ),
+    )
+
+
+def locate_codex_transcript(
+    cwd: Path,
+    sessions_dir: Path | None,
+    started_at: datetime,
+) -> HarnessTranscriptRef | None:
+    root = sessions_dir or Path.home() / CODEX_SESSIONS_DIR
+    if not root.is_dir():
+        return None
+    matches: list[tuple[datetime, Path, str]] = []
+    for path in root.rglob("*.jsonl"):
+        try:
+            modified_at = datetime.fromtimestamp(path.stat().st_mtime, UTC)
+        except OSError:
+            continue
+        if modified_at < started_at:
+            continue
+        meta = read_codex_meta(path)
+        if meta is None or meta.thread_source == "subagent":
+            continue
+        if normalize_path(Path(meta.cwd)) != normalize_path(cwd):
+            continue
+        matches.append((modified_at, path, meta.session_id))
+    if len(matches) == 0:
+        return None
+    _, transcript_path, session_id = max(
+        matches,
+        key=lambda match: (match[0], str(match[1])),
+    )
+    return HarnessTranscriptRef(
+        kind=HarnessKind.CODEX,
+        session_id=session_id,
+        transcript_path=normalize_path(transcript_path),
+    )

codealmanac/integrations/harnesses/git_status.py

@@ -0,0 +1,49 @@
+import subprocess
+from pathlib import Path
+
+from codealmanac.integrations.command import CommandRunner
+
+
+def git_status_snapshot(
+    runner: CommandRunner,
+    cwd: Path,
+) -> frozenset[Path]:
+    try:
+        result = runner.run(
+            "git",
+            ("-C", str(cwd), "status", "--porcelain=v1", "-z", "--untracked-files=all"),
+            cwd,
+            10,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return frozenset()
+    if result.returncode != 0:
+        return frozenset()
+    return frozenset(parse_git_status_paths(result.stdout))
+
+
+def parse_git_status_paths(value: str) -> tuple[Path, ...]:
+    paths: list[Path] = []
+    fields = [field for field in value.split("\0") if field]
+    skip_next = False
+    for field in fields:
+        if skip_next:
+            skip_next = False
+            continue
+        if len(field) < 4:
+            continue
+        status = field[:2]
+        path_text = field[3:]
+        paths.append(Path(path_text))
+        if status[0] in {"R", "C"} or status[1] in {"R", "C"}:
+            skip_next = True
+    return tuple(paths)
+
+
+def changed_paths(
+    cwd: Path,
+    before: frozenset[Path],
+    after: frozenset[Path],
+) -> tuple[Path, ...]:
+    changed = sorted(after - before, key=lambda item: str(item))
+    return tuple(cwd / path for path in changed)

codealmanac/integrations/sources/__init__.py

@@ -0,0 +1,29 @@
+from codealmanac.integrations.sources.filesystem import FilesystemSourceRuntimeAdapter
+from codealmanac.integrations.sources.git import GitSourceRuntimeAdapter
+from codealmanac.integrations.sources.github import GitHubSourceRuntimeAdapter
+from codealmanac.integrations.sources.transcripts import (
+    TranscriptSourceRuntimeAdapter,
+    default_transcript_discovery_adapters,
+)
+from codealmanac.integrations.sources.web import WebSourceRuntimeAdapter
+from codealmanac.services.sources.ports import SourceRuntimeAdapter
+
+
+def default_source_runtime_adapters() -> tuple[SourceRuntimeAdapter, ...]:
+    return (
+        FilesystemSourceRuntimeAdapter(),
+        GitSourceRuntimeAdapter(),
+        GitHubSourceRuntimeAdapter(),
+        TranscriptSourceRuntimeAdapter(),
+        WebSourceRuntimeAdapter(),
+    )
+
+__all__ = [
+    "FilesystemSourceRuntimeAdapter",
+    "GitSourceRuntimeAdapter",
+    "GitHubSourceRuntimeAdapter",
+    "TranscriptSourceRuntimeAdapter",
+    "WebSourceRuntimeAdapter",
+    "default_source_runtime_adapters",
+    "default_transcript_discovery_adapters",
+]

codealmanac/integrations/sources/filesystem/__init__.py

@@ -0,0 +1,5 @@
+from codealmanac.integrations.sources.filesystem.adapter import (
+    FilesystemSourceRuntimeAdapter,
+)
+
+__all__ = ["FilesystemSourceRuntimeAdapter"]