codemate-team 0.1.0__py3-none-any.whl

codemate/__init__.py

@@ -0,0 +1,3 @@
+"""Codemate sequential AI team runner."""
+
+__version__ = "0.1.0"

codemate/agents.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class AgentRunInput:
+    run_id: str
+    step_id: str
+    cwd: Path
+    prompt: str
+    mode: str
+    expected_output: str
+    output_path: Path
+    raw_log_path: Path
+    schema_path: Path | None
+    config: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class AgentRunResult:
+    ok: bool
+    output_path: Path
+    raw_log_path: Path
+    exit_code: int
+
+
+class AgentAdapter:
+    def run(self, input: AgentRunInput) -> AgentRunResult:
+        raise NotImplementedError
+
+
+class CodexCliAdapter(AgentAdapter):
+    def run(self, input: AgentRunInput) -> AgentRunResult:
+        command = str(input.config.get("command", "codex"))
+        _require_executable(command)
+        args = [
+            command,
+            "exec",
+            "--cd",
+            str(input.cwd),
+            "--sandbox",
+            str(input.config.get("sandbox", "workspace-write")),
+            "--ask-for-approval",
+            str(input.config.get("approval", "never")),
+            "--output-last-message",
+            str(input.output_path),
+        ]
+        if input.schema_path and input.schema_path.exists():
+            args.extend(["--output-schema", str(input.schema_path)])
+        args.append(input.prompt)
+        return _run_process(args, input)
+
+
+class ClaudeCodeAdapter(AgentAdapter):
+    def run(self, input: AgentRunInput) -> AgentRunResult:
+        command = str(input.config.get("command", "claude"))
+        _require_executable(command)
+        permission_mode = _claude_permission_mode(input.mode, input.config)
+        output_format = str(input.config.get("output_format", "text"))
+        args = [command, "-p", input.prompt, "--permission-mode", permission_mode]
+        if output_format != "text":
+            args.extend(["--output-format", output_format])
+        result = _run_process(args, input)
+        # Claude Code streams its final answer to stdout (captured in the raw log)
+        # rather than to a dedicated output file, so derive the output ourselves.
+        if not input.output_path.read_text(errors="replace").strip():
+            raw = input.raw_log_path.read_text(errors="replace")
+            input.output_path.write_text(_extract_claude_message(raw, output_format))
+        return result
+
+
+def adapter_for(config: dict[str, Any]) -> AgentAdapter:
+    provider = str(config.get("provider", "")).lower()
+    if provider == "codex-cli":
+        return CodexCliAdapter()
+    if provider == "claude-code":
+        return ClaudeCodeAdapter()
+    raise ValueError(f"Unsupported agent provider: {provider}")
+
+
+def _extract_claude_message(raw: str, output_format: str) -> str:
+    """Pull the assistant's final message out of captured Claude Code output.
+
+    With `--output-format json` the CLI emits a result envelope; extract its
+    `result` field. Anything else (including malformed JSON) falls back to the
+    raw captured text so no output is ever silently dropped.
+    """
+    if output_format == "json":
+        try:
+            data = json.loads(raw.strip() or "{}")
+        except json.JSONDecodeError:
+            return raw
+        if isinstance(data, dict) and isinstance(data.get("result"), str):
+            return data["result"]
+    return raw
+
+
+def _claude_permission_mode(mode: str, config: dict[str, Any]) -> str:
+    if mode in {"read_only", "review_only"}:
+        return "plan"
+    if mode == "write":
+        return str(config.get("write_permission_mode", "acceptEdits"))
+    return str(config.get("default_mode", "plan"))
+
+
+def _run_process(args: list[str], input: AgentRunInput) -> AgentRunResult:
+    timeout = int(input.config.get("timeout_seconds", 900))
+    with input.raw_log_path.open("w") as raw_log:
+        try:
+            result = subprocess.run(
+                args,
+                cwd=input.cwd,
+                text=True,
+                stdout=raw_log,
+                stderr=subprocess.STDOUT,
+                timeout=timeout,
+                check=False,
+            )
+            exit_code = result.returncode
+        except subprocess.TimeoutExpired:
+            raw_log.write(f"\n[timeout after {timeout} seconds]\n")
+            exit_code = 124
+    if not input.output_path.exists():
+        input.output_path.write_text("")
+    return AgentRunResult(
+        ok=exit_code == 0,
+        output_path=input.output_path,
+        raw_log_path=input.raw_log_path,
+        exit_code=exit_code,
+    )
+
+
+def _require_executable(command: str) -> None:
+    if shutil.which(command) is None:
+        raise FileNotFoundError(f"Required agent command not found: {command}")

