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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: entelligence-cli
-Version: 0.1.74
+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.74 → 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.76/entelligence_cli/upload/conductor.py

@@ -0,0 +1,37 @@
+"""Conductor attribution — recognize sessions that ran inside a Conductor workspace.
+
+Conductor (conductor.build) runs Claude Code / Codex against the DEFAULT ``~/.claude`` /
+``~/.codex`` homes, so its sessions are already discovered like any other — keyed by the worktree
+cwd, which lives under ``~/conductor/workspaces/<project>/<workspace>``. Recognizing that cwd lets
+the manifest mark a session's orchestrator as "conductor" (a dimension orthogonal to ``agent``),
+so downstream tooling / the frontend can distinguish parallel-agent runs from plain sessions.
+
+Path-based only — no dependency on Conductor's macOS app database.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+CONDUCTOR_WORKSPACES = Path.home() / "conductor" / "workspaces"
+
+
+def conductor_workspace(cwd: Path | str | None) -> str | None:
+    """Return a ``<project>/<workspace>`` label when ``cwd`` is inside a Conductor workspace.
+
+    e.g. ``~/conductor/workspaces/Starter project/quebec/src`` -> ``Starter project/quebec``.
+    Returns None when ``cwd`` is missing or not under the Conductor workspaces root.
+    """
+    if cwd is None:
+        return None
+    # normpath collapses `.`/`..` lexically (no filesystem/symlink access) so a cwd like
+    # `.../workspaces/proj/ws/../other` resolves to `proj/other`, not the original `proj/ws`.
+    path = Path(os.path.normpath(cwd))
+    if CONDUCTOR_WORKSPACES not in path.parents:
+        return None
+    parts = path.relative_to(CONDUCTOR_WORKSPACES).parts
+    # Require BOTH a project and a workspace segment — a bare
+    # ~/conductor/workspaces/<project> (no worktree) is not a real workspace.
+    return "/".join(parts[:2]) if len(parts) >= 2 else None

{entelligence_cli-0.1.74 → entelligence_cli-0.1.76}/entelligence_cli/upload/discovery.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import json
 import logging
+import os
+import sqlite3
 from collections.abc import Callable, Iterable, Iterator
 from concurrent.futures import ProcessPoolExecutor, as_completed
 from datetime import UTC, datetime
@@ -193,6 +195,141 @@ def find_codex_candidates(home: HomeSpec) -> Iterator[Session]:
         )
 
 
+# ----- Discovery: opencode --------------------------------------------------
+#
+# opencode (sst/opencode, v1.17+) stores everything in a single SQLite db at
+# ``<data-dir>/opencode.db`` — no per-session file. A session is one ``session`` row (which
+# carries ``directory`` = cwd) plus rows in ``message`` / ``part``. To ride the same file-based
+# pipeline as Claude Code / Codex, we synthesize one NDJSON transcript per session (one line per
+# message, its parts merged in) and materialize it under this cache root; the rest of the pipeline
+# (secret + PII scrub, upload, manifest, dedup) then treats it like any other transcript file.
+
+OPENCODE_CACHE_ROOT = Path.home() / ".entelligence" / "cache" / "opencode"
+
+
+def _opencode_db(home: Path) -> Path | None:
+    """The opencode SQLite db under ``home`` (``opencode.db``, or an ``opencode-<channel>.db``)."""
+    db = home / "opencode.db"
+    if db.is_file():
+        return db
+    others = sorted(home.glob("opencode*.db"))
+    return others[0] if others else None
+
+
+def _sqlite_ro_uri(db: Path) -> str:
+    """Read-only, immutable SQLite URI. Percent-encode the path so a home dir containing
+    ``?`` or ``#`` (URI delimiters) doesn't make SQLite open the wrong file."""
+    from urllib.parse import quote
+
+    return f"file:{quote(str(db))}?mode=ro&immutable=1"
+
+
+def _safe_component(value: object, fallback: str) -> str:
+    """A single, filesystem-safe path component: no separators or ``.``/``..`` traversal, so an
+    absolute or dotted opencode id can't escape the cache root when joined with ``/``."""
+    text = str(value or fallback)
+    for sep in ("/", "\\", "\x00"):
+        text = text.replace(sep, "_")
+    return text.strip(". ") or fallback
+
+
+def _opencode_json(raw: str) -> dict:
+    # TypeError guards a SQL NULL data column (json.loads(None) raises TypeError, not ValueError).
+    try:
+        obj = json.loads(raw)
+        return obj if isinstance(obj, dict) else {"value": obj}
+    except (json.JSONDecodeError, TypeError, ValueError):
+        return {}
+
+
+def _opencode_synthesize(con: sqlite3.Connection, session_id: str) -> bytes:
+    """One NDJSON line per message (parts merged), ordered by creation time. b'' if empty."""
+    lines: list[str] = []
+    messages = con.execute(
+        "SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created, id",
+        (session_id,),
+    ).fetchall()
+    for msg_id, msg_data in messages:
+        parts = con.execute(
+            "SELECT data FROM part WHERE message_id = ? ORDER BY time_created, id",
+            (msg_id,),
+        ).fetchall()
+        record = {
+            "id": msg_id,
+            "sessionID": session_id,
+            "message": _opencode_json(msg_data),
+            "parts": [_opencode_json(p[0]) for p in parts],
+        }
+        lines.append(json.dumps(record, separators=(",", ":")))
+    return ("\n".join(lines) + "\n").encode() if lines else b""
+
+
+def find_opencode_candidates(
+    home: HomeSpec, *, cache_root: Path | None = None
+) -> Iterator[Session]:
+    """Yield a Session per opencode session, materializing each into an NDJSON transcript.
+
+    ``home.path`` is the opencode data dir (holds ``opencode.db``). Each session is synthesized
+    to ``<cache_root>/<home_label>/<project_id>/<session_id>.jsonl`` and that file becomes the
+    Session's ``abs_path`` — so scanning, redaction, upload, and dedup are all unchanged.
+    """
+    db = _opencode_db(home.path)
+    if db is None:
+        logger.debug("Skipping %s (no opencode db)", home.path)
+        return
+    root = (cache_root or OPENCODE_CACHE_ROOT) / home.label
+    try:
+        con = sqlite3.connect(_sqlite_ro_uri(db), uri=True)
+    except sqlite3.Error as exc:
+        logger.debug("opencode db open failed %s: %s", db, exc)
+        return
+    try:
+        con.row_factory = sqlite3.Row
+        try:
+            rows = con.execute(
+                "SELECT id, project_id, directory, time_updated FROM session"
+            ).fetchall()
+        except sqlite3.Error as exc:
+            logger.debug("opencode session query failed on %s: %s", db, exc)
+            return
+        for s in rows:
+            # A schema mismatch (missing message/part table) raises sqlite3.Error mid-generator;
+            # contain it per-session so one bad db doesn't abort the whole upload.
+            try:
+                data = _opencode_synthesize(con, s["id"])
+            except sqlite3.Error as exc:
+                logger.debug("opencode synthesize failed for session %s: %s", s["id"], exc)
+                continue
+            if not data:
+                continue
+            # Sanitize both components: an absolute or ``..``-laden project_id/session id would
+            # otherwise let ``root / rel`` write outside the cache (Path drops the left side on an
+            # absolute right side).
+            rel = Path(_safe_component(s["project_id"], "unknown")) / (
+                f"{_safe_component(s['id'], 'session')}.jsonl"
+            )
+            abs_path = root / rel
+            try:
+                abs_path.parent.mkdir(parents=True, exist_ok=True)
+                abs_path.write_bytes(data)
+            except OSError as exc:
+                logger.debug("opencode materialize failed %s: %s", abs_path, exc)
+                continue
+            directory = s["directory"]
+            yield Session(
+                agent=AgentKind.OPENCODE,
+                home_label=home.label,
+                abs_path=abs_path,
+                rel_path=rel,
+                size_bytes=len(data),
+                mtime=datetime.fromtimestamp((s["time_updated"] or 0) / 1000, tz=UTC),
+                cwd=Path(directory) if directory else None,
+                secret_findings=[],
+            )
+    finally:
+        con.close()
+
+
 # ----- Scan + orchestration -------------------------------------------------
 
 
