entelligence-cli 0.1.75__tar.gz → 0.1.76__tar.gz

{entelligence_cli-0.1.75 → entelligence_cli-0.1.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entelligence-cli
-Version: 0.1.75
+Version: 0.1.76
 Summary: AI-powered code review assistant for your terminal - Get instant, intelligent feedback on your code changes
 Author-email: EntelligenceAI <info@entelligence.ai>
 Project-URL: Homepage, https://entelligence.ai

{entelligence_cli-0.1.75 → entelligence_cli-0.1.76}/entelligence_cli/git_operations.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+import json
 import os
 import re
 import subprocess
+from collections import Counter
 from collections.abc import Iterable
 from pathlib import Path
 
@@ -524,3 +526,152 @@ def build_cwd_repos(cwds: Iterable[str | Path | None]) -> dict[str, dict[str, st
             entry["base"] = base
         out[key] = entry
     return out
+
+
+# ── file-touch repo resolution (the parent-folder fallback) ──────────────────
+#
+# When a session's cwd is a *parent* folder (dev started the agent above the
+# repo, or in a container of repos), `git -C <cwd>` finds no repo and the upload
+# gate drops the whole session — even though its edited files live in real,
+# possibly-connected sub-repos. These helpers recover the repo from the files the
+# session actually touched, so those sessions upload instead of vanishing.
+
+_WRITE_TOOLS = frozenset({"Edit", "Write", "MultiEdit", "NotebookEdit"})
+_READ_TOOLS = frozenset({"Read", "NotebookRead"})
+_dir_repo_cache: dict[str, str | None] = {}
+
+
+def repo_for_path(file_path: str | Path) -> str | None:
+    """``owner/repo`` of the git repo containing ``file_path``, or None.
+
+    Walks up from the file's directory via ``git -C <dir> remote get-url origin``
+    (git resolves the enclosing repo). Cached per directory — one session touches
+    many files across a handful of dirs.
+    """
+    directory = str(Path(file_path).expanduser().parent)
+    if directory not in _dir_repo_cache:
+        _dir_repo_cache[directory] = parse_owner_repo(get_remote_url(directory))
+    return _dir_repo_cache[directory]
+
+
+def _majority_repo(paths: Iterable[str | Path]) -> str | None:
+    counts: Counter[str] = Counter()
+    for p in paths:
+        repo = repo_for_path(p)
+        if repo:
+            counts[repo] += 1
+    return counts.most_common(1)[0][0] if counts else None
+
+
+def session_repo_from_transcript(transcript_path: str | Path) -> str | None:
+    """Resolve a session's repo from the files its tool calls touched.
+
+    Write-precedence majority: the repo most of the session's WRITTEN files live
+    in (that's where the work landed). Reads are only a fallback for sessions
+    that never wrote (planning/research) — a read often hits a reference or
+    dependency repo, not the one being worked on. Returns None when nothing
+    resolves (no file ops, or none under a git repo).
+
+    The fallback for sessions started from a parent folder whose cwd doesn't
+    resolve — see the module note above.
+
+    Claude Code transcripts only: Codex wraps records in a ``payload`` object
+    with a different tool-call encoding, so nothing matches here and Codex
+    sessions return None (they stay gated on cwd resolution, as before).
+    """
+    written: list[str] = []
+    read: list[str] = []
+    try:
+        with open(transcript_path, encoding="utf-8") as fh:
+            for line in fh:
+                try:
+                    obj = json.loads(line)
+                except (json.JSONDecodeError, ValueError):
+                    continue
+                message = obj.get("message")
+                if not isinstance(message, dict):
+                    continue
+                for block in message.get("content") or []:
+                    if not isinstance(block, dict) or block.get("type") != "tool_use":
+                        continue
+                    inp = block.get("input")
+                    if not isinstance(inp, dict):
+                        # A malformed line can carry a non-dict input (list /
+                        # string); `.get` on it would raise AttributeError and,
+                        # since it's outside the OSError guard, crash the whole
+                        # upload loop. Skip it — one bad line isn't fatal.
+                        continue
+                    fp = inp.get("file_path") or inp.get("notebook_path")
+                    if not isinstance(fp, str) or not fp:
+                        continue
+                    if block.get("name") in _WRITE_TOOLS:
+                        written.append(fp)
+                    elif block.get("name") in _READ_TOOLS:
+                        read.append(fp)
+    except OSError:
+        return None
+    return _majority_repo(written) or _majority_repo(read)
+
+
+_dir_root_cache: dict[str, tuple[str, str] | None] = {}
+
+
+def repo_root_for_path(file_path: str | Path) -> tuple[str, str] | None:
+    """``(git_toplevel, owner/repo)`` of the repo containing ``file_path``.
+
+    Git-truth resolution (``rev-parse --show-toplevel`` + origin URL),
+    cached per directory like ``repo_for_path``. None when the path isn't
+    inside a repo, or the repo has no parseable origin.
+    """
+    directory = str(Path(file_path).expanduser().parent)
+    if directory not in _dir_root_cache:
+        root = get_toplevel(directory)
+        repo = parse_owner_repo(get_remote_url(directory)) if root else None
+        _dir_root_cache[directory] = (root, repo) if root and repo else None
+    return _dir_root_cache[directory]
+
+
+def touched_repo_roots(transcript_path: str | Path) -> dict[str, str]:
+    """``{git_toplevel: owner/repo}`` for every repo this session's tool calls touched.
+
+    The manifest stamp that makes per-TASK multi-repo attribution possible
+    at ingest: the backend has no git on disk, so it prefix-matches each
+    task's touched-file paths against these roots. One entry per repo
+    (roots, not files) resolved with real git — exact where name-matching
+    would guess (nested repos, worktrees, coincidental folder names).
+
+    Cheap on big transcripts: lines are pre-filtered on a ``tool_use``
+    substring before JSON parsing, and git runs once per distinct
+    directory (cached).
+
+    Claude Code transcripts only (same shape caveat as
+    ``session_repo_from_transcript``); Codex yields an empty map.
+    """
+    roots: dict[str, str] = {}
+    try:
+        with open(transcript_path, encoding="utf-8") as fh:
+            for line in fh:
+                if '"tool_use"' not in line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                except (json.JSONDecodeError, ValueError):
+                    continue
+                message = obj.get("message")
+                if not isinstance(message, dict):
+                    continue
+                for block in message.get("content") or []:
+                    if not isinstance(block, dict) or block.get("type") != "tool_use":
+                        continue
+                    inp = block.get("input")
+                    if not isinstance(inp, dict):
+                        continue
+                    fp = inp.get("file_path") or inp.get("notebook_path")
+                    if not isinstance(fp, str) or not fp:
+                        continue
+                    resolved = repo_root_for_path(fp)
+                    if resolved:
+                        roots[resolved[0]] = resolved[1]
+    except OSError:
+        return roots
+    return roots

{entelligence_cli-0.1.75 → entelligence_cli-0.1.76}/entelligence_cli/upload/manifest.py

@@ -129,6 +129,10 @@ def build_manifest(
         "total_bytes": sum(e["size_bytes"] for e in entries),
         "entelligence": plan.entelligence.model_dump() if plan.entelligence else None,
         "cwd_repos": cwd_repos,
+        # `{git_toplevel: owner/repo}` for every repo this home's sessions'
+        # tool calls touched — the ingest side prefix-matches task files
+        # against these roots for per-task multi-repo attribution.
+        "repo_roots": plan.repo_roots.get(home_label, {}),
         "sessions": entries,
     }
     return json.dumps(body, indent=2).encode()

{entelligence_cli-0.1.75 → entelligence_cli-0.1.76}/entelligence_cli/upload/models.py

@@ -88,6 +88,11 @@ class UploadPlan(BaseModel):
     sessions: list[Session]
     entelligence: EntelligenceIdentity | None = None
     cwd_repos: dict[str, dict[str, str]] = Field(default_factory=dict)
+    # Per-home `{git_toplevel: owner/repo}` for every repo the home's
+    # sessions' TOOL CALLS touched (not just their cwds) — keyed by
+    # home_label. The ingest side prefix-matches each task's touched files
+    # against these roots for multi-repo attribution.
+    repo_roots: dict[str, dict[str, str]] = Field(default_factory=dict)
 
     @property
     def total_bytes(self) -> int:

{entelligence_cli-0.1.75 → entelligence_cli-0.1.76}/entelligence_cli/upload/runner.py

@@ -32,7 +32,7 @@ from ..ui.output import console
 from .config import load_config, save_config
 from .discovery import auto_detect_homes, discover_all, homes_from_config, scan_sessions
 from .manifest import build_manifest, resolve_entelligence_identity
-from .models import UploadConfig, UploadPlan
+from .models import AgentKind, UploadConfig, UploadPlan
 from .pii import Identity, redact_pii
 from .secrets import redact_bytes
 from .stores import LocalFsStore, PresignedS3Store
@@ -306,7 +306,9 @@ def _partition_by_connected_repos(sessions, cwd_repos, connected):
     Args:
         sessions: Discovered ``Session`` objects to partition.
         cwd_repos: ``{cwd_str: {"repo": "owner/repo", "base": ...}}`` from
-            ``git_operations.build_cwd_repos``.
+            ``git_operations.build_cwd_repos``. **Mutated as a side effect**:
+            a repo recovered from a session's touched files is stamped back
+            in under that session's cwd — see the inline comment for why.
         connected: Lowercased ``owner/repo`` names the org has connected.
 
     Returns:
@@ -318,12 +320,30 @@ def _partition_by_connected_repos(sessions, cwd_repos, connected):
     for s in sessions:
         entry = cwd_repos.get(str(s.cwd)) if s.cwd is not None else None
         repo = (entry or {}).get("repo")
+        if not repo:
+            # cwd didn't resolve — e.g. the session was started from a PARENT
+            # folder, not the repo itself. Recover the repo from the files it
+            # edited (write-precedence majority) so parent-folder sessions upload
+            # instead of being silently dropped at the gate.
+            recovered = git_operations.session_repo_from_transcript(s.abs_path)
+            if recovered and s.cwd is not None:
+                # Stamp the recovery into cwd_repos so the manifest carries it.
+                # The backend's ingest-side repo resolver reads this map (its
+                # only git-truth source for synced transcripts); without the
+                # stamp the session would upload but its tasks would then drop
+                # at the backend's signed-up-repo gate — the same silent drop,
+                # one stage later.
+                cwd_repos[str(s.cwd)] = {**(entry or {}), "repo": recovered}
+                repo = recovered
+            # When cwd is None there's no key to stamp under, so the backend
+            # could never resolve it — leave `repo` unset so the session fails
+            # CLOSED (skipped) instead of uploading only to drop at ingest.
         if repo and repo.lower() in connected:
             kept.append(s)
         else:
             # Fail-CLOSED: skip anything we can't positively place in a connected
-            # repo — both non-connected repos and sessions whose cwd didn't resolve
-            # (no git remote / dir gone).
+            # repo — both non-connected repos and sessions whose cwd + touched
+            # files both failed to resolve (no git remote / dir gone).
             skipped.append(s)
             skipped_repo_counts[repo or "(unresolved repo)"] += 1
     return kept, skipped, skipped_repo_counts
@@ -452,6 +472,19 @@ def run_transcript_upload(
     if scanned:
         scan_sessions(sessions, workers=scan_workers)
 
+    # --- Touched-repo roots (multi-repo attribution stamp) ------------------
+    # One session can edit repo B from a cwd in repo A; the cwd_repos map
+    # can't see that. Walk each kept session's tool calls and git-resolve the
+    # toplevel of every touched repo — the manifest stamp the ingest side
+    # prefix-matches task files against. Per home, since manifests are.
+    repo_roots: dict[str, dict[str, str]] = {}
+    for s in sessions:
+        if s.agent is not AgentKind.CLAUDE_CODE:
+            continue  # Codex tool calls have a different shape; nothing to walk
+        roots = git_operations.touched_repo_roots(s.abs_path)
+        if roots:
+            repo_roots.setdefault(s.home_label, {}).update(roots)
+
     plan = UploadPlan(
         org_uuid=identity.org_uuid,
         user_uuid=identity.user_uuid,
@@ -460,6 +493,7 @@ def run_transcript_upload(
         sessions=sessions,
         entelligence=identity,
         cwd_repos=cwd_repos,
+        repo_roots=repo_roots,
     )
 
     console.print(f"\n[bold green]{len(sessions)}[/bold green] session(s) ready to upload:")

{entelligence_cli-0.1.75 → entelligence_cli-0.1.76}/entelligence_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entelligence-cli
-Version: 0.1.75
+Version: 0.1.76
 Summary: AI-powered code review assistant for your terminal - Get instant, intelligent feedback on your code changes
 Author-email: EntelligenceAI <info@entelligence.ai>
 Project-URL: Homepage, https://entelligence.ai

{entelligence_cli-0.1.75 → entelligence_cli-0.1.76}/entelligence_cli.egg-info/SOURCES.txt

@@ -61,4 +61,5 @@ tests/test_incident_smoke.py
 tests/test_pii.py
 tests/test_security_commands.py
 tests/test_update_command.py
-tests/test_upload_repo_filter.py
+tests/test_upload_repo_filter.py
+tests/test_upload_repo_roots.py

{entelligence_cli-0.1.75 → entelligence_cli-0.1.76}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "entelligence-cli"
-version = "0.1.75"
+version = "0.1.76"
 description = "AI-powered code review assistant for your terminal - Get instant, intelligent feedback on your code changes"
 readme = "README.md"
 authors = [

entelligence_cli-0.1.76/tests/test_upload_repo_filter.py

@@ -0,0 +1,274 @@
+"""Fail-closed guarantees for the transcript upload's connected-repo pre-filter.
+
+Only sessions that positively resolve to a repo the org has connected may be
+uploaded. These lock in that contract at the two decision points:
+``_partition_by_connected_repos`` (per-session keep/skip) and
+``_fetch_connected_repos`` (abort vs. empty set).
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+import click
+import pytest
+
+from entelligence_cli.upload.models import AgentKind, Session
+from entelligence_cli.upload.runner import (
+    _fetch_connected_repos,
+    _partition_by_connected_repos,
+)
+
+
+CONNECTED = {"entelligence-ai/backend"}
+
+
+def _session(cwd: str) -> Session:
+    """Minimal Session — only ``.cwd`` affects the pre-filter."""
+    return Session(
+        agent=AgentKind.CLAUDE_CODE,
+        home_label="h",
+        abs_path=Path(f"{cwd}/x.jsonl"),
+        rel_path=Path("x.jsonl"),
+        size_bytes=1,
+        mtime=datetime(2026, 1, 1, tzinfo=UTC),
+        cwd=Path(cwd),
+    )
+
+
+def test_partition_keeps_only_connected_repo_sessions():
+    kept, skipped, counts = _partition_by_connected_repos(
+        [_session("/w/backend"), _session("/w/personal")],
+        {
+            "/w/backend": {"repo": "Entelligence-AI/backend"},  # case-insensitive match
+            "/w/personal": {"repo": "someone/personal"},
+        },
+        CONNECTED,
+    )
+    assert [str(s.cwd) for s in kept] == ["/w/backend"]
+    assert [str(s.cwd) for s in skipped] == ["/w/personal"]
+    assert counts["someone/personal"] == 1
+
+
+def test_partition_skips_unresolved_repo_fail_closed():
+    """A session whose cwd doesn't resolve to a repo is SKIPPED, not kept."""
+    kept, skipped, counts = _partition_by_connected_repos(
+        [_session("/w/nogit")],
+        {},
+        CONNECTED,  # cwd absent from the map => unresolved
+    )
+    assert kept == []
+    assert [str(s.cwd) for s in skipped] == ["/w/nogit"]
+    assert counts["(unresolved repo)"] == 1
+
+
+def test_fetch_connected_repos_aborts_when_unverifiable():
+    """A fetch error raises (fail-closed) instead of returning None / uploading all."""
+
+    class _Boom:
+        def fetch_organization_repos(self, org_uuid):
+            raise RuntimeError("network down")
+
+    with pytest.raises(click.ClickException):
+        _fetch_connected_repos(_Boom(), "org-uuid")
+
+
+def test_fetch_connected_repos_error_body_aborts():
+    class _ErrBody:
+        def fetch_organization_repos(self, org_uuid):
+            return {"Error": "unauthorized"}
+
+    with pytest.raises(click.ClickException):
+        _fetch_connected_repos(_ErrBody(), "org-uuid")
+
+
+def test_fetch_connected_repos_empty_for_zero_connected():
+    """Zero connected repos => empty set (=> nothing eligible), not None."""
+
+    class _Empty:
+        def fetch_organization_repos(self, org_uuid):
+            return {"Repositories": []}
+
+    assert _fetch_connected_repos(_Empty(), "org-uuid") == set()
+
+
+# ── parent-folder recovery: resolve from touched files (write-precedence) ─────
+
+
+def _write_transcript(path: Path, ops: list[tuple[str, str]]) -> None:
+    """``ops`` = list of ``(tool_name, file_path)`` → a minimal CC transcript."""
+    lines = [
+        json.dumps(
+            {
+                "message": {
+                    "content": [{"type": "tool_use", "name": tool, "input": {"file_path": fp}}]
+                }
+            }
+        )
+        for tool, fp in ops
+    ]
+    path.write_text("\n".join(lines) + "\n")
+
+
+def test_session_repo_write_beats_read(tmp_path, monkeypatch):
+    """Writes decide the repo; reads of a reference repo can't outvote them."""
+    from entelligence_cli import git_operations
+
+    monkeypatch.setattr(
+        git_operations,
+        "repo_for_path",
+        lambda fp: "Org/backend" if "/work/backend/" in str(fp) else "Org/old-service",
+    )
+    t = tmp_path / "s.jsonl"
+    _write_transcript(
+        t,
+        [
+            ("Read", "/ref/old-service/a.py"),  # 2 reads of a reference repo
+            ("Read", "/ref/old-service/b.py"),
+            ("Edit", "/work/backend/x.py"),  # 1 write of the work repo
+        ],
+    )
+    assert git_operations.session_repo_from_transcript(t) == "Org/backend"
+
+
+def test_session_repo_read_fallback_when_no_writes(tmp_path, monkeypatch):
+    """No writes → fall back to the read-majority repo (planning session)."""
+    from entelligence_cli import git_operations
+
+    monkeypatch.setattr(git_operations, "repo_for_path", lambda fp: "Org/backend")
+    t = tmp_path / "s.jsonl"
+    _write_transcript(t, [("Read", "/x/backend/a.py"), ("Read", "/x/backend/b.py")])
+    assert git_operations.session_repo_from_transcript(t) == "Org/backend"
+
+
+def test_partition_recovers_parent_folder_session_from_files(tmp_path, monkeypatch):
+    """A session started from a PARENT folder (cwd unresolved) is KEPT when its
+    edited files resolve to a connected repo — the parent-folder / Wasif case."""
+    from entelligence_cli import git_operations
+
+    monkeypatch.setattr(
+        git_operations,
+        "repo_for_path",
+        lambda fp: "Entelligence-AI/backend" if "backend" in str(fp) else None,
+    )
+    t = tmp_path / "s.jsonl"
+    _write_transcript(t, [("Edit", "/Users/wasif/projects/backend/src/x.py")])
+    s = Session(
+        agent=AgentKind.CLAUDE_CODE,
+        home_label="h",
+        abs_path=t,
+        rel_path=Path("s.jsonl"),
+        size_bytes=1,
+        mtime=datetime(2026, 1, 1, tzinfo=UTC),
+        cwd=Path("/Users/wasif/projects"),  # a parent folder, not the repo itself
+    )
+    kept, skipped, _ = _partition_by_connected_repos([s], {}, CONNECTED)
+    assert len(kept) == 1 and skipped == []
+
+
+def test_partition_stamps_recovered_repo_into_cwd_repos(tmp_path, monkeypatch):
+    """A file-touch-recovered repo is stamped back into ``cwd_repos`` so the
+    manifest carries it — the backend's ingest-side repo gate resolves tasks
+    from that map, so without the stamp the session would upload but its
+    tasks would drop at ingest (the same silent drop, one stage later)."""
+    from entelligence_cli import git_operations
+
+    monkeypatch.setattr(git_operations, "repo_for_path", lambda fp: "Entelligence-AI/backend")
+    t = tmp_path / "s.jsonl"
+    _write_transcript(t, [("Edit", "/Users/wasif/projects/backend/src/x.py")])
+    s = Session(
+        agent=AgentKind.CLAUDE_CODE,
+        home_label="h",
+        abs_path=t,
+        rel_path=Path("s.jsonl"),
+        size_bytes=1,
+        mtime=datetime(2026, 1, 1, tzinfo=UTC),
+        cwd=Path("/Users/wasif/projects"),
+    )
+    cwd_repos: dict = {}
+    _partition_by_connected_repos([s], cwd_repos, CONNECTED)
+    assert cwd_repos["/Users/wasif/projects"] == {"repo": "Entelligence-AI/backend"}
+
+
+def test_session_repo_none_for_codex_shaped_transcript(tmp_path, monkeypatch):
+    """Codex transcripts (payload-wrapped records) yield no file ops here →
+    None. Documents the known coverage limit: the fallback is CC-only."""
+    from entelligence_cli import git_operations
+
+    monkeypatch.setattr(git_operations, "repo_for_path", lambda fp: "Org/backend")
+    t = tmp_path / "codex.jsonl"
+    codex_line = {
+        "type": "response_item",
+        "payload": {
+            "type": "function_call",
+            "name": "shell",
+            "arguments": '{"command": ["apply_patch", "/w/backend/x.py"]}',
+        },
+    }
+    t.write_text(json.dumps(codex_line) + "\n")
+    assert git_operations.session_repo_from_transcript(t) is None
+
+
+def test_session_repo_survives_non_dict_input(tmp_path, monkeypatch):
+    """A tool_use block whose `input` is a non-dict (malformed line) must not
+    crash — it's skipped, and valid blocks in the same file still resolve."""
+    from entelligence_cli import git_operations
+
+    monkeypatch.setattr(git_operations, "repo_for_path", lambda fp: "Org/backend")
+    t = tmp_path / "s.jsonl"
+    t.write_text(
+        "\n".join(
+            [
+                # input is a string, not a dict → would AttributeError on .get
+                json.dumps(
+                    {
+                        "message": {
+                            "content": [{"type": "tool_use", "name": "Edit", "input": "oops"}]
+                        }
+                    }
+                ),
+                # a well-formed write in the same file still resolves
+                json.dumps(
+                    {
+                        "message": {
+                            "content": [
+                                {
+                                    "type": "tool_use",
+                                    "name": "Edit",
+                                    "input": {"file_path": "/w/backend/x.py"},
+                                }
+                            ]
+                        }
+                    }
+                ),
+            ]
+        )
+        + "\n"
+    )
+    assert git_operations.session_repo_from_transcript(t) == "Org/backend"
+
+
+def test_partition_skips_recovered_repo_when_cwd_is_none(tmp_path, monkeypatch):
+    """A cwd=None session whose files resolve to a connected repo is SKIPPED,
+    not kept — with no cwd there's no manifest key to stamp, so the backend
+    could never resolve it (uploading would just drop it at ingest)."""
+    from entelligence_cli import git_operations
+
+    monkeypatch.setattr(git_operations, "repo_for_path", lambda fp: "Entelligence-AI/backend")
+    t = tmp_path / "s.jsonl"
+    _write_transcript(t, [("Edit", "/Users/wasif/projects/backend/src/x.py")])
+    s = Session(
+        agent=AgentKind.CLAUDE_CODE,
+        home_label="h",
+        abs_path=t,
+        rel_path=Path("s.jsonl"),
+        size_bytes=1,
+        mtime=datetime(2026, 1, 1, tzinfo=UTC),
+        cwd=None,  # no cwd → nothing to stamp under
+    )
+    cwd_repos: dict = {}
+    kept, skipped, _ = _partition_by_connected_repos([s], cwd_repos, CONNECTED)
+    assert kept == [] and len(skipped) == 1
+    assert cwd_repos == {}  # nothing stamped

entelligence_cli-0.1.76/tests/test_upload_repo_roots.py

@@ -0,0 +1,161 @@
+"""The `repo_roots` manifest stamp — per-session touched-repo git toplevels.
+
+One session can edit repo B from a cwd in repo A, so `cwd_repos` (cwd-keyed)
+can't see every repo a session touched. `touched_repo_roots` walks the
+transcript's tool calls and git-resolves each touched repo's toplevel; the
+manifest carries the map so the ingest side can prefix-match task files
+against it (per-task multi-repo attribution).
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+
+from entelligence_cli import git_operations
+from entelligence_cli.upload.manifest import build_manifest
+from entelligence_cli.upload.models import AgentKind, Session, UploadPlan
+
+
+def _write_transcript(path: Path, ops: list[tuple[str, str]]) -> None:
+    lines = [
+        json.dumps(
+            {
+                "message": {
+                    "content": [{"type": "tool_use", "name": tool, "input": {"file_path": fp}}]
+                }
+            }
+        )
+        for tool, fp in ops
+    ]
+    path.write_text("\n".join(lines) + "\n")
+
+
+def _fake_root_resolver(mapping: dict[str, tuple[str, str]]):
+    """dir-prefix → (root, repo); mirrors repo_root_for_path's contract."""
+
+    def _resolve(fp):
+        for prefix, resolved in mapping.items():
+            if str(fp).startswith(prefix):
+                return resolved
+        return None
+
+    return _resolve
+
+
+def test_touched_repo_roots_collects_every_touched_repo(tmp_path, monkeypatch):
+    """Edits + reads across two repos → one root entry per repo; files under
+    no repo (e.g. /tmp scratch) contribute nothing."""
+    monkeypatch.setattr(
+        git_operations,
+        "repo_root_for_path",
+        _fake_root_resolver(
+            {
+                "/w/backend/": ("/w/backend", "Org/backend"),
+                "/w/cli/": ("/w/cli", "Org/cli"),
+            }
+        ),
+    )
+    t = tmp_path / "s.jsonl"
+    _write_transcript(
+        t,
+        [
+            ("Edit", "/w/backend/a.py"),
+            ("Read", "/w/cli/b.py"),
+            ("Write", "/tmp/scratch.py"),  # not in any repo
+        ],
+    )
+
+    assert git_operations.touched_repo_roots(t) == {
+        "/w/backend": "Org/backend",
+        "/w/cli": "Org/cli",
+    }
+
+
+def test_touched_repo_roots_tolerates_malformed_lines(tmp_path, monkeypatch):
+    """Non-dict input / non-JSON lines are skipped, not fatal."""
+    monkeypatch.setattr(
+        git_operations,
+        "repo_root_for_path",
+        _fake_root_resolver({"/w/": ("/w", "Org/w")}),
+    )
+    t = tmp_path / "s.jsonl"
+    t.write_text(
+        "not json at all\n"
+        + json.dumps(
+            {"message": {"content": [{"type": "tool_use", "name": "Edit", "input": "oops"}]}}
+        )
+        + "\n"
+        + json.dumps(
+            {
+                "message": {
+                    "content": [
+                        {"type": "tool_use", "name": "Edit", "input": {"file_path": "/w/x.py"}}
+                    ]
+                }
+            }
+        )
+        + "\n"
+    )
+
+    assert git_operations.touched_repo_roots(t) == {"/w": "Org/w"}
+
+
+def test_touched_repo_roots_codex_shape_yields_empty(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        git_operations, "repo_root_for_path", _fake_root_resolver({"/w/": ("/w", "Org/w")})
+    )
+    t = tmp_path / "codex.jsonl"
+    t.write_text(json.dumps({"type": "response_item", "payload": {"type": "function_call"}}) + "\n")
+
+    assert git_operations.touched_repo_roots(t) == {}
+
+
+def _session(home_label: str, cwd: str, path: Path) -> Session:
+    return Session(
+        agent=AgentKind.CLAUDE_CODE,
+        home_label=home_label,
+        abs_path=path,
+        rel_path=Path("s.jsonl"),
+        size_bytes=1,
+        mtime=datetime(2026, 1, 1, tzinfo=UTC),
+        cwd=Path(cwd),
+    )
+
+
+def test_manifest_carries_repo_roots_scoped_to_home(tmp_path):
+    """Each home's manifest gets ITS `repo_roots`, not another home's."""
+    t = tmp_path / "s.jsonl"
+    t.write_text("{}\n")
+    plan = UploadPlan(
+        org_uuid="org",
+        user_uuid="user",
+        hostname="host",
+        uploader="dev",
+        sessions=[_session("h1", "/w/backend", t), _session("h2", "/w/cli", t)],
+        repo_roots={
+            "h1": {"/w/backend": "Org/backend"},
+            "h2": {"/w/cli": "Org/cli"},
+        },
+    )
+
+    body = json.loads(build_manifest(plan, datetime(2026, 7, 2, tzinfo=UTC), "h1", redacted=False))
+    assert body["repo_roots"] == {"/w/backend": "Org/backend"}
+
+    body2 = json.loads(build_manifest(plan, datetime(2026, 7, 2, tzinfo=UTC), "h2", redacted=False))
+    assert body2["repo_roots"] == {"/w/cli": "Org/cli"}
+
+
+def test_manifest_repo_roots_empty_when_unstamped(tmp_path):
+    t = tmp_path / "s.jsonl"
+    t.write_text("{}\n")
+    plan = UploadPlan(
+        org_uuid="org",
+        user_uuid="user",
+        hostname="host",
+        uploader="dev",
+        sessions=[_session("h1", "/w/x", t)],
+    )
+    body = json.loads(build_manifest(plan, datetime(2026, 7, 2, tzinfo=UTC), "h1", redacted=False))
+    assert body["repo_roots"] == {}

entelligence_cli-0.1.75/tests/test_upload_repo_filter.py

@@ -1,93 +0,0 @@
-"""Fail-closed guarantees for the transcript upload's connected-repo pre-filter.
-
-Only sessions that positively resolve to a repo the org has connected may be
-uploaded. These lock in that contract at the two decision points:
-``_partition_by_connected_repos`` (per-session keep/skip) and
-``_fetch_connected_repos`` (abort vs. empty set).
-"""
-
-from __future__ import annotations
-
-from datetime import UTC, datetime
-from pathlib import Path
-
-import click
-import pytest
-
-from entelligence_cli.upload.models import AgentKind, Session
-from entelligence_cli.upload.runner import (
-    _fetch_connected_repos,
-    _partition_by_connected_repos,
-)
-
-
-CONNECTED = {"entelligence-ai/backend"}
-
-
-def _session(cwd: str) -> Session:
-    """Minimal Session — only ``.cwd`` affects the pre-filter."""
-    return Session(
-        agent=AgentKind.CLAUDE_CODE,
-        home_label="h",
-        abs_path=Path(f"{cwd}/x.jsonl"),
-        rel_path=Path("x.jsonl"),
-        size_bytes=1,
-        mtime=datetime(2026, 1, 1, tzinfo=UTC),
-        cwd=Path(cwd),
-    )
-
-
-def test_partition_keeps_only_connected_repo_sessions():
-    kept, skipped, counts = _partition_by_connected_repos(
-        [_session("/w/backend"), _session("/w/personal")],
-        {
-            "/w/backend": {"repo": "Entelligence-AI/backend"},  # case-insensitive match
-            "/w/personal": {"repo": "someone/personal"},
-        },
-        CONNECTED,
-    )
-    assert [str(s.cwd) for s in kept] == ["/w/backend"]
-    assert [str(s.cwd) for s in skipped] == ["/w/personal"]
-    assert counts["someone/personal"] == 1
-
-
-def test_partition_skips_unresolved_repo_fail_closed():
-    """A session whose cwd doesn't resolve to a repo is SKIPPED, not kept."""
-    kept, skipped, counts = _partition_by_connected_repos(
-        [_session("/w/nogit")],
-        {},
-        CONNECTED,  # cwd absent from the map => unresolved
-    )
-    assert kept == []
-    assert [str(s.cwd) for s in skipped] == ["/w/nogit"]
-    assert counts["(unresolved repo)"] == 1
-
-
-def test_fetch_connected_repos_aborts_when_unverifiable():
-    """A fetch error raises (fail-closed) instead of returning None / uploading all."""
-
-    class _Boom:
-        def fetch_organization_repos(self, org_uuid):
-            raise RuntimeError("network down")
-
-    with pytest.raises(click.ClickException):
-        _fetch_connected_repos(_Boom(), "org-uuid")
-
-
-def test_fetch_connected_repos_error_body_aborts():
-    class _ErrBody:
-        def fetch_organization_repos(self, org_uuid):
-            return {"Error": "unauthorized"}
-
-    with pytest.raises(click.ClickException):
-        _fetch_connected_repos(_ErrBody(), "org-uuid")
-
-
-def test_fetch_connected_repos_empty_for_zero_connected():
-    """Zero connected repos => empty set (=> nothing eligible), not None."""
-
-    class _Empty:
-        def fetch_organization_repos(self, org_uuid):
-            return {"Repositories": []}
-
-    assert _fetch_connected_repos(_Empty(), "org-uuid") == set()