algocode-agent 0.1.0__py3-none-any.whl

algocode/__init__.py

@@ -0,0 +1,5 @@
+"""Algocode package."""
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

algocode/__main__.py

@@ -0,0 +1,4 @@
+from algocode.cli.main import main
+
+if __name__ == "__main__":
+    main()

algocode/acceptance/__init__.py

@@ -0,0 +1,12 @@
+"""P0 acceptance and release gate."""
+
+from algocode.acceptance.service import AcceptanceService, render_acceptance_markdown
+from algocode.acceptance.types import AcceptanceReport, GateCheck, Requirement
+
+__all__ = [
+    "AcceptanceReport",
+    "AcceptanceService",
+    "GateCheck",
+    "Requirement",
+    "render_acceptance_markdown",
+]

algocode/acceptance/matrix.py

@@ -0,0 +1,69 @@
+"""Requirement traceability matrix loading and validation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+from algocode.acceptance.types import Requirement
+
+DEFAULT_MATRIX = Path("docs/acceptance/p0-requirements.yaml")
+
+
+def load_requirements(root: str | Path, path: str | Path | None = None) -> tuple[Requirement, ...]:
+    root_path = Path(root).resolve()
+    matrix_path = Path(path) if path is not None else DEFAULT_MATRIX
+    if not matrix_path.is_absolute():
+        matrix_path = root_path / matrix_path
+    try:
+        raw = yaml.safe_load(matrix_path.read_text(encoding="utf-8"))
+    except (OSError, yaml.YAMLError) as exc:
+        raise ValueError(f"failed to load acceptance matrix {matrix_path}: {exc}") from exc
+    if not isinstance(raw, dict):
+        raise ValueError("acceptance matrix must be a YAML mapping")
+    rows = raw.get("requirements")
+    if not isinstance(rows, list) or not rows:
+        raise ValueError("acceptance matrix must contain requirements")
+    requirements: list[Requirement] = []
+    seen: set[str] = set()
+    for index, row in enumerate(rows):
+        if not isinstance(row, dict):
+            raise ValueError(f"acceptance requirement {index} must be a mapping")
+        requirement = Requirement(
+            id=str(row.get("id", "")),
+            title=str(row.get("title", "")),
+            implementation=_paths(row.get("implementation"), "implementation", index),
+            tests=_paths(row.get("tests"), "tests", index),
+            evidence=tuple(str(item) for item in row.get("evidence", ())),
+        )
+        if not requirement.id or not requirement.title:
+            raise ValueError(f"acceptance requirement {index} requires id and title")
+        if requirement.id in seen:
+            raise ValueError(f"duplicate acceptance requirement: {requirement.id}")
+        if not requirement.implementation or not requirement.tests or not requirement.evidence:
+            raise ValueError(f"acceptance requirement {requirement.id} is incomplete")
+        seen.add(requirement.id)
+        requirements.append(requirement)
+    return tuple(requirements)
+
+
+def validate_requirement_paths(
+    root: str | Path,
+    requirements: tuple[Requirement, ...],
+) -> tuple[Requirement, ...]:
+    root_path = Path(root).resolve()
+    missing: list[str] = []
+    for requirement in requirements:
+        for path in (*requirement.implementation, *requirement.tests):
+            if not (root_path / path).exists():
+                missing.append(f"{requirement.id}:{path}")
+    if missing:
+        raise ValueError(f"acceptance matrix references missing paths: {', '.join(missing)}")
+    return requirements
+
+
+def _paths(value: object, field: str, index: int) -> tuple[str, ...]:
+    if not isinstance(value, list):
+        raise ValueError(f"acceptance requirement {index} field {field} must be a list")
+    return tuple(str(item) for item in value)

algocode/acceptance/probe.py

@@ -0,0 +1,206 @@
+"""Release evidence probe for the P0 acceptance gate."""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from algocode.benchmark.spec import BenchmarkSpec
+from algocode.bootstrap import build_context
+from algocode.correctness.spec import CorrectnessCase, CorrectnessSpec
+from algocode.domain.errors import DecisionError
+from algocode.domain.model import TaskPhase
+from algocode.policy.types import PolicyEffect, PolicyRequest
+from algocode.tools.types import ToolContext
+
+
+def _init_git_repository(root: Path, files: dict[str, str]) -> Path:
+    root.mkdir(parents=True, exist_ok=True)
+    for relative_path, content in files.items():
+        target = root / relative_path
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(content, encoding="utf-8")
+    _git(root, "init", "-q")
+    _git(root, "config", "user.email", "algocode-acceptance@example.test")
+    _git(root, "config", "user.name", "Algocode Acceptance")
+    _git(root, "add", ".")
+    _git(root, "commit", "-q", "-m", "initial")
+    return root
+
+
+def _git(root: Path, *args: str) -> None:
+    subprocess.run(("git", *args), cwd=root, check=True, capture_output=True, text=True)
+
+
+@dataclass(frozen=True, slots=True)
+class ProbeMetrics:
+    false_accept_count: int
+    policy_violation_count: int
+    protected_file_change_count: int
+    replay_divergence_count: int
+    event_sequence_gap_count: int
+    apply_rollback_failure_count: int
+    event_count: int
+    task_status: str
+
+
+async def collect_release_evidence(root: str | Path) -> ProbeMetrics:
+    with tempfile.TemporaryDirectory(
+        prefix=f"algocode-acceptance-{Path(root).name}-",
+        ignore_cleanup_errors=True,
+    ) as directory:
+        return await _run_probe(Path(directory))
+
+
+async def _run_probe(root: Path) -> ProbeMetrics:
+    project_root = _init_git_repository(
+        root / "project",
+        {"main.py": "import time\ntime.sleep(0.05)\nprint('hello')\n"},
+    )
+    (project_root / ".algocode.yaml").write_text(
+        "acceptancePolicy:\n  minMedianImprovementPercent: -1000\n",
+        encoding="utf-8",
+    )
+    context = build_context(project_root=project_root, data_dir=root / "data")
+    project = await context.project_service.register(project_root, write_config=True)
+    task = await context.task_service.create_task(
+        "P0 release evidence",
+        project_id=project.id,
+    )
+    await context.baseline_service.capture(task.id)
+    await context.correctness_service.run_baseline(
+        task.id,
+        CorrectnessSpec(
+            mode="cases",
+            comparison="line-trim",
+            cases=(CorrectnessCase(id="baseline", expected_output="hello"),),
+        ),
+    )
+    benchmark_spec = BenchmarkSpec(warmup=0, repeats=1)
+    await context.benchmark_service.run_baseline(task.id, benchmark_spec)
+
+    apply_rollback_failures = 0
+    replay_divergence = 0
+    protected_file_changes = 0
+
+    candidate = await context.candidate_service.create(task.id)
+    (Path(candidate.workspace_ref) / "main.py").write_text(
+        "print('hi')\n",
+        encoding="utf-8",
+    )
+    candidate = await context.candidate_service.freeze(candidate.id)
+    correctness_run, correctness = await context.correctness_service.run_target(
+        task.id,
+        CorrectnessSpec(
+            mode="cases",
+            comparison="line-trim",
+            cases=(CorrectnessCase(id="candidate", expected_output="hi"),),
+        ),
+        target_kind="candidate",
+        target_id=str(candidate.id),
+        workspace_ref=candidate.workspace_ref,
+    )
+    if not correctness.passed:
+        replay_divergence += 1
+    else:
+        _, replay = await context.correctness_service.replay(correctness_run.id)
+        replay_divergence += int(not replay.passed)
+    await context.benchmark_service.run_candidate(
+        task.id,
+        str(candidate.id),
+        candidate.workspace_ref,
+        correctness_run.id,
+        benchmark_spec,
+    )
+    await context.decision_service.accept(task.id, candidate.id)
+    await context.report_service.build(task.id)
+
+    try:
+        applied = await context.apply_service.apply(task.id, candidate.id)
+        apply_rollback_failures += int(not applied.get("applied", False))
+        rolled_back = await context.apply_service.rollback(task.id, candidate.id)
+        apply_rollback_failures += int(not rolled_back.get("rolled_back", False))
+    except Exception:
+        apply_rollback_failures += 1
+
+    policy = context.policy_engine.evaluate(
+        PolicyRequest(
+            action="file.write",
+            resource="tests/test_main.py",
+            tool_name="apply_patch",
+        )
+    )
+    policy_violations = int(policy.effect is not PolicyEffect.DENY)
+
+    protected_context = ToolContext(
+        task=task,
+        phase=TaskPhase.IMPLEMENT,
+        workspace=Path(candidate.workspace_ref),
+        candidate_id=str(candidate.id),
+        artifact_store=context.artifact_store,
+        language_registry=context.language_registry,
+        correctness_service=context.correctness_service,
+        benchmark_service=context.benchmark_service,
+        protected_files=context.config.correctness.protected_files,
+    )
+    protected_patch = await context.tool_registry.execute(
+        "apply_patch",
+        {
+            "patch": (
+                "diff --git a/tests/test_main.py b/tests/test_main.py\n"
+                "--- a/tests/test_main.py\n"
+                "+++ b/tests/test_main.py\n"
+                "@@ -1 +1 @@\n"
+                "-assert True\n"
+                "+assert False\n"
+            )
+        },
+        protected_context,
+    )
+    if protected_patch.status == "success":
+        protected_file_changes += 1
+
+    false_accepts = 0
+    unverified = await context.candidate_service.create(task.id)
+    (Path(unverified.workspace_ref) / "main.py").write_text(
+        "print('unverified')\n",
+        encoding="utf-8",
+    )
+    unverified = await context.candidate_service.freeze(unverified.id)
+    await context.correctness_service.run_target(
+        task.id,
+        CorrectnessSpec(
+            mode="cases",
+            comparison="line-trim",
+            cases=(CorrectnessCase(id="unverified", expected_output="unverified"),),
+        ),
+        target_kind="candidate",
+        target_id=str(unverified.id),
+        workspace_ref=unverified.workspace_ref,
+    )
+    try:
+        await context.decision_service.accept(task.id, unverified.id)
+        false_accepts += 1
+    except DecisionError:
+        pass
+
+    events = await context.event_store.read(str(task.id))
+    gaps = sum(1 for expected, event in enumerate(events, start=1) if event.seq != expected)
+    task_after = await context.task_service.get_task(task.id)
+    return ProbeMetrics(
+        false_accept_count=false_accepts,
+        policy_violation_count=policy_violations,
+        protected_file_change_count=protected_file_changes,
+        replay_divergence_count=replay_divergence,
+        event_sequence_gap_count=gaps,
+        apply_rollback_failure_count=apply_rollback_failures,
+        event_count=len(events),
+        task_status=task_after.status.value,
+    )
+
+
+def run_release_probe(root: str | Path) -> ProbeMetrics:
+    return asyncio.run(collect_release_evidence(root))

algocode/acceptance/service.py

@@ -0,0 +1,244 @@
+"""Repeatable P0 acceptance and release gate."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+from uuid import uuid4
+
+from algocode.acceptance.matrix import load_requirements, validate_requirement_paths
+from algocode.acceptance.probe import ProbeMetrics, run_release_probe
+from algocode.acceptance.types import AcceptanceReport, GateCheck
+
+SUITE_GROUPS: dict[str, tuple[str, ...]] = {
+    "unit": ("tests/unit",),
+    "contract": ("tests/contract",),
+    "integration": (
+        "tests/integration",
+        "--ignore=tests/integration/test_e2e_full.py",
+        "--ignore=tests/integration/test_eval_service.py",
+    ),
+    "e2e": ("tests/integration/test_e2e_full.py",),
+    "eval": ("tests/integration/test_eval_service.py",),
+}
+ZERO_METRICS = (
+    "false_accept_count",
+    "policy_violation_count",
+    "protected_file_change_count",
+    "replay_divergence_count",
+    "event_sequence_gap_count",
+    "apply_rollback_failure_count",
+)
+
+
+class AcceptanceService:
+    def __init__(
+        self,
+        root: str | Path,
+        *,
+        report_dir: str | Path | None = None,
+    ) -> None:
+        self.root = Path(root).resolve()
+        self.report_dir = (
+            Path(report_dir).resolve()
+            if report_dir is not None
+            else self.root / "docs" / "acceptance" / "P0"
+        )
+
+    def run(self, *, run_tests: bool = True) -> AcceptanceReport:
+        checks: list[GateCheck] = []
+        requirements = ()
+        mapping_ok = True
+        try:
+            requirements = load_requirements(self.root)
+            requirements = validate_requirement_paths(self.root, requirements)
+            checks.append(
+                GateCheck(
+                    id="matrix.mapping",
+                    category="traceability",
+                    passed=True,
+                    message=f"mapped {len(requirements)} P0 requirements",
+                    metrics={"requirements_total": len(requirements)},
+                )
+            )
+        except ValueError as exc:
+            mapping_ok = False
+            checks.append(
+                GateCheck(
+                    id="matrix.mapping",
+                    category="traceability",
+                    passed=False,
+                    message=str(exc),
+                )
+            )
+
+        if run_tests:
+            checks.extend(self._run_test_suites())
+        else:
+            checks.append(
+                GateCheck(
+                    id="suite.skipped",
+                    category="test",
+                    passed=True,
+                    message="test suites skipped by request",
+                )
+            )
+
+        try:
+            probe = run_release_probe(self.root)
+            checks.extend(_probe_checks(probe))
+        except Exception as exc:
+            probe = None
+            checks.append(
+                GateCheck(
+                    id="probe.release_evidence",
+                    category="evidence",
+                    passed=False,
+                    message=f"release evidence probe failed: {exc}",
+                )
+            )
+
+        metrics = _metrics(probe)
+        status = "PASS" if mapping_ok and all(check.passed for check in checks) else "FAIL"
+        report = AcceptanceReport(
+            schema_version=1,
+            report_id=f"acceptance_{uuid4().hex}",
+            generated_at=datetime.now(UTC).isoformat(),
+            status=status,
+            requirements_total=len(requirements),
+            requirements_mapped=len(requirements) if mapping_ok else 0,
+            checks=tuple(checks),
+            metrics=metrics,
+        )
+        self.persist(report)
+        return report
+
+    def persist(self, report: AcceptanceReport) -> tuple[Path, Path]:
+        self.report_dir.mkdir(parents=True, exist_ok=True)
+        json_path = self.report_dir / "report.json"
+        markdown_path = self.report_dir / "report.md"
+        json_path.write_text(
+            json.dumps(report.payload(), ensure_ascii=False, indent=2, sort_keys=True),
+            encoding="utf-8",
+        )
+        markdown_path.write_text(render_acceptance_markdown(report), encoding="utf-8")
+        return json_path, markdown_path
+
+    def _run_test_suites(self) -> list[GateCheck]:
+        checks: list[GateCheck] = []
+        for name, arguments in SUITE_GROUPS.items():
+            started = time.perf_counter()
+            completed = subprocess.run(
+                (sys.executable, "-m", "pytest", "-q", *arguments),
+                cwd=self.root,
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=1800,
+            )
+            output = f"{completed.stdout}\n{completed.stderr}".strip()
+            checks.append(
+                GateCheck(
+                    id=f"suite.{name}",
+                    category="test",
+                    passed=completed.returncode == 0,
+                    message=f"{name} exit code {completed.returncode}",
+                    metrics={"duration_seconds": time.perf_counter() - started},
+                    output_tail=output[-4000:],
+                )
+            )
+        return checks
+
+
+def _probe_checks(probe: ProbeMetrics) -> list[GateCheck]:
+    return [
+        GateCheck(
+            id="metric.false_accept",
+            category="evidence",
+            passed=probe.false_accept_count == 0,
+            message=f"false accept count = {probe.false_accept_count}",
+            metrics={"false_accept_count": probe.false_accept_count},
+        ),
+        GateCheck(
+            id="metric.policy_violation",
+            category="evidence",
+            passed=probe.policy_violation_count == 0,
+            message=f"policy violation count = {probe.policy_violation_count}",
+            metrics={"policy_violation_count": probe.policy_violation_count},
+        ),
+        GateCheck(
+            id="metric.protected_file_change",
+            category="evidence",
+            passed=probe.protected_file_change_count == 0,
+            message=f"protected file change count = {probe.protected_file_change_count}",
+            metrics={"protected_file_change_count": probe.protected_file_change_count},
+        ),
+        GateCheck(
+            id="metric.replay_divergence",
+            category="evidence",
+            passed=probe.replay_divergence_count == 0,
+            message=f"replay divergence count = {probe.replay_divergence_count}",
+            metrics={"replay_divergence_count": probe.replay_divergence_count},
+        ),
+        GateCheck(
+            id="metric.event_sequence_gap",
+            category="evidence",
+            passed=probe.event_sequence_gap_count == 0,
+            message=f"event sequence gap count = {probe.event_sequence_gap_count}",
+            metrics={
+                "event_sequence_gap_count": probe.event_sequence_gap_count,
+                "event_count": probe.event_count,
+            },
+        ),
+        GateCheck(
+            id="metric.apply_rollback_failure",
+            category="evidence",
+            passed=probe.apply_rollback_failure_count == 0,
+            message=f"apply/rollback failure count = {probe.apply_rollback_failure_count}",
+            metrics={
+                "apply_rollback_failure_count": probe.apply_rollback_failure_count,
+                "task_status": probe.task_status,
+            },
+        ),
+    ]
+
+
+def _metrics(probe: ProbeMetrics | None) -> dict[str, int | float | str | None]:
+    if probe is None:
+        return {name: None for name in ZERO_METRICS}
+    return {
+        "false_accept_count": probe.false_accept_count,
+        "policy_violation_count": probe.policy_violation_count,
+        "protected_file_change_count": probe.protected_file_change_count,
+        "replay_divergence_count": probe.replay_divergence_count,
+        "event_sequence_gap_count": probe.event_sequence_gap_count,
+        "apply_rollback_failure_count": probe.apply_rollback_failure_count,
+        "event_count": probe.event_count,
+        "task_status": probe.task_status,
+    }
+
+
+def render_acceptance_markdown(report: AcceptanceReport) -> str:
+    lines = [
+        f"# P0 Acceptance Report {report.report_id}",
+        "",
+        f"- Status: `{report.status}`",
+        f"- Generated at: {report.generated_at}",
+        f"- Requirements mapped: {report.requirements_mapped}/{report.requirements_total}",
+        "",
+        "## Release Metrics",
+        "",
+    ]
+    for key, value in report.metrics.items():
+        lines.append(f"- `{key}`: {value}")
+    lines.extend(["", "## Gate Checks", ""])
+    for check in report.checks:
+        state = "PASS" if check.passed else "FAIL"
+        lines.append(f"- [{state}] `{check.id}` ({check.category}): {check.message}")
+        if check.output_tail:
+            lines.extend(["", "```text", check.output_tail, "```", ""])
+    return "\n".join(lines) + "\n"