@@ -243,6 +380,8 @@ def find_all_candidates(homes: Iterable[HomeSpec]) -> list[Session]:
             found.extend(find_claude_code_candidates(home))
         elif home.kind is AgentKind.CODEX:
             found.extend(find_codex_candidates(home))
+        elif home.kind is AgentKind.OPENCODE:
+            found.extend(find_opencode_candidates(home))
     found.sort(key=lambda s: s.mtime, reverse=True)
     return found
 
@@ -361,6 +500,43 @@ def _count_codex_sessions(home: Path) -> int:
         return 0
 
 
+def _count_opencode_sessions(home: Path) -> int:
+    db = _opencode_db(home)
+    if db is None:
+        return 0
+    try:
+        con = sqlite3.connect(_sqlite_ro_uri(db), uri=True)
+        try:
+            return con.execute("SELECT count(*) FROM session").fetchone()[0]
+        finally:
+            con.close()
+    except sqlite3.Error:
+        return 0
+
+
+def _detect_opencode_homes() -> dict[Path, int]:
+    """opencode lives at $XDG_DATA_HOME/opencode (default ~/.local/share/opencode), not ~/.<x>."""
+    out: dict[Path, int] = {}
+    roots: list[Path] = []
+    xdg = os.environ.get("XDG_DATA_HOME")
+    if xdg:
+        roots.append(Path(xdg) / "opencode")
+    roots.append(Path.home() / ".local" / "share" / "opencode")
+    seen: set[Path] = set()
+    for root in roots:
+        try:
+            resolved = root.resolve()
+        except OSError:
+            continue
+        if resolved in seen or not resolved.is_dir():
+            continue
+        seen.add(resolved)
+        n = _count_opencode_sessions(resolved)
+        if n > 0:
+            out[resolved] = n
+    return out
+
+
 def _detect_candidate_homes(prefix: str, counter: Callable[[Path], int]) -> dict[Path, int]:
     """Find ~/<prefix>* dirs that actually contain transcripts. Returns {resolved_path: count}."""
     out: dict[Path, int] = {}