codemate/artifacts.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+def new_run_id() -> str:
+    return datetime.now().strftime("%Y-%m-%dT%H-%M-%S-%f")
+
+
+def latest_run_dir(root: Path) -> Path:
+    runs = root / ".team" / "runs"
+    candidates = sorted([path for path in runs.glob("*") if path.is_dir()])
+    if not candidates:
+        raise FileNotFoundError("No runs found")
+    return candidates[-1]
+
+
+@dataclass
+class RunState:
+    run_id: str
+    task: str
+    flow: str
+    status: str
+    branch: str
+    base_branch: str
+    base_head: str
+    current_step: str | None = None
+    steps: list[dict[str, Any]] = field(default_factory=list)
+    changed_files: list[str] = field(default_factory=list)
+    reason: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "run_id": self.run_id,
+            "task": self.task,
+            "flow": self.flow,
+            "status": self.status,
+            "branch": self.branch,
+            "base_branch": self.base_branch,
+            "base_head": self.base_head,
+            "current_step": self.current_step,
+            "steps": self.steps,
+            "changed_files": self.changed_files,
+            "reason": self.reason,
+        }
+
+    @classmethod
+    def from_path(cls, path: Path) -> "RunState":
+        data = json.loads(path.read_text())
+        return cls(**data)
+
+
+class RunArtifacts:
+    def __init__(self, root: Path, run_id: str) -> None:
+        self.root = root
+        self.run_id = run_id
+        self.dir = root / ".team" / "runs" / run_id
+        self.dir.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def state_path(self) -> Path:
+        return self.dir / "state.json"
+
+    def write_state(self, state: RunState) -> None:
+        self.state_path.write_text(json.dumps(state.to_dict(), indent=2) + "\n")
+
+    def write_text(self, name: str, content: str) -> Path:
+        path = self.dir / name
+        path.write_text(content)
+        return path
+
+    def read_text(self, name: str, default: str = "") -> str:
+        path = self.dir / name
+        return path.read_text() if path.exists() else default
+
+
+class RunLock:
+    def __init__(self, root: Path, run_id: str) -> None:
+        self.path = root / ".team" / "lock.json"
+        self.run_id = run_id
+
+    def __enter__(self) -> "RunLock":
+        if self.path.exists():
+            if self._is_stale():
+                self.path.unlink()
+            else:
+                raise RuntimeError(f"Another codemate run appears active: {self.path}")
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(
+            json.dumps(
+                {
+                    "run_id": self.run_id,
+                    "pid": os.getpid(),
+                    "created_at": datetime.now().isoformat(timespec="seconds"),
+                },
+                indent=2,
+            )
+            + "\n"
+        )
+        return self
+
+    def _is_stale(self) -> bool:
+        try:
+            data = json.loads(self.path.read_text())
+        except (OSError, json.JSONDecodeError):
+            return False
+        pid = data.get("pid")
+        if not isinstance(pid, int) or pid <= 0:
+            return False
+        try:
+            os.kill(pid, 0)
+        except ProcessLookupError:
+            return True
+        except PermissionError:
+            return False
+        return False
+
+    def __exit__(self, _exc_type: object, _exc: object, _tb: object) -> None:
+        if self.path.exists():
+            self.path.unlink()

