paircode 0.12.1__tar.gz → 0.12.3__tar.gz

{paircode-0.12.1 → paircode-0.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paircode
-Version: 0.12.1
+Version: 0.12.3
 Summary: Adversarial journey framework — orchestrate multiple LLM peers through research, plan, and execute stages with file-trace peer review.
 Project-URL: Homepage, https://github.com/starshipagentic/paircode
 Project-URL: Repository, https://github.com/starshipagentic/paircode

{paircode-0.12.1 → paircode-0.12.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paircode"
-version = "0.12.1"
+version = "0.12.3"
 description = "Adversarial journey framework — orchestrate multiple LLM peers through research, plan, and execute stages with file-trace peer review."
 readme = "README.md"
 license = { text = "MIT" }

{paircode-0.12.1 → paircode-0.12.3}/src/paircode/__init__.py

@@ -2,4 +2,4 @@
 
 See README.md and diary/001-step-a-architecture.md for the full design.
 """
-__version__ = "0.12.0"
+__version__ = "0.12.2"

{paircode-0.12.1 → paircode-0.12.3}/src/paircode/peerlab.py

@@ -41,6 +41,30 @@ SEED_EXCLUDES: tuple[str, ...] = (
 
 GITIGNORE_BLOCK_HEADER = "# peerlab — per-peer independent parallel labs"
 
+# Defaults dropped into each new peer lab's own .gitignore so peer commits
+# don't accidentally include Python bytecode, editor junk, OS cruft.
+# If the lab inherited a .gitignore from the project root (rsync seed), we
+# APPEND this block — user's rules win, these are a safety net.
+LAB_GITIGNORE_BLOCK = """\
+# peerlab defaults — python + editor junk (keep peer commits clean)
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.tox/
+.coverage
+.coverage.*
+htmlcov/
+.DS_Store
+.idea/
+.vscode/
+*.swp
+"""
+LAB_GITIGNORE_MARKER = "peerlab defaults"
+
 
 @dataclass(frozen=True)
 class EnsureResult:
@@ -108,6 +132,25 @@ def _rsync_project(src: Path, dst: Path, excludes: Iterable[str] = SEED_EXCLUDES
     shutil.copytree(src, dst, ignore=_ignore)
 
 
+def ensure_lab_gitignore(lab: Path) -> bool:
+    """Ensure the peer lab has Python/editor junk gitignored. Idempotent.
+
+    If the lab already has a `.gitignore` (inherited via rsync from the
+    project root), our block is appended so user rules win. If none exists
+    (greenfield), our block IS the .gitignore.
+
+    Returns True if the block was added this call, False if it was already
+    there (marker detection).
+    """
+    gitignore = lab / ".gitignore"
+    existing = gitignore.read_text(encoding="utf-8") if gitignore.exists() else ""
+    if LAB_GITIGNORE_MARKER in existing:
+        return False
+    new_text = (existing.rstrip() + "\n\n" if existing.strip() else "") + LAB_GITIGNORE_BLOCK
+    gitignore.write_text(new_text, encoding="utf-8")
+    return True
+
+
 def _git_init(lab: Path) -> None:
     """`git init` inside `lab/`. No-op if already inited."""
     if (lab / ".git").exists():
@@ -121,17 +164,24 @@ def _git_init(lab: Path) -> None:
         subprocess.run(["git", "init", "--quiet", str(lab)], check=True)
 
 
-def _git_initial_commit(lab: Path, message: str = "initial seed from project root") -> bool:
+def _git_initial_commit(
+    lab: Path, peer_id: str, message: str = "initial seed from project root"
+) -> bool:
     """Stage everything + commit. Returns True if a commit was made.
 
-    Sets local-only user.name/email (doesn't touch global git config) so the
-    commit is authored even on machines without a global identity.
+    Authors the commit as the peer itself (`{peer_id} <{peer_id}@peerlab.local>`)
+    via lab-local git config. Every subsequent peer commit inside this lab
+    inherits that local identity — so `git log` in a peer's lab attributes
+    all work to that peer, clean replay.
     """
     if not any(lab.iterdir()):
         return False
-    # Local git config — scoped to this repo
-    subprocess.run(["git", "-C", str(lab), "config", "user.name", "paircode-peerlab"], check=False)
-    subprocess.run(["git", "-C", str(lab), "config", "user.email", "peerlab@paircode.local"], check=False)
+    # Local git config — scoped to this lab, doesn't touch global identity.
+    subprocess.run(["git", "-C", str(lab), "config", "user.name", peer_id], check=False)
+    subprocess.run(
+        ["git", "-C", str(lab), "config", "user.email", f"{peer_id}@peerlab.local"],
+        check=False,
+    )
     subprocess.run(["git", "-C", str(lab), "add", "-A"], check=False)
     # Commit only if there's something staged
     diff_check = subprocess.run(
@@ -183,8 +233,12 @@ def ensure_peer_labs(state: PaircodeState) -> list[EnsureResult]:
         lab.mkdir(exist_ok=True)
         # Seed from project root (might be empty for greenfield — rsync handles fine)
         _rsync_project(project_root, lab)
+        # Drop peerlab-default .gitignore so peer commits don't pull in
+        # __pycache__, .pytest_cache, editor junk etc. Appends if the lab
+        # already inherited a .gitignore from the project root.
+        ensure_lab_gitignore(lab)
         _git_init(lab)
-        _git_initial_commit(lab, message="initial seed from project root")
+        _git_initial_commit(lab, pid, message="initial seed from project root")
         results.append(EnsureResult(peer_id=pid, lab_path=lab, status="created"))
     return results
 

{paircode-0.12.1 → paircode-0.12.3}/tests/test_peerlab.py

@@ -11,8 +11,10 @@ from click.testing import CliRunner
 from paircode.cli import main
 from paircode.handshake import ProposedPeer
 from paircode.peerlab import (
+    LAB_GITIGNORE_MARKER,
     PEERLAB_DIRNAME,
     ensure_gitignore,
+    ensure_lab_gitignore,
     ensure_peer_labs,
     peer_lab_path,
 )
@@ -176,6 +178,81 @@ def test_paircode_peerlab_help_is_reachable():
 # Seed excludes honored
 # ---------------------------------------------------------------------------
 
+def test_lab_gitignore_has_pycache_on_fresh_lab(tmp_path, monkeypatch):
+    """Fresh lab's .gitignore excludes __pycache__ and bytecode so peer
+    commits don't pull in build junk. Regression for v0.12.0 bug where
+    `git add -A` in peer labs committed .pyc files."""
+    _init_and_scaffold(tmp_path, monkeypatch)
+    state = find_paircode()
+    ensure_peer_labs(state)
+    lab = peer_lab_path(state, "peer-a-codex")
+    gitignore = lab / ".gitignore"
+    assert gitignore.exists()
+    content = gitignore.read_text()
+    assert "__pycache__/" in content
+    assert "*.py[cod]" in content
+    assert LAB_GITIGNORE_MARKER in content
+
+
+def test_ensure_lab_gitignore_appends_to_existing(tmp_path):
+    """If user's project already has a .gitignore (rsync brought it over),
+    the peerlab block is APPENDED — user rules preserved."""
+    lab = tmp_path
+    (lab / ".gitignore").write_text("# user project rules\nsecrets.env\n")
+    assert ensure_lab_gitignore(lab) is True
+    content = (lab / ".gitignore").read_text()
+    assert "secrets.env" in content  # user rule preserved
+    assert LAB_GITIGNORE_MARKER in content  # our block added
+
+
+def test_ensure_lab_gitignore_is_idempotent(tmp_path):
+    """Second call no-ops if marker already there."""
+    lab = tmp_path
+    assert ensure_lab_gitignore(lab) is True
+    before = (lab / ".gitignore").read_text()
+    assert ensure_lab_gitignore(lab) is False
+    assert (lab / ".gitignore").read_text() == before
+
+
+def test_initial_commit_authored_as_peer_id(tmp_path, monkeypatch):
+    """Initial seed commit must be authored as the peer_id so replay
+    (git log) attributes work to each peer. Fixes v0.12.0 where commits
+    were authored as generic 'paircode-peerlab'."""
+    _init_and_scaffold(tmp_path, monkeypatch)
+    state = find_paircode()
+    ensure_peer_labs(state)
+    for pid in ("peer-a-codex", "peer-b-gemini"):
+        lab = peer_lab_path(state, pid)
+        r = subprocess.run(
+            ["git", "-C", str(lab), "log", "-1", "--format=%an <%ae>"],
+            capture_output=True, text=True, check=False,
+        )
+        assert pid in r.stdout, f"commit author should contain {pid}; got {r.stdout}"
+        assert f"{pid}@peerlab.local" in r.stdout
+
+
+def test_different_peers_produce_different_initial_commits(tmp_path, monkeypatch):
+    """Distinct peer_ids as commit authors mean the seed commit SHAs differ
+    across labs — proves independence beyond 'same content, same author,
+    accidental SHA collision'."""
+    _init_and_scaffold(tmp_path, monkeypatch)
+    state = find_paircode()
+    ensure_peer_labs(state)
+    codex_lab = peer_lab_path(state, "peer-a-codex")
+    gemini_lab = peer_lab_path(state, "peer-b-gemini")
+
+    def head_sha(lab):
+        r = subprocess.run(
+            ["git", "-C", str(lab), "rev-parse", "HEAD"],
+            capture_output=True, text=True, check=False,
+        )
+        return r.stdout.strip()
+
+    assert head_sha(codex_lab) != head_sha(gemini_lab), (
+        "initial seed commits should differ across labs since authors differ"
+    )
+
+
 def test_seed_excludes_dot_paircode_and_dot_git(tmp_path, monkeypatch):
     """Seeded labs must not contain `.paircode/` (recursion) or the outer
     repo's `.git/` (each lab gets its own fresh git instead)."""