tdd-cli 0.1.0__py3-none-any.whl

tddcli/snapshot.py

@@ -0,0 +1,90 @@
+"""Working-tree snapshots for sensitivity checks (§8.4, R8.5).
+
+Restoration must return the tree to its *pre-mutation* state, never to HEAD: at a
+passed-on-arrival the RED test is written but uncommitted, so the tree is legitimately
+dirty and `git checkout --` would destroy it. Untracked files cannot be restored by
+git at all, so contents are captured directly.
+
+Build output is excluded throughout — a suite run between `begin` and `end` rewrites
+`.pyc` files, and comparing those would make every verification fail.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+from pathlib import Path
+
+from . import gitutil
+from .config import Config
+
+MAX_CAPTURE_BYTES = 4 * 1024 * 1024
+
+
+def authored_dirty(worktree: Path, config: Config) -> set[str]:
+    return {p for p in gitutil.dirty_paths(worktree) if not config.is_ignored(p)}
+
+
+def _read(worktree: Path, rel: str) -> bytes | None:
+    path = worktree / rel
+    if not path.is_file():
+        return None
+    if path.stat().st_size > MAX_CAPTURE_BYTES:
+        return None
+    return path.read_bytes()
+
+
+def capture(worktree: Path, config: Config) -> str:
+    """Snapshot every non-ignored dirty path, contents included."""
+    entries = {}
+    for rel in sorted(authored_dirty(worktree, config)):
+        data = _read(worktree, rel)
+        entries[rel] = (
+            None if data is None else base64.b64encode(data).decode("ascii")
+        )
+    return json.dumps({"files": entries})
+
+
+def fingerprint(worktree: Path, config: Config) -> str:
+    h = hashlib.sha256()
+    for rel in sorted(authored_dirty(worktree, config)):
+        h.update(rel.encode())
+        data = _read(worktree, rel)
+        h.update(hashlib.sha256(data).digest() if data is not None else b"missing")
+    return h.hexdigest()
+
+
+def restore(worktree: Path, config: Config, snapshot_json: str) -> list[str]:
+    """Return the tree to the captured state. Returns the paths acted on."""
+    saved = json.loads(snapshot_json)["files"]
+    touched: list[str] = []
+
+    for rel in sorted(authored_dirty(worktree, config)):
+        if rel in saved:
+            continue
+        # Dirty now, clean when captured: revert it, or remove it if it is new.
+        path = worktree / rel
+        tracked = bool(
+            gitutil.git(worktree, "ls-files", "--", rel, check=False).strip()
+        )
+        if tracked:
+            gitutil.checkout_paths(worktree, [rel])
+        elif path.is_file():
+            path.unlink()
+        touched.append(rel)
+
+    for rel, encoded in saved.items():
+        path = worktree / rel
+        if encoded is None:
+            if path.is_file():
+                path.unlink()
+                touched.append(rel)
+            continue
+        data = base64.b64decode(encoded)
+        if not path.is_file() or path.read_bytes() != data:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_bytes(data)
+            touched.append(rel)
+
+    return sorted(set(touched))

tddcli/staging.py

@@ -0,0 +1,130 @@
+"""Staging and commits, derived from the phase being left (§9.5).
+
+The tool stages; agents never do. `git add -A` is never used.
+
+R9.14 falls out of this for free: if the RED commit's staged set would contain a file
+that is neither a test nor a declared stub, that *is* implementation written during
+RED — detected exactly, in every language, without parsing a line of source.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from . import gitutil
+from .config import Config
+from .contract import DeclaredCycle
+
+RED = "red"
+GREEN = "green"
+REFACTOR = "refactor"
+PIN = "pin"
+
+
+@dataclass
+class Classification:
+    tests: list[str] = field(default_factory=list)
+    stubs: list[str] = field(default_factory=list)
+    implementation: list[str] = field(default_factory=list)
+    generated: list[str] = field(default_factory=list)
+    outside: list[str] = field(default_factory=list)      # outside every project root
+    excluded: list[str] = field(default_factory=list)     # pre-existing dirt (R9.21)
+    ignored: list[str] = field(default_factory=list)      # build output; never authored
+
+    @property
+    def undeclared_impl(self) -> list[str]:
+        return self.implementation
+
+    def adopt_stubs(self, paths: list[str]) -> None:
+        """Move tool-sanctioned stubs out of implementation and into the RED commit.
+
+        The plan declares stubs it foresaw; this covers the ones the *tool* demanded
+        after an uncollectable target (R9.14) — leaving them classified as
+        implementation would report the agent for doing exactly as it was told.
+        """
+        chosen = set(paths)
+        self.implementation = [p for p in self.implementation if p not in chosen]
+        self.stubs = sorted(set(self.stubs) | chosen)
+
+
+def classify(
+    config: Config,
+    changed: set[str],
+    cycle_projects: list[str],
+    declared: DeclaredCycle | None,
+    excluded: set[str],
+) -> Classification:
+    out = Classification()
+    stub_set = set(declared.stub_expected) if declared else set()
+    roots = {config.project(p).root for p in cycle_projects}
+
+    for rel in sorted(changed):
+        if config.is_ignored(rel):            # build output is never authored
+            out.ignored.append(rel)
+            continue
+        if rel in excluded:
+            out.excluded.append(rel)
+            continue
+        if config.is_generated(rel):          # R7.7
+            out.generated.append(rel)
+            continue
+        owner = config.owning_project(rel)
+        if owner is None or owner.root not in roots:
+            out.outside.append(rel)
+            continue
+        if owner.is_test_file(rel):
+            out.tests.append(rel)
+        elif rel in stub_set or owner.relative_to_root(rel) in stub_set:
+            out.stubs.append(rel)
+        else:
+            out.implementation.append(rel)
+    return out
+
+
+def paths_for_phase(phase: str, classification: Classification) -> list[str]:
+    if phase == RED:
+        return sorted(classification.tests + classification.stubs)
+    if phase == PIN:
+        return sorted(classification.tests)
+    # GREEN and REFACTOR take everything authored inside the cycle's projects.
+    return sorted(
+        classification.tests + classification.stubs + classification.implementation
+    )
+
+
+def default_message(phase: str, declared: DeclaredCycle | None, ordinal: int) -> str:
+    if declared and phase in declared.commit_messages:
+        return declared.commit_messages[phase]
+    title = (declared.title if declared else "") or f"cycle {ordinal}"
+    return {
+        RED: f"test: {title}",
+        PIN: f"test: pin {title}",
+        GREEN: f"feat: {title}",
+        REFACTOR: f"refactor: {title}",
+    }[phase]
+
+
+def commit(
+    worktree: Path,
+    paths: list[str],
+    message: str,
+    trailers: dict[str, str],
+) -> tuple[str | None, list[str]]:
+    """Stage exactly `paths` and commit. Returns (sha, staged) — (None, []) if empty."""
+    gitutil.reset_index(worktree)
+    if not paths:
+        return None, []
+    gitutil.add(worktree, paths)
+    staged = gitutil.staged_paths(worktree)
+    if not staged:
+        return None, []
+    sha = gitutil.commit(worktree, message, trailers)
+    return sha, staged
+
+
+def commit_generated(
+    worktree: Path, paths: list[str], artifact: str, trailers: dict[str, str]
+) -> tuple[str | None, list[str]]:
+    """R9.20 — regenerated output lands in its own commit, separately reviewable."""
+    return commit(worktree, paths, f"chore({artifact}): regenerate", trailers)