codemate/cli.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import argparse
+import shutil
+import shlex
+import sys
+from pathlib import Path
+
+from .artifacts import RunState, latest_run_dir
+from .config import init_project, load_config
+from .git_tools import add_and_commit, changed_files, diff, ensure_repo, restore_paths
+from .workflow import run_task
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="codemate")
+    parser.add_argument("--root", default=".", help="Project root")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    init_parser = subparsers.add_parser("init", help="Create team.yml and .team files")
+    init_parser.add_argument("--force", action="store_true")
+
+    doctor_parser = subparsers.add_parser("doctor", help="Check local harness dependencies")
+    doctor_parser.add_argument("--flow")
+
+    run_parser = subparsers.add_parser("run", help="Run a task through the configured flow")
+    run_parser.add_argument("task", nargs="?")
+    run_parser.add_argument("--file")
+    run_parser.add_argument("--flow")
+
+    status_parser = subparsers.add_parser("status", help="Show run status")
+    status_parser.add_argument("--run-id")
+
+    logs_parser = subparsers.add_parser("logs", help="Show run logs")
+    logs_parser.add_argument("--run-id")
+    logs_parser.add_argument("--step")
+
+    subparsers.add_parser("diff", help="Show current git diff")
+
+    accept_parser = subparsers.add_parser("accept", help="Accept current run changes")
+    accept_parser.add_argument("--commit", action="store_true")
+    accept_parser.add_argument("--message", default=None)
+
+    reset_parser = subparsers.add_parser("reset", help="Reset files changed by latest run")
+    reset_parser.add_argument("--run-id")
+
+    args = parser.parse_args(argv)
+    root = Path(args.root).resolve()
+
+    try:
+        if args.command == "init":
+            return _init(root, args.force)
+        if args.command == "doctor":
+            return _doctor(root, args.flow)
+        if args.command == "run":
+            task = _read_task(args)
+            config = load_config(root)
+            state = run_task(config, task, args.flow)
+            print(_format_state(state))
+            print(f"Run artifacts: .team/runs/{state.run_id}")
+            return 0
+        if args.command == "status":
+            state = _load_state(root, args.run_id)
+            print(_format_state(state))
+            return 0
+        if args.command == "logs":
+            return _logs(root, args.run_id, args.step)
+        if args.command == "diff":
+            ensure_repo(root)
+            print(diff(root), end="")
+            return 0
+        if args.command == "accept":
+            return _accept(root, args.commit, args.message)
+        if args.command == "reset":
+            return _reset(root, args.run_id)
+    except Exception as exc:
+        print(f"codemate: error: {exc}", file=sys.stderr)
+        return 1
+    return 1
+
+
+def _init(root: Path, force: bool) -> int:
+    created = init_project(root, force=force)
+    if not created:
+        print("Team configuration is up to date.")
+        return 0
+    print("Created team configuration:")
+    for path in created:
+        print(f"- {path.relative_to(root)}")
+    return 0
+
+
+def _doctor(root: Path, flow: str | None) -> int:
+    config = load_config(root)
+    ensure_repo(root)
+    missing: list[str] = []
+    warnings: list[str] = []
+    seen: set[str] = set()
+    for step in config.flow_steps(flow):
+        if step.get("type") != "agent":
+            if step.get("type") == "command":
+                group = str(step.get("command_group"))
+                commands = config.command_group(group)
+                if not commands:
+                    warnings.append(f"command group `{group}` is empty")
+                for command in commands:
+                    executable = _first_command_token(command)
+                    if executable and shutil.which(executable) is None:
+                        missing.append(f"command group `{group}`: {executable}")
+            continue
+        agent_name = str(step.get("agent"))
+        if agent_name in seen:
+            continue
+        seen.add(agent_name)
+        command = str(config.agent(agent_name).get("command", agent_name))
+        if shutil.which(command) is None:
+            missing.append(f"{agent_name}: {command}")
+    if missing:
+        print("Missing agent commands:")
+        for item in missing:
+            print(f"- {item}")
+        return 1
+    if warnings:
+        print("Doctor passed with warnings:")
+        for item in warnings:
+            print(f"- {item}")
+        return 0
+    print("Doctor passed")
+    return 0
+
+
+def _read_task(args: argparse.Namespace) -> str:
+    if args.file:
+        return Path(args.file).read_text().strip()
+    if args.task:
+        return args.task.strip()
+    raise ValueError("Provide a task string or --file")
+
+
+def _load_state(root: Path, run_id: str | None) -> RunState:
+    run_dir = root / ".team" / "runs" / run_id if run_id else latest_run_dir(root)
+    return RunState.from_path(run_dir / "state.json")
+
+
+def _logs(root: Path, run_id: str | None, step: str | None) -> int:
+    run_dir = root / ".team" / "runs" / run_id if run_id else latest_run_dir(root)
+    state = RunState.from_path(run_dir / "state.json")
+    matches = state.steps
+    if step:
+        matches = [item for item in matches if item.get("id") == step]
+    if not matches:
+        print("No matching logs")
+        return 1
+    for item in matches:
+        path_value = item.get("raw_log") or item.get("log") or item.get("output")
+        if not path_value:
+            continue
+        path = root / str(path_value)
+        if not path.exists():
+            print(f"Missing log artifact: {path.relative_to(root)}")
+            continue
+        print(f"==> {path.relative_to(root)} <==")
+        content = path.read_text(errors="replace")
+        print(content, end="")
+        if not content.endswith("\n"):
+            print()
+    return 0
+
+
+def _accept(root: Path, commit: bool, message: str | None) -> int:
+    state = _load_state(root, None)
+    if not commit:
+        print(f"Run {state.run_id} accepted. Changes remain in the working tree.")
+        return 0
+    paths = [path for path in changed_files(root) if not path.startswith(".team/")]
+    if not paths:
+        print(f"Run {state.run_id} has no source changes to commit.")
+        return 0
+    add_and_commit(root, paths, message or f"team: accept run {state.run_id}")
+    print(f"Committed run {state.run_id}")
+    return 0
+
+
+def _reset(root: Path, run_id: str | None) -> int:
+    state = _load_state(root, run_id)
+    paths = [path for path in state.changed_files if not path.startswith(".team/")]
+    if not paths:
+        print(f"Run {state.run_id} recorded no source files to reset.")
+        return 0
+    restore_paths(root, paths)
+    for path in paths:
+        full_path = root / path
+        if full_path.exists() and path in changed_files(root):
+            try:
+                full_path.unlink()
+            except IsADirectoryError:
+                pass
+    print(f"Reset files recorded for run {state.run_id}")
+    return 0
+
+
+def _first_command_token(command: str) -> str | None:
+    try:
+        parts = shlex.split(command)
+    except ValueError:
+        return None
+    if not parts:
+        return None
+    if any(token in parts[0] for token in ("=", "/", "\\")):
+        return None
+    return parts[0]
+
+
+def _format_state(state: RunState) -> str:
+    changed = ", ".join(state.changed_files) if state.changed_files else "none"
+    reason = f"\nReason: {state.reason}" if state.reason else ""
+    return (
+        f"Run: {state.run_id}\n"
+        f"Flow: {state.flow}\n"
+        f"Status: {state.status}\n"
+        f"Branch: {state.branch}\n"
+        f"Changed files: {changed}"
+        f"{reason}"
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codemate/commands.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def run_command_group(
+    root: Path, commands: list[str], log_path: Path, timeout_seconds: int = 900
+) -> tuple[bool, str | None, int]:
+    if not commands:
+        log_path.write_text("No commands configured.\n")
+        return True, None, 0
+
+    with log_path.open("w") as log:
+        for command in commands:
+            log.write(f"$ {command}\n")
+            log.flush()
+            try:
+                result = subprocess.run(
+                    command,
+                    cwd=root,
+                    shell=True,
+                    text=True,
+                    stdout=log,
+                    stderr=subprocess.STDOUT,
+                    timeout=timeout_seconds,
+                    check=False,
+                )
+                exit_code = result.returncode
+            except subprocess.TimeoutExpired:
+                exit_code = 124
+                log.write(f"\n[timeout after {timeout_seconds} seconds]\n")
+            log.write(f"\n[exit_code={exit_code}]\n")
+            if exit_code != 0:
+                return False, command, exit_code
+    return True, None, 0