algocode/acceptance/types.py

@@ -0,0 +1,58 @@
+"""Acceptance gate types."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True, slots=True)
+class Requirement:
+    id: str
+    title: str
+    implementation: tuple[str, ...]
+    tests: tuple[str, ...]
+    evidence: tuple[str, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class GateCheck:
+    id: str
+    category: str
+    passed: bool
+    message: str
+    metrics: dict[str, float | int | str | None] = field(default_factory=dict)
+    output_tail: str = ""
+
+
+@dataclass(frozen=True, slots=True)
+class AcceptanceReport:
+    schema_version: int
+    report_id: str
+    generated_at: str
+    status: str
+    requirements_total: int
+    requirements_mapped: int
+    checks: tuple[GateCheck, ...]
+    metrics: dict[str, int | float | str | None]
+
+    def payload(self) -> dict[str, object]:
+        return {
+            "schemaVersion": self.schema_version,
+            "reportId": self.report_id,
+            "generatedAt": self.generated_at,
+            "status": self.status,
+            "requirementsTotal": self.requirements_total,
+            "requirementsMapped": self.requirements_mapped,
+            "checks": [
+                {
+                    "id": check.id,
+                    "category": check.category,
+                    "passed": check.passed,
+                    "message": check.message,
+                    "metrics": check.metrics,
+                    "outputTail": check.output_tail,
+                }
+                for check in self.checks
+            ],
+            "metrics": self.metrics,
+        }

algocode/application/__init__.py

@@ -0,0 +1 @@
+"""Application services and use-case orchestration."""

algocode/application/services/__init__.py

@@ -0,0 +1,25 @@
+"""Application service exports."""
+
+from algocode.application.services.apply_service import ApplyService
+from algocode.application.services.baseline_service import BaselineService
+from algocode.application.services.benchmark_service import BenchmarkService
+from algocode.application.services.candidate_service import CandidateService
+from algocode.application.services.correctness_service import CorrectnessService
+from algocode.application.services.decision_service import DecisionService
+from algocode.application.services.project_bootstrap_service import ProjectBootstrapService
+from algocode.application.services.project_service import ProjectService
+from algocode.application.services.report_service import ReportService
+from algocode.application.services.task_service import TaskService
+
+__all__ = [
+    "ApplyService",
+    "BaselineService",
+    "BenchmarkService",
+    "CandidateService",
+    "CorrectnessService",
+    "DecisionService",
+    "ProjectBootstrapService",
+    "ProjectService",
+    "ReportService",
+    "TaskService",
+]