@@ -379,11 +555,12 @@ def _detect_candidate_homes(prefix: str, counter: Callable[[Path], int]) -> dict
     return out
 
 
-def auto_detect_homes() -> tuple[list[Path], list[Path]]:
-    """Return (claude_homes, codex_homes) auto-detected under ~/ that hold transcripts."""
+def auto_detect_homes() -> tuple[list[Path], list[Path], list[Path]]:
+    """Return (claude_homes, codex_homes, opencode_homes) auto-detected that hold transcripts."""
     claude = sorted(_detect_candidate_homes(".claude", _count_cc_sessions).keys())
     codex = sorted(_detect_candidate_homes(".codex", _count_codex_sessions).keys())
-    return claude, codex
+    opencode = sorted(_detect_opencode_homes().keys())
+    return claude, codex, opencode
 
 
 def homes_from_config(cfg: UploadConfig) -> list[HomeSpec]:
@@ -401,4 +578,10 @@ def homes_from_config(cfg: UploadConfig) -> list[HomeSpec]:
             console.print(f"[yellow]skip:[/yellow] codex-home {p} no longer exists")
             continue
         homes.append(HomeSpec(kind=AgentKind.CODEX, path=p.resolve()))
+    for raw in cfg.opencode_homes:
+        p = Path(raw).expanduser()
+        if not p.is_dir():
+            console.print(f"[yellow]skip:[/yellow] opencode-home {p} no longer exists")
+            continue
+        homes.append(HomeSpec(kind=AgentKind.OPENCODE, path=p.resolve()))
     return homes

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

@@ -14,6 +14,7 @@ from datetime import datetime
 from typing import TYPE_CHECKING
 
 from ..ui.output import console
+from .conductor import conductor_workspace
 from .models import EntelligenceIdentity, UploadConfig, UploadPlan
 
 
@@ -105,6 +106,13 @@ def build_manifest(
             "mtime": s.mtime.isoformat(),
             "cwd": str(s.cwd) if s.cwd is not None else None,
             "secret_match_counts": s.secret_counts_by_type or None,
+            "pii_match_counts": s.pii_counts or None,
+            # Distinguishes "PII found and removed" from "found but left in" (secrets_mode=allow):
+            # true only when PII was detected AND this upload was redacted.
+            "pii_redacted": bool(s.pii_counts) and redacted,
+            # Orchestrator tag (orthogonal to `agent`): set when the session ran inside a
+            # Conductor workspace, so the frontend can distinguish parallel-agent runs.
+            "conductor": conductor_workspace(s.cwd),
         }
         for s in home_sessions
     ]
