agent-sdlc 0.4.0__tar.gz → 0.4.2__tar.gz

{agent_sdlc-0.4.0/agent_sdlc.egg-info → agent_sdlc-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-sdlc
-Version: 0.4.0
+Version: 0.4.2
 Summary: Diff-scoped mutation gate for pre-commit and agent Stop hooks
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/PavelGuzenfeld/agent-sdlc

{agent_sdlc-0.4.0 → agent_sdlc-0.4.2/agent_sdlc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-sdlc
-Version: 0.4.0
+Version: 0.4.2
 Summary: Diff-scoped mutation gate for pre-commit and agent Stop hooks
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/PavelGuzenfeld/agent-sdlc

{agent_sdlc-0.4.0 → agent_sdlc-0.4.2}/mutation_gate/__init__.py

@@ -1,3 +1,3 @@
 """Diff-scoped mutation gate. Spec: PavelGuzenfeld/dotfiles#9."""
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"

{agent_sdlc-0.4.0 → agent_sdlc-0.4.2}/mutation_gate/cli.py

@@ -117,9 +117,11 @@ def _gate_file(
         token.write(repo, rel, fp, "no-mutants")
         return False, [], cands
 
-    cover = coverage_map.covering_tests(repo, rel, cands, fp)
-    if not cover and rel.endswith(".py"):
-        _emit(f"  {rel}: coverage came back empty — every mutant runs against all candidate tests")
+    try:
+        cover = coverage_map.covering_tests(repo, rel, cands, fp)
+    except coverage_map.EmptyCoverageError as empty:
+        cover = {}
+        _emit(f"  {rel}: coverage came back empty ({empty}) — every mutant runs against all candidate tests")
     all_tests = [str(p.relative_to(repo.root)) for p in cands]
 
     baseline = runner.baseline_green(repo, all_tests, lang_cfg.test_command)
@@ -240,6 +242,14 @@ def _user_turn_text(content) -> str | None:
     return "\n".join(kept) if kept else None
 
 
+def _line_numbers(text: str) -> set[int]:
+    parts = text.split(",")
+    bad = next((part for part in parts if not part.strip().isdigit()), None)
+    if bad is not None:
+        raise argparse.ArgumentTypeError(f"invalid line number: {bad!r}")
+    return {int(part) for part in parts}
+
+
 def main(argv: list[str] | None = None) -> int:
     argv = sys.argv[1:] if argv is None else argv
     if argv[:1] == ["rules"]:
@@ -261,10 +271,14 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--no-adversary", action="store_true")
     parser.add_argument("--file", default=None,
                         help="gate every line of one file (acceptance / on-demand)")
+    parser.add_argument("--lines", type=_line_numbers, default=None,
+                        help="with --file, gate only these comma-separated line numbers")
     parser.add_argument("--dry-run", action="store_true",
                         help="print candidates and mutants; run no tests")
     parser.add_argument("files", nargs="*", help="ignored; pre-commit passes filenames")
     args = parser.parse_args(argv)
+    if args.lines and not args.file:
+        parser.error("--lines requires --file")
     staged = args.staged or not args.worktree
 
     payload = _stop_hook_payload() if args.worktree else {}
@@ -309,7 +323,8 @@ def _run(repo, args, staged: bool, transcript_path: str | None = None) -> int:
 
     if args.file:
         target = (repo.root / args.file)
-        all_changed = {args.file: set(range(1, len(target.read_text().splitlines()) + 1))}
+        every_line = set(range(1, len(target.read_text().splitlines()) + 1))
+        all_changed = {args.file: args.lines or every_line}
     else:
         try:
             all_changed = mutants.changed_lines(repo.root, staged)

{agent_sdlc-0.4.0 → agent_sdlc-0.4.2}/mutation_gate/coverage_map.py

@@ -10,7 +10,8 @@ from __future__ import annotations
 import ast
 import json
 import sqlite3
-from pathlib import Path
+import time
+from pathlib import Path, PurePosixPath
 
 from . import mutants, runner
 from .repo import CACHE_ROOT, Repo, git
@@ -221,6 +222,7 @@ def blob_hashes(repo: Repo, paths: list[Path]) -> list[str]:
 
 
 _CACHE_VERSION = "2"
+_COARSEST_MTIME_STEP_S = 2.0
 
 
 def _cache_path(repo: Repo, target: str, fingerprint: str) -> Path:
@@ -235,6 +237,10 @@ def _cov_scope(target: str) -> str:
     return str(Path(target).parent)
 
 
+class EmptyCoverageError(Exception):
+    pass
+
+
 def covering_tests(
     repo: Repo, target: str, cands: list[Path], fingerprint: str
 ) -> dict[int, list[str]]:
@@ -251,13 +257,19 @@ def covering_tests(
     rels = " ".join(str(p.relative_to(repo.root)) for p in cands)
     cmd = lang_cfg.coverage_command.format(file=_cov_scope(target), tests=rels)
     # Same suite plus instrumentation, so the baseline cap is the honest bound.
-    # Overrunning leaves no contexts, which widens selection to the whole suite.
+    run_start = time.time()
     verdict = runner.run_capped(repo, cmd, repo.config.baseline_timeout)
+    if verdict in (runner.FAILED, runner.TIMED_OUT):
+        raise EmptyCoverageError(f"the coverage run {verdict}")
+    data_file = repo.root / lang_cfg.coverage_data_file
+    if data_file.exists() and data_file.stat().st_mtime < run_start - _COARSEST_MTIME_STEP_S:
+        raise EmptyCoverageError(f"{lang_cfg.coverage_data_file} predates this coverage run")
 
     mapping = _read_contexts(repo, target, lang_cfg.coverage_data_file)
-    if mapping and verdict != runner.TIMED_OUT:
-        cache.parent.mkdir(parents=True, exist_ok=True)
-        cache.write_text(json.dumps({str(k): v for k, v in mapping.items()}))
+    if not mapping:
+        raise EmptyCoverageError(f"no test recorded a line of {target}")
+    cache.parent.mkdir(parents=True, exist_ok=True)
+    cache.write_text(json.dumps({str(k): v for k, v in mapping.items()}))
     return mapping
 
 
@@ -273,23 +285,30 @@ def _numbits_to_lines(numbits: bytes) -> list[int]:
     ]
 
 
+def _measured_file_id(repo: Repo, target: str, files: list[tuple[int, str]]) -> int:
+    """A test_command run in docker records the container's mount path, not the host's
+    (#358), so a lone row ending in `target`'s components stands in for an exact match.
+    Two such rows are ambiguous: no mapping is safer than narrowing to the wrong file's tests."""
+    target_path = (repo.root / target).resolve()
+    exact = [fid for fid, path in files if Path(path).resolve() == target_path]
+    if exact:
+        return exact[0]
+    parts = Path(target).parts
+    tails = [fid for fid, path in files if PurePosixPath(path).parts[-len(parts):] == parts]
+    if not tails:
+        raise EmptyCoverageError(f"no row in the data file matches {target}")
+    if len(tails) > 1:
+        raise EmptyCoverageError(f"{len(tails)} rows in the data file end in {target}")
+    return tails[0]
+
+
 def _read_contexts(repo: Repo, target: str, coverage_data_file: str) -> dict[int, list[str]]:
     data_file = repo.root / coverage_data_file
     if not data_file.exists():
-        return {}
-    target_path = (repo.root / target).resolve()
+        raise EmptyCoverageError(f"no data file at {coverage_data_file}")
     con = sqlite3.connect(f"file:{data_file}?mode=ro", uri=True)
     try:
-        file_id = next(
-            (
-                fid
-                for fid, path in con.execute("SELECT id, path FROM file")
-                if Path(path).resolve() == target_path
-            ),
-            None,
-        )
-        if file_id is None:
-            return {}
+        file_id = _measured_file_id(repo, target, con.execute("SELECT id, path FROM file").fetchall())
         rows = con.execute(
             "SELECT line_bits.numbits, context.context FROM line_bits "
             "JOIN context ON context.id = line_bits.context_id "
@@ -297,7 +316,7 @@ def _read_contexts(repo: Repo, target: str, coverage_data_file: str) -> dict[int
             (file_id,),
         ).fetchall()
     except sqlite3.DatabaseError:
-        return {}
+        raise EmptyCoverageError(f"{coverage_data_file} is not a readable coverage database") from None
     finally:
         con.close()
     result: dict[int, list[str]] = {}

{agent_sdlc-0.4.0 → agent_sdlc-0.4.2}/mutation_gate/rules.py

@@ -20,6 +20,12 @@ _INSTALLED = Path(__file__).resolve().parent / "bundled_rules"
 RULES_DIR = _INSTALLED if _INSTALLED.is_dir() else Path(__file__).resolve().parent.parent / "rules"
 
 
+def source_dir(repo: Repo) -> Path:
+    """The pack's own checkout is its own rule source; the bundle would downgrade it."""
+    is_pack_checkout = (repo.root / "mutation_gate" / "rules.py").is_file()
+    return repo.root / "rules" if is_pack_checkout else RULES_DIR
+
+
 def _emit(line: str) -> None:
     print(line, file=sys.stderr)
 
@@ -42,7 +48,7 @@ def frontmatter(model_paths: list[str]) -> bytes:
 
 def expected(repo: Repo) -> dict[str, bytes]:
     out: dict[str, bytes] = {}
-    for path in sorted(RULES_DIR.glob("*.md")):
+    for path in sorted(source_dir(repo).glob("*.md")):
         if path.name == SCOPED_RULE:
             if not repo.config.model_paths:
                 continue

{agent_sdlc-0.4.0 → agent_sdlc-0.4.2}/rules/diff-discipline.md

@@ -28,3 +28,4 @@ structure right and the **layout wrong**. `sed`/`perl` only for prose, config an
 single-line literals — a regex alternation matches across lines and eats them.
 `sg` is ambiguous: `/usr/bin/sg` is newgrp's alias, and ast-grep-cli's shim can shadow it. Always `ast-grep`.
 Use it to audit too: a structural question deserves a pattern, not a grep heuristic.
+Run the formatter through the repo's own hook, `pre-commit run <id> --files <changed files>`, never a bare whole-file run: it reformats lines you did not touch.

{agent_sdlc-0.4.0 → agent_sdlc-0.4.2}/rules/testing.md

@@ -65,6 +65,8 @@ test that only re-exercises what the slice already covers earns nothing.
 watch it fail for the right reason. A test that was never red proves nothing —
 it could pass against the unmodified tree.
 
+**Read the launch path first.** Before validating on hardware, read every script the launch path execs. A fake image can hide a startup step that changes the outcome, such as one that wipes a log directory.
+
 ## Adversary protocol
 
 When the gate goes green, the pack spawns an isolated review that sees the

{agent_sdlc-0.4.0 → agent_sdlc-0.4.2}/rules/tickets.md

@@ -34,7 +34,8 @@ A PR waits for CI in one foreground call — `gh pr checks <PR> --watch
 --fail-fast` or `gh run watch <run> --exit-status` — with the Bash timeout at
 its 600000 ms maximum and the output to a file, re-issued on timeout. The call
 blocks until CI settles, so no turn is spent on a status check: every turn
-re-reads the whole context.
+re-reads the whole context. Unless the session is ending with the PR open: skip
+the wait and record CI as unwatched in the handoff.
 
 ## Follow-ups
 

{agent_sdlc-0.4.0 → agent_sdlc-0.4.2}/rules/voice.md

@@ -19,3 +19,8 @@ Private docs, issues and PR bodies: no preamble, no restating the brief, no Over
 section, no "This PR introduces…", no closing summary. Defect in the title, then
 repro, expected/actual, evidence. Tighten the section you edit; design docs and
 ICD notes keep their rationale.
+
+Text posted or edited under the user's name starts from their own words: same
+length and register, grammar fixed, nothing added. Session evidence goes in only
+when they ask. Before any public post or edit: is this longer than what the user
+wrote? Then cut back to it.