whycode-cli 0.2.0__tar.gz → 0.2.2__tar.gz

{whycode_cli-0.2.0/src/whycode_cli.egg-info → whycode_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whycode-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: Tells you what to be afraid of before you touch a file.
 Author: Kevin
 License-Expression: MIT
@@ -67,13 +67,14 @@ decide what to do.
 
 ## Install
 
-Once published to PyPI:
-
 ```bash
-pip install whycode
+pip install whycode-cli
 ```
 
-From source (current canonical path):
+The PyPI distribution is `whycode-cli` (the bare name `whycode` was already
+taken by an unrelated project); the installed command is still `whycode`.
+
+From source, if you want to track `main`:
 
 ```bash
 pip install git+https://github.com/fangshuor/WhyCode.git
@@ -87,9 +88,11 @@ Requires Python 3.11+.
 cd /path/to/your/repo
 
 whycode init                        # one-command setup: CI workflow + pre-commit gate
+whycode highlights                  # first-run treasure map: top decisions + incidents
 whycode why src/some/file.py        # the Risk Card for one file
 whycode why src/some/file.py -b     # one-line summary (for triage / scripts)
-whycode why src/some/file.py --at <sha>  # what did this file's risk look like as of <sha>?
+whycode why src/some/file.py --at <sha>     # risk as of a past commit
+whycode why src/some/file.py --mute <kind>  # local "this signal is wrong, hide it" feedback
 whycode diff                        # rank everything you changed vs origin/main
 whycode diff --staged               # ditto, for files staged for commit
 whycode diff --fail-on history      # CI gate: exit 1 if any file is ≥ READ HISTORY FIRST
@@ -177,11 +180,13 @@ That installs two things:
 - **`.git/hooks/pre-commit`** — runs `whycode diff --staged --fail-on handle`
   before every commit. HANDLE WITH CARE files can't be touched without an
   explicit `git commit --no-verify`.
-- **`.github/workflows/whycode.yml`** — a GitHub Action that risk-ranks every
-  PR's files and fails the build at `--fail-on history` (≥ READ HISTORY FIRST).
+- **`.github/workflows/whycode.yml`** — a GitHub Action that prints a
+  risk-ranked table for every PR. Advisory by default (never blocks merging);
+  append `--fail-on history` (or `handle` / `look`) to the diff line to turn
+  it into a hard gate.
 
-Tune the `--fail-on` thresholds inside those two files for your repo. Re-run
-with `whycode init --force` to overwrite.
+Tune the thresholds inside those two files for your repo. Re-run with
+`whycode init --force` to overwrite.
 
 **MCP server** — see the next section.
 

{whycode_cli-0.2.0 → whycode_cli-0.2.2}/README.md

@@ -39,13 +39,14 @@ decide what to do.
 
 ## Install
 
-Once published to PyPI:
-
 ```bash
-pip install whycode
+pip install whycode-cli
 ```
 
-From source (current canonical path):
+The PyPI distribution is `whycode-cli` (the bare name `whycode` was already
+taken by an unrelated project); the installed command is still `whycode`.
+
+From source, if you want to track `main`:
 
 ```bash
 pip install git+https://github.com/fangshuor/WhyCode.git
@@ -59,9 +60,11 @@ Requires Python 3.11+.
 cd /path/to/your/repo
 
 whycode init                        # one-command setup: CI workflow + pre-commit gate
+whycode highlights                  # first-run treasure map: top decisions + incidents
 whycode why src/some/file.py        # the Risk Card for one file
 whycode why src/some/file.py -b     # one-line summary (for triage / scripts)
-whycode why src/some/file.py --at <sha>  # what did this file's risk look like as of <sha>?
+whycode why src/some/file.py --at <sha>     # risk as of a past commit
+whycode why src/some/file.py --mute <kind>  # local "this signal is wrong, hide it" feedback
 whycode diff                        # rank everything you changed vs origin/main
 whycode diff --staged               # ditto, for files staged for commit
 whycode diff --fail-on history      # CI gate: exit 1 if any file is ≥ READ HISTORY FIRST
@@ -149,11 +152,13 @@ That installs two things:
 - **`.git/hooks/pre-commit`** — runs `whycode diff --staged --fail-on handle`
   before every commit. HANDLE WITH CARE files can't be touched without an
   explicit `git commit --no-verify`.
-- **`.github/workflows/whycode.yml`** — a GitHub Action that risk-ranks every
-  PR's files and fails the build at `--fail-on history` (≥ READ HISTORY FIRST).
+- **`.github/workflows/whycode.yml`** — a GitHub Action that prints a
+  risk-ranked table for every PR. Advisory by default (never blocks merging);
+  append `--fail-on history` (or `handle` / `look`) to the diff line to turn
+  it into a hard gate.
 
-Tune the `--fail-on` thresholds inside those two files for your repo. Re-run
-with `whycode init --force` to overwrite.
+Tune the thresholds inside those two files for your repo. Re-run with
+`whycode init --force` to overwrite.
 
 **MCP server** — see the next section.
 

{whycode_cli-0.2.0 → whycode_cli-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "whycode-cli"
-version = "0.2.0"
+version = "0.2.2"
 description = "Tells you what to be afraid of before you touch a file."
 readme = "README.md"
 license = "MIT"

{whycode_cli-0.2.0 → whycode_cli-0.2.2}/src/whycode/__init__.py

@@ -1,3 +1,3 @@
 """WhyCode — tells you what to be afraid of before touching a file."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{whycode_cli-0.2.0 → whycode_cli-0.2.2}/src/whycode/cli.py

@@ -4,6 +4,8 @@ Commands
 --------
 - ``whycode why <path>``        — print the Risk Card for a single file.
 - ``whycode why <path> --at SHA`` — risk card as of a past commit.
+- ``whycode why <path> --mute KIND`` — locally suppress a noisy signal kind.
+- ``whycode highlights``        — repo-wide treasure map of decisions and incidents.
 - ``whycode diff [--base REF]`` — risk-rank files changed against a base ref.
 - ``whycode show <sha>``        — risk-flavored summary for one commit.
 - ``whycode timeline <path>``   — risk score evolution across the file's history.
@@ -29,6 +31,7 @@ from whycode import __version__
 from whycode import git_facts as gf
 from whycode import risk_card as rc
 from whycode import signals as sig
+from whycode import suppressions as supp
 
 app = typer.Typer(
     add_completion=False,
@@ -119,6 +122,20 @@ def why(
         "--at",
         help="Show the Risk Card as of this commit / ref (postmortem queries).",
     ),
+    mute: list[str] = typer.Option(
+        [],
+        "--mute",
+        help=(
+            "Suppress a signal kind for this path going forward "
+            "(stored in .whycode/suppressed.json). Accepts kind name or "
+            "unique prefix: incident, revert, ghost, coupling, silence, …"
+        ),
+    ),
+    no_mutes: bool = typer.Option(
+        False,
+        "--no-mutes",
+        help="Bypass the local suppression list — show all signals.",
+    ),
     max_commits: int | None = typer.Option(
         None, "--max-commits", help="Cap the number of commits scanned (debug)."
     ),
@@ -140,7 +157,31 @@ def why(
         except gf.GitError:
             err.print(f"[red]error:[/red] unknown commit / ref: {at!r}")
             raise typer.Exit(2) from None
-    card = rc.build(repo_root, rel, max_commits=max_commits, ref=resolved_ref)
+    if mute:
+        sl = supp.load(repo_root)
+        added: list[str] = []
+        for token in mute:
+            try:
+                kind = supp.resolve_kind(token)
+            except ValueError as exc:
+                err.print(f"[red]error:[/red] {exc}")
+                raise typer.Exit(2) from None
+            if sl.add(rel, kind):
+                added.append(kind.value)
+        if added:
+            supp.save(repo_root, sl)
+            if not json_out:
+                err.print(
+                    f"[dim]muted on {rel}: {', '.join(added)}  "
+                    f"(stored in .whycode/suppressed.json — edit to undo)[/dim]"
+                )
+    card = rc.build(
+        repo_root,
+        rel,
+        max_commits=max_commits,
+        ref=resolved_ref,
+        apply_suppressions=not no_mutes,
+    )
     if json_out:
         console.print_json(json.dumps(card.to_dict()))
         return
@@ -286,6 +327,136 @@ def diff(
             raise typer.Exit(1)
 
 
+@app.command()
+def highlights(
+    invariants: int = typer.Option(
+        5, "--invariants", help="How many invariant lines to surface."
+    ),
+    incidents: int = typer.Option(
+        5, "--incidents", help="How many incident commits to surface."
+    ),
+    max_commits: int | None = typer.Option(
+        None,
+        "--max-commits",
+        help="Cap on commits scanned (defaults to no cap; tune for very large repos).",
+    ),
+    repo: Path = typer.Option(Path("."), "--repo", help="Path inside the repo."),
+    json_out: bool = typer.Option(
+        False, "--json", help="Emit machine-readable JSON instead of a card."
+    ),
+) -> None:
+    """The first-run treasure map: top decisions and incidents across the repo.
+
+    Surfaces the highest-value commit-message lines (invariants stated by past
+    authors) and the most recent incident-flavoured commits — the things a
+    reader most wants to know about the codebase before touching anything.
+    """
+    try:
+        repo_root = gf.discover_repo_root(repo.resolve())
+    except gf.GitError as exc:
+        err.print(f"[red]error:[/red] {exc}")
+        raise typer.Exit(2) from exc
+
+    with console.status("Reading repo history…", spinner="dots"):
+        commits = gf.all_commits(repo_root, max_count=max_commits)
+    if not commits:
+        console.print("[yellow]no commits in this repo[/yellow]")
+        return
+
+    inv_pairs = gf.extract_invariant_quotes(commits)
+    sha_to_commit = {c.sha: c for c in commits}
+    seen_lines: dict[str, str] = {}
+    for sha, line in inv_pairs:
+        seen_lines.setdefault(line, sha)
+    inv_records: list[tuple[str, str, gf.Commit]] = []
+    for line, sha in seen_lines.items():
+        commit = sha_to_commit.get(sha)
+        if commit is None:
+            continue
+        inv_records.append((line, sha, commit))
+    inv_records.sort(key=lambda t: t[2].authored_at, reverse=True)
+    inv_records = inv_records[:invariants]
+
+    incident_records = gf.find_incidents(commits)[:incidents]
+
+    if json_out:
+        console.print_json(
+            json.dumps(
+                {
+                    "repo": str(repo_root),
+                    "scanned_commits": len(commits),
+                    "invariants": [
+                        {
+                            "sha": c.sha[:12],
+                            "subject": c.subject,
+                            "author": c.author_name,
+                            "authored_at": c.authored_at.isoformat(),
+                            "line": line,
+                        }
+                        for line, _, c in inv_records
+                    ],
+                    "incidents": [
+                        {
+                            "sha": c.sha[:12],
+                            "subject": c.subject,
+                            "author": c.author_name,
+                            "authored_at": c.authored_at.isoformat(),
+                        }
+                        for c in incident_records
+                    ],
+                }
+            )
+        )
+        return
+
+    console.print(
+        f"[bold]WhyCode highlights[/bold]   "
+        f"[dim]{len(commits)} commits scanned in this repo[/dim]\n"
+    )
+    if inv_records:
+        console.print(
+            f"[bold yellow]INVARIANTS[/bold yellow] "
+            f"[dim]({len(inv_records)} most recent stated by past authors)[/dim]"
+        )
+        for i, (line, sha, commit) in enumerate(inv_records, 1):
+            short = sha[:7]
+            date = str(commit.authored_at.date())
+            console.print(
+                f"  {i}. [dim]{short}  {date}  {commit.author_name}[/dim]"
+            )
+            console.print(f"     [italic]{line}[/italic]")
+        console.print()
+    else:
+        console.print(
+            "[dim]INVARIANTS: none found. The repo's commit bodies don't use "
+            "cautionary language like 'do not', 'must not', 'warning:', etc.[/dim]\n"
+        )
+
+    if incident_records:
+        console.print(
+            f"[bold red]INCIDENTS[/bold red] "
+            f"[dim]({len(incident_records)} most recent incident-flavoured commits)[/dim]"
+        )
+        for i, c in enumerate(incident_records, 1):
+            short = c.sha[:7]
+            date = str(c.authored_at.date())
+            subj = c.subject if len(c.subject) <= 70 else c.subject[:69] + "…"
+            console.print(
+                f"  {i}. [dim]{short}  {date}  {c.author_name}[/dim]\n"
+                f"     {subj}"
+            )
+        console.print()
+    else:
+        console.print(
+            "[dim]INCIDENTS: none found. No commit subject contains 'hotfix', "
+            "'incident', 'regression', etc.[/dim]\n"
+        )
+
+    console.print(
+        "[dim]→ whycode why <path>   to dig into the file behind any of these.[/dim]"
+    )
+
+
 def _sample_indices(total: int, max_samples: int) -> list[int]:
     """Pick at most ``max_samples`` indices spread across [0, total).
 

{whycode_cli-0.2.0 → whycode_cli-0.2.2}/src/whycode/risk_card.py

@@ -18,6 +18,7 @@ from rich.text import Text
 
 from whycode import git_facts as gf
 from whycode import signals as sig
+from whycode import suppressions as supp
 from whycode.scorer import Band, Score, score
 
 if TYPE_CHECKING:
@@ -73,9 +74,20 @@ def build(
     *,
     max_commits: int | None = None,
     ref: str | None = None,
+    apply_suppressions: bool = True,
 ) -> RiskCard:
+    """Build a Risk Card.
+
+    By default, signals matching the local ``.whycode/suppressed.json`` list
+    are dropped — that file is the user's "this signal is wrong, hide it"
+    feedback. Pass ``apply_suppressions=False`` to bypass it (useful for
+    debug or auditing what was hidden).
+    """
     facts = gf.gather(repo_root, path, max_commits=max_commits, ref=ref)
     signals = sig.all_signals(facts)
+    if apply_suppressions:
+        suppressions = supp.load(repo_root)
+        signals = supp.filter_signals(signals, suppressions, path)
     s = score(signals)
     head = facts.commits[0] if facts.commits else None
     return RiskCard(

whycode_cli-0.2.2/src/whycode/suppressions.py

@@ -0,0 +1,123 @@
+"""Local suppression list — the "this signal is wrong, hide it" feedback loop.
+
+Stored at ``<repo>/.whycode/suppressed.json``.  ``.whycode/`` is gitignored,
+so the list is per-developer and never travels with the repo.  This honours
+the privacy contract: no central DB, no telemetry, no cross-team sharing of
+"these signals are bogus" data.
+
+Schema (intentionally tiny — easy to hand-edit):
+
+    {
+      "suppressed": [
+        ["src/foo.py", "incident_history"],
+        ["src/bar.py", "ghost_keeper"]
+      ]
+    }
+
+Match is exact ``(path, kind)`` — no globs.  We can add patterns if real
+users ask for them; for now precision beats convenience.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable, Iterator
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from whycode.signals import SignalKind
+
+if TYPE_CHECKING:
+    from whycode.signals import Signal
+
+_FILENAME = "suppressed.json"
+_DIRNAME = ".whycode"
+
+
+@dataclass
+class SuppressionList:
+    entries: list[tuple[str, str]] = field(default_factory=list)
+
+    def is_suppressed(self, path: str, kind: SignalKind) -> bool:
+        return (path, kind.value) in self.entries
+
+    def add(self, path: str, kind: SignalKind) -> bool:
+        """Idempotent. Returns True if a new entry was added."""
+        pair = (path, kind.value)
+        if pair in self.entries:
+            return False
+        self.entries.append(pair)
+        return True
+
+    def __iter__(self) -> Iterator[tuple[str, str]]:
+        return iter(self.entries)
+
+    def __len__(self) -> int:
+        return len(self.entries)
+
+
+def _path(repo_root: Path) -> Path:
+    return repo_root / _DIRNAME / _FILENAME
+
+
+def load(repo_root: Path) -> SuppressionList:
+    """Return the suppression list for ``repo_root``. Empty if no file exists."""
+    target = _path(repo_root)
+    if not target.exists():
+        return SuppressionList()
+    try:
+        raw = json.loads(target.read_text())
+    except (OSError, json.JSONDecodeError):
+        # A corrupt file should not stop ``whycode why`` from running.
+        # Treat as empty and let the user see what happened on next save.
+        return SuppressionList()
+    items = raw.get("suppressed", [])
+    out: list[tuple[str, str]] = []
+    for item in items:
+        if isinstance(item, list) and len(item) == 2:
+            out.append((str(item[0]), str(item[1])))
+    return SuppressionList(entries=out)
+
+
+def save(repo_root: Path, sl: SuppressionList) -> None:
+    target = _path(repo_root)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    payload = {"suppressed": [list(pair) for pair in sl.entries]}
+    target.write_text(json.dumps(payload, indent=2) + "\n")
+
+
+def resolve_kind(token: str) -> SignalKind:
+    """Resolve a user-supplied kind name (or unique prefix) to a SignalKind.
+
+    Raises ValueError when the token is unknown or matches multiple kinds.
+    """
+    needle = token.lower().replace("-", "_").strip()
+    if not needle:
+        raise ValueError("empty signal kind")
+    matches = [k for k in SignalKind if needle in k.value]
+    if not matches:
+        raise ValueError(
+            f"unknown signal kind: {token!r}. "
+            f"Known: {', '.join(k.value for k in SignalKind)}"
+        )
+    if len(matches) > 1:
+        names = ", ".join(k.value for k in matches)
+        raise ValueError(f"ambiguous: {token!r} matches multiple kinds: {names}")
+    return matches[0]
+
+
+def filter_signals(
+    signals: Iterable[Signal], suppressions: SuppressionList, path: str
+) -> list[Signal]:
+    """Drop signals whose ``(path, kind)`` is in the suppression list."""
+    return [s for s in signals if not suppressions.is_suppressed(path, s.kind)]
+
+
+__all__ = [
+    "SuppressionList",
+    "filter_signals",
+    "load",
+    "resolve_kind",
+    "save",
+]

whycode_cli-0.2.2/src/whycode/templates/github-workflow.yml

@@ -0,0 +1,40 @@
+# Risk-rank pull requests with WhyCode.
+#
+# On every PR this workflow computes the Risk Card for each changed file
+# (vs the PR base) and prints a risk-ranked table to the job log.
+# Advisory by default — humans decide.
+#
+# To turn it into a hard gate that blocks merging, append `--fail-on <band>`
+# to the `whycode diff` line below:
+#   handle    block at HANDLE WITH CARE   (score >= 75)
+#   history   block at READ HISTORY FIRST (score >= 50)
+#   look      stricter — block at >= 25
+name: WhyCode
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: read
+
+jobs:
+  whycode:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out PR
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # WhyCode needs full history
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install WhyCode
+        run: pip install whycode-cli
+
+      - name: Risk-rank files in this PR
+        run: whycode diff --base origin/${{ github.base_ref }}

{whycode_cli-0.2.0 → whycode_cli-0.2.2/src/whycode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whycode-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: Tells you what to be afraid of before you touch a file.
 Author: Kevin
 License-Expression: MIT
@@ -67,13 +67,14 @@ decide what to do.
 
 ## Install
 
-Once published to PyPI:
-
 ```bash
-pip install whycode
+pip install whycode-cli
 ```
 
-From source (current canonical path):
+The PyPI distribution is `whycode-cli` (the bare name `whycode` was already
+taken by an unrelated project); the installed command is still `whycode`.
+
+From source, if you want to track `main`:
 
 ```bash
 pip install git+https://github.com/fangshuor/WhyCode.git
@@ -87,9 +88,11 @@ Requires Python 3.11+.
 cd /path/to/your/repo
 
 whycode init                        # one-command setup: CI workflow + pre-commit gate
+whycode highlights                  # first-run treasure map: top decisions + incidents
 whycode why src/some/file.py        # the Risk Card for one file
 whycode why src/some/file.py -b     # one-line summary (for triage / scripts)
-whycode why src/some/file.py --at <sha>  # what did this file's risk look like as of <sha>?
+whycode why src/some/file.py --at <sha>     # risk as of a past commit
+whycode why src/some/file.py --mute <kind>  # local "this signal is wrong, hide it" feedback
 whycode diff                        # rank everything you changed vs origin/main
 whycode diff --staged               # ditto, for files staged for commit
 whycode diff --fail-on history      # CI gate: exit 1 if any file is ≥ READ HISTORY FIRST
@@ -177,11 +180,13 @@ That installs two things:
 - **`.git/hooks/pre-commit`** — runs `whycode diff --staged --fail-on handle`
   before every commit. HANDLE WITH CARE files can't be touched without an
   explicit `git commit --no-verify`.
-- **`.github/workflows/whycode.yml`** — a GitHub Action that risk-ranks every
-  PR's files and fails the build at `--fail-on history` (≥ READ HISTORY FIRST).
+- **`.github/workflows/whycode.yml`** — a GitHub Action that prints a
+  risk-ranked table for every PR. Advisory by default (never blocks merging);
+  append `--fail-on history` (or `handle` / `look`) to the diff line to turn
+  it into a hard gate.
 
-Tune the `--fail-on` thresholds inside those two files for your repo. Re-run
-with `whycode init --force` to overwrite.
+Tune the thresholds inside those two files for your repo. Re-run with
+`whycode init --force` to overwrite.
 
 **MCP server** — see the next section.
 

{whycode_cli-0.2.0 → whycode_cli-0.2.2}/src/whycode_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/whycode/mcp_server.py
 src/whycode/risk_card.py
 src/whycode/scorer.py
 src/whycode/signals.py
+src/whycode/suppressions.py
 src/whycode/templates/__init__.py
 src/whycode/templates/github-workflow.yml
 src/whycode/templates/pre-commit
@@ -21,4 +22,5 @@ src/whycode_cli.egg-info/top_level.txt
 tests/test_cli.py
 tests/test_git_facts.py
 tests/test_scorer.py
-tests/test_signals.py
+tests/test_signals.py
+tests/test_suppressions.py

{whycode_cli-0.2.0 → whycode_cli-0.2.2}/tests/test_cli.py

@@ -377,6 +377,94 @@ def test_honest_silent_when_no_invariants(repo, days_ago) -> None:  # type: igno
     assert "no invariants" in result.output.lower()
 
 
+def test_highlights_surfaces_invariants_and_incidents(repo, days_ago) -> None:  # type: ignore[no-untyped-def]
+    repo.commit(
+        "compat: keep sync path",
+        {"a.py": "1"},
+        body="Do not switch to async — v1 clients break.",
+        when=days_ago(60),
+    )
+    repo.commit(
+        "hotfix: refund regression",
+        {"b.py": "1"},
+        body="See INC-447 for context.",
+        when=days_ago(20),
+    )
+    result = _invoke(repo.root, "highlights")
+    assert result.exit_code == 0
+    out = result.output
+    assert "INVARIANTS" in out
+    assert "Do not switch to async" in out
+    assert "INCIDENTS" in out
+    assert "hotfix: refund regression" in out
+
+
+def test_highlights_json_output(repo, days_ago) -> None:  # type: ignore[no-untyped-def]
+    repo.commit(
+        "compat: keep sync",
+        {"a.py": "1"},
+        body="Important: legacy header must stay.",
+        when=days_ago(30),
+    )
+    result = _invoke(repo.root, "highlights", "--json")
+    assert result.exit_code == 0
+    data = json.loads(result.output)
+    assert "invariants" in data
+    assert "incidents" in data
+    assert any("legacy header" in inv["line"] for inv in data["invariants"])
+
+
+def test_highlights_quiet_repo_does_not_error(repo) -> None:  # type: ignore[no-untyped-def]
+    repo.commit("init: nothing here", {"a.py": "1"})
+    result = _invoke(repo.root, "highlights")
+    assert result.exit_code == 0
+    out = result.output.lower()
+    assert "none found" in out
+
+
+def test_why_mute_writes_suppression_and_hides_signal(repo, days_ago) -> None:  # type: ignore[no-untyped-def]
+    repo.commit(
+        "init",
+        {"refund.py": "1"},
+        when=days_ago(60),
+    )
+    repo.commit(
+        "hotfix: regression",
+        {"refund.py": "2"},
+        body="See #INC-42",
+        when=days_ago(10),
+    )
+    # First call: incident_history fires.
+    before = _invoke(repo.root, "why", "refund.py", "--json")
+    data_before = json.loads(before.output)
+    assert any(s["kind"] == "incident_history" for s in data_before["signals"])
+
+    # Mute it.
+    muted = _invoke(repo.root, "why", "refund.py", "--mute", "incident", "--json")
+    assert muted.exit_code == 0
+    data_muted = json.loads(muted.output)
+    assert all(s["kind"] != "incident_history" for s in data_muted["signals"])
+    # File now exists on disk.
+    assert (repo.root / ".whycode" / "suppressed.json").exists()
+
+    # Subsequent run: still hidden (persistence).
+    again = _invoke(repo.root, "why", "refund.py", "--json")
+    data_again = json.loads(again.output)
+    assert all(s["kind"] != "incident_history" for s in data_again["signals"])
+
+    # --no-mutes brings it back without removing from the file.
+    bypass = _invoke(repo.root, "why", "refund.py", "--no-mutes", "--json")
+    data_bypass = json.loads(bypass.output)
+    assert any(s["kind"] == "incident_history" for s in data_bypass["signals"])
+
+
+def test_why_mute_unknown_kind_errors(repo) -> None:  # type: ignore[no-untyped-def]
+    repo.commit("init", {"a.py": "1"})
+    result = _invoke(repo.root, "why", "a.py", "--mute", "nonsense")
+    assert result.exit_code != 0
+    assert "unknown signal kind" in result.output.lower()
+
+
 def test_mcp_summary_field_present_in_json(repo, days_ago) -> None:  # type: ignore[no-untyped-def]
     """Verify the MCP server includes a quotable summary string in get_risk_profile."""
     sha = repo.commit("feat: A", {"a.py": "1"}, when=days_ago(40))

whycode_cli-0.2.2/tests/test_suppressions.py

@@ -0,0 +1,96 @@
+"""Tests for the local suppression list."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from whycode import suppressions as sup
+from whycode.signals import SignalKind
+
+
+def test_empty_when_no_file(tmp_path) -> None:  # type: ignore[no-untyped-def]
+    sl = sup.load(tmp_path)
+    assert len(sl) == 0
+    assert not sl.is_suppressed("foo.py", SignalKind.NEWBORN)
+
+
+def test_add_save_load_roundtrip(tmp_path) -> None:  # type: ignore[no-untyped-def]
+    sl = sup.load(tmp_path)
+    assert sl.add("src/a.py", SignalKind.INCIDENT_HISTORY) is True
+    assert sl.add("src/a.py", SignalKind.INCIDENT_HISTORY) is False  # idempotent
+    sl.add("src/b.py", SignalKind.GHOST_KEEPER)
+    sup.save(tmp_path, sl)
+
+    reloaded = sup.load(tmp_path)
+    assert reloaded.is_suppressed("src/a.py", SignalKind.INCIDENT_HISTORY)
+    assert reloaded.is_suppressed("src/b.py", SignalKind.GHOST_KEEPER)
+    assert not reloaded.is_suppressed("src/a.py", SignalKind.GHOST_KEEPER)
+    assert not reloaded.is_suppressed("src/c.py", SignalKind.INCIDENT_HISTORY)
+
+
+def test_corrupt_file_treated_as_empty(tmp_path) -> None:  # type: ignore[no-untyped-def]
+    target = tmp_path / ".whycode" / "suppressed.json"
+    target.parent.mkdir()
+    target.write_text("not json {")
+    sl = sup.load(tmp_path)
+    assert len(sl) == 0  # graceful degradation
+
+
+def test_save_creates_directory(tmp_path) -> None:  # type: ignore[no-untyped-def]
+    sl = sup.SuppressionList()
+    sl.add("a.py", SignalKind.SILENCE)
+    sup.save(tmp_path, sl)
+    assert (tmp_path / ".whycode" / "suppressed.json").exists()
+    payload = json.loads((tmp_path / ".whycode" / "suppressed.json").read_text())
+    assert payload == {"suppressed": [["a.py", "silence"]]}
+
+
+def test_resolve_kind_exact_match() -> None:
+    assert sup.resolve_kind("incident_history") is SignalKind.INCIDENT_HISTORY
+
+
+def test_resolve_kind_prefix_match() -> None:
+    assert sup.resolve_kind("revert") is SignalKind.REVERT_CHAIN
+    assert sup.resolve_kind("ghost") is SignalKind.GHOST_KEEPER
+    assert sup.resolve_kind("invariant") is SignalKind.INVARIANT_QUOTE
+
+
+def test_resolve_kind_dash_normalised() -> None:
+    assert sup.resolve_kind("incident-history") is SignalKind.INCIDENT_HISTORY
+
+
+def test_resolve_kind_unknown_raises() -> None:
+    with pytest.raises(ValueError, match="unknown signal kind"):
+        sup.resolve_kind("nonsense")
+
+
+def test_resolve_kind_empty_raises() -> None:
+    with pytest.raises(ValueError, match="empty"):
+        sup.resolve_kind("")
+
+
+def test_filter_signals_drops_suppressed() -> None:
+    from whycode.signals import Signal
+
+    sigs = [
+        Signal(kind=SignalKind.INCIDENT_HISTORY, severity=3, headline="x", detail="x"),
+        Signal(kind=SignalKind.SILENCE, severity=2, headline="y", detail="y"),
+    ]
+    sl = sup.SuppressionList()
+    sl.add("foo.py", SignalKind.INCIDENT_HISTORY)
+    out = sup.filter_signals(sigs, sl, "foo.py")
+    assert len(out) == 1
+    assert out[0].kind is SignalKind.SILENCE
+
+
+def test_filter_signals_path_specific() -> None:
+    from whycode.signals import Signal
+
+    sigs = [Signal(kind=SignalKind.INCIDENT_HISTORY, severity=3, headline="x", detail="x")]
+    sl = sup.SuppressionList()
+    sl.add("other.py", SignalKind.INCIDENT_HISTORY)
+    # Suppression is for other.py — must not affect foo.py.
+    out = sup.filter_signals(sigs, sl, "foo.py")
+    assert len(out) == 1

whycode_cli-0.2.0/src/whycode/templates/github-workflow.yml

@@ -1,42 +0,0 @@
-# Risk-gates pull requests with WhyCode.
-#
-# On every PR this workflow computes the Risk Card for each changed file
-# (vs the PR base) and:
-#   - prints a risk-ranked table to the job log
-#   - exits non-zero if any file reaches the band you choose, blocking merge
-#
-# Tune `--fail-on` to taste:
-#   handle   block PRs touching files >= HANDLE WITH CARE (>= 75)
-#   history  block PRs touching files >= READ HISTORY FIRST (>= 50)
-#   look     stricter; block at >= 25 (probably too noisy)
-#
-# Remove `--fail-on` entirely to make WhyCode advisory only.
-name: WhyCode
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-
-permissions:
-  contents: read
-  pull-requests: read
-
-jobs:
-  whycode:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out PR
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0  # WhyCode needs full history
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install WhyCode
-        run: pip install git+https://github.com/fangshuor/WhyCode.git
-
-      - name: Risk-rank files in this PR
-        run: whycode diff --base origin/${{ github.base_ref }} --fail-on history