@@ -121,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.74 → entelligence_cli-0.1.76}/entelligence_cli/upload/models.py

@@ -20,6 +20,7 @@ MANIFEST_DIR = "_manifest"
 class AgentKind(StrEnum):
     CLAUDE_CODE = "claude-code"
     CODEX = "codex"
+    OPENCODE = "opencode"
 
 
 class HomeSpec(BaseModel):
@@ -45,6 +46,12 @@ class Session(BaseModel):
         exclude=True,
         repr=False,
     )
+    # Populated at upload time by pii.redact_pii (counts by type, never values).
+    pii_counts: dict[str, int] = Field(
+        default_factory=dict,
+        exclude=True,
+        repr=False,
+    )
 
     @property
     def cwd_str(self) -> str:
@@ -81,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:
@@ -107,9 +119,12 @@ class UploadConfig(BaseModel):
 
     claude_homes: list[str] = Field(default_factory=list)
     codex_homes: list[str] = Field(default_factory=list)
+    # opencode data dirs (e.g. ~/.local/share/opencode). Sessions live in a SQLite db there,
+    # not per-session files, so discovery materializes them into transcripts (see discovery.py).
+    opencode_homes: list[str] = Field(default_factory=list)
     secrets_mode: Literal["redact", "allow", "skip"] = Field(default="redact")
     skip_prefixes: list[str] = Field(default_factory=list)
     entelligence: EntelligenceIdentity | None = None
 
     def needs_setup(self) -> bool:
-        return not (self.claude_homes or self.codex_homes)
+        return not (self.claude_homes or self.codex_homes or self.opencode_homes)

entelligence_cli-0.1.76/entelligence_cli/upload/pii.py

@@ -0,0 +1,152 @@
+"""Client-side PII scrub — the deterministic complement to ``secrets.py``.
+
+``secrets.py`` removes credentials (detect-secrets + a pattern table). This module removes the
+*personal identifiers* that dominate coding-agent transcripts and that no secret scanner or
+chat-trained PII model handles well: the OS username baked into nearly every file path
+(``/Users/<name>/...``), the machine owner's identity (login / git name), emails, and
+URL-embedded session/installation tokens.
+
+Design decisions (see also the evaluation that rejected Rampart/StarPII for this data):
+  - Boundary-aware regex, **not** routed through ``secrets.redact_bytes``. That path assumes
+    high-entropy secrets: it substring-replaces and whole-line-wipes any value shorter than
+    ``MIN_BYTE_REPLACE_LEN`` (12) — both wrong for a 7-char username.
+  - Runs **after** ``secrets.redact_bytes`` in the pipeline: secret findings reference the
+    original line bytes, so a PII edit must not shift them first.
+  - Placeholders reuse the ``<REDACTED:Type>`` convention so a single ``grep '<REDACTED:'`` covers
+    both passes.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import getpass
+import logging
+import re
+import subprocess
+from collections import Counter
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+logger = logging.getLogger("entelligence_cli.upload")
+
+# Path segments after /Users/ or /home/ that are not people — never redact these.
+NON_USER_SEGMENTS: frozenset[str] = frozenset(
+    {
+        "shared",
+        "guest",
+        "public",
+        "default",
+        "default user",
+        "all users",
+        "administrator",
+        "root",
+        "runner",
+        "library",
+        "applications",
+        "home",
+        "user",
+    }
+)
+_NON_USER_BYTES: frozenset[bytes] = frozenset(s.encode() for s in NON_USER_SEGMENTS)
+
+# Below this length an identity token is too generic to match as a bare word safely.
+_MIN_IDENTITY_LEN = 3
+
+# /Users/<seg>, /home/<seg>, C:\Users\<seg> — the segment is the username.
+_PATH_USER_RE = re.compile(rb"(?P<pre>/Users/|/home/|[A-Za-z]:\\Users\\)(?P<seg>[^/\\\s\"']+)")
+# (?<!\\) stops a JSON escape's trailing letter from starting a bogus local-part: transcript
+# bytes carry literal `\n`/`\t` inside JSON strings, so raw `\n@click.option` is a decorator,
+# not an email. Real emails (preceded by a quote/space) still match.
+_EMAIL_RE = re.compile(rb"(?<!\\)\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b")
+# (count-label, pattern, replacement) — scrub the token, keep the public URL shape.
+_URL_TOKEN_RES: list[tuple[str, re.Pattern[bytes], bytes]] = [
+    ("Token", re.compile(rb"(claude\.ai/code/session_)[A-Za-z0-9]+"), rb"\1<REDACTED:Token>"),
+    ("Id", re.compile(rb"(/(?:app/)?installations/)\d+"), rb"\1<REDACTED:Id>"),
+    (
+        "Token",
+        re.compile(rb"([?&](?:access_token|token|api_key|key|code)=)[^\s&\"']+"),
+        rb"\1<REDACTED:Token>",
+    ),
+]
+
+_USERNAME_PLACEHOLDER = b"<REDACTED:Username>"
+
+
+@dataclass(frozen=True)
+class Identity:
+    """The machine owner's identifiers, resolved once per run."""
+
+    tokens: frozenset[str] = field(default_factory=frozenset)
+
+    @classmethod
+    def resolve(cls) -> Identity:
+        candidates: set[str] = set()
+        # Identity is best-effort; the path regex is the main signal, so swallow failures.
+        with contextlib.suppress(Exception):
+            candidates.add(getpass.getuser())
+        with contextlib.suppress(Exception):
+            candidates.add(Path.home().name)
+        candidates.add(_git_global_name())
+        tokens = {
+            t
+            for t in candidates
+            if t and len(t) >= _MIN_IDENTITY_LEN and t.lower() not in NON_USER_SEGMENTS
+        }
+        return cls(tokens=frozenset(tokens))
+
+
+def _git_global_name() -> str:
+    try:
+        result = subprocess.run(
+            ["git", "config", "--global", "user.name"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.stdout.strip()
+    except Exception:  # noqa: BLE001 — git may be absent; not fatal
+        return ""
+
+
+def redact_pii(
+    data: bytes, identity: Identity, *, redact: bool = True
+) -> tuple[bytes, dict[str, int]]:
+    """Return (new_bytes, counts_by_type). With ``redact=False`` (secrets_mode "allow"), count
+    only and leave ``data`` byte-for-byte unchanged.
+
+    Order matters: emails run *before* the identity pass so an email containing the username
+    (``rishabh@…``) is redacted whole rather than double-counted. We transform a ``work`` copy
+    through every pass so counts are accurate even in count-only mode; the original ``data`` is
+    what's returned unless ``redact`` is set.
+    """
+    counts: Counter[str] = Counter()
+
+    def _path_sub(match: re.Match[bytes]) -> bytes:
+        seg = match.group("seg")
+        if seg == _USERNAME_PLACEHOLDER or seg.lower() in _NON_USER_BYTES or len(seg) < 2:
+            return match.group(0)
+        counts["Username"] += 1
+        return match.group("pre") + _USERNAME_PLACEHOLDER
+
+    def _email_sub(_match: re.Match[bytes]) -> bytes:
+        counts["Email"] += 1
+        return b"<REDACTED:Email>"
+
+    # 1. usernames in file paths (catches teammates' usernames too, not just this machine's)
+    work = _PATH_USER_RE.sub(_path_sub, data)
+    # 2. emails — before identity, so a name embedded in an email isn't recounted below
+    work = _EMAIL_RE.sub(_email_sub, work)
+    # 3. this machine's identity as bare whole words (no substring clobber, case-insensitive)
+    for token in sorted(identity.tokens, key=len, reverse=True):
+        pattern = re.compile(rb"\b" + re.escape(token.encode()) + rb"\b", re.IGNORECASE)
+        work, n = pattern.subn(_USERNAME_PLACEHOLDER, work)
+        if n:
+            counts["Username"] += n
+    # 4. token-bearing URLs (leave public URLs intact)
+    for label, pattern, replacement in _URL_TOKEN_RES:
+        work, n = pattern.subn(replacement, work)
+        if n:
+            counts[label] += n
+
+    return (work if redact else data), dict(counts)