whycode-cli 0.4.0__tar.gz → 0.4.2__tar.gz

{whycode_cli-0.4.0 → whycode_cli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whycode-cli
-Version: 0.4.0
+Version: 0.4.2
 Summary: Tells you what to be afraid of before you touch a file.
 Author: Kevin
 License-Expression: MIT

{whycode_cli-0.4.0 → whycode_cli-0.4.2}/pyproject.toml

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

{whycode_cli-0.4.0 → whycode_cli-0.4.2}/src/whycode/__init__.py

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

{whycode_cli-0.4.0 → whycode_cli-0.4.2}/src/whycode/cache.py

@@ -112,10 +112,21 @@ class CacheStore:
     cache misses; this class never invokes ``git`` itself.
     """
 
-    def __init__(self, db_path: Path) -> None:
+    def __init__(self, db_path: Path, *, in_memory: bool = False) -> None:
+        """Open (creating if needed) the SQLite cache at ``db_path``.
+
+        ``in_memory=True`` opens a transient ``:memory:`` connection
+        instead — the disk file is never created and is never read.
+        Used by ``--no-cache`` to retain in-session amortisation
+        (matches the cold-fill code path) without persisting anything.
+        """
         self.db_path = db_path
-        self.db_path.parent.mkdir(parents=True, exist_ok=True)
-        self._conn = sqlite3.connect(self.db_path)
+        self._in_memory = in_memory
+        if in_memory:
+            self._conn = sqlite3.connect(":memory:")
+        else:
+            self.db_path.parent.mkdir(parents=True, exist_ok=True)
+            self._conn = sqlite3.connect(self.db_path)
         # row_factory makes column access readable in tests / debug.
         self._conn.row_factory = sqlite3.Row
         self._conn.execute("PRAGMA foreign_keys = ON")
@@ -402,13 +413,18 @@ class CacheStore:
         file_row_count = int(
             self._conn.execute("SELECT COUNT(*) FROM commit_files").fetchone()[0]
         )
-        try:
-            size_bytes = self.db_path.stat().st_size
-        except OSError:
+        if self._in_memory:
             size_bytes = 0
+            exists = False
+        else:
+            try:
+                size_bytes = self.db_path.stat().st_size
+            except OSError:
+                size_bytes = 0
+            exists = self.db_path.exists()
         return CacheStats(
             path=self.db_path,
-            exists=self.db_path.exists(),
+            exists=exists,
             schema_version=self.schema_version,
             head_sha=self.head_sha,
             commit_count=commit_count,
@@ -430,6 +446,16 @@ def open_for(repo_root: Path) -> CacheStore:
     return CacheStore(cache_path_for(repo_root))
 
 
+def open_in_memory(repo_root: Path) -> CacheStore:
+    """Open a transient in-memory cache for ``repo_root``.
+
+    Used by ``--no-cache`` to keep within-session amortisation (the same
+    cold-fill code path everything else uses) while never touching disk.
+    The store is destroyed on ``close()`` and has no after-effects.
+    """
+    return CacheStore(cache_path_for(repo_root), in_memory=True)
+
+
 def parse_authored_at(value: str) -> datetime:
     """Parse the ``authored_at`` string we stored from git.
 

{whycode_cli-0.4.0 → whycode_cli-0.4.2}/src/whycode/cli.py

@@ -20,10 +20,12 @@ Commands
 
 from __future__ import annotations
 
+import functools
 import json
 import sys
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any
+from typing import Any, TypeVar
 
 import typer
 from rich.console import Console
@@ -48,18 +50,27 @@ err = Console(stderr=True)
 
 
 def _open_cache(repo_root: Path, no_cache: bool) -> ch.CacheStore | None:
-    """Open the on-disk cache for ``repo_root`` unless suppressed.
-
-    A None return means "do not pass a cache through git_facts" — every
-    git-side helper falls back to its original network-free, cache-free
-    implementation. This is the escape hatch behind ``--no-cache`` and
-    is also the default when the cache cannot be initialised at all
-    (read-only filesystem, etc.); we never want a cache failure to
-    block the main read path.
+    """Open the cache for ``repo_root`` according to the no-cache flag.
+
+    Modes:
+      * ``no_cache=False`` (the default): persistent on-disk SQLite at
+        ``.whycode/cache.db``.
+      * ``no_cache=True``: a transient ``:memory:`` SQLite store. The
+        same git-walk code path runs as for the cold-fill, but the
+        database is destroyed on ``close()`` — nothing lands on disk
+        and the next run starts cold. Keeping per-run amortisation
+        (one ``git log`` walk shared across files) is what makes
+        ``--no-cache`` at most as slow as a cold persistent fill;
+        the previous ``cache=None`` short-circuit lost that and so
+        ``--no-cache`` re-issued per-file walks every iteration.
+
+    A ``None`` return means "do not pass a cache through git_facts".
+    Happens only when even an in-memory open fails — very rare and
+    we never want a cache problem to block the main read path.
     """
-    if no_cache:
-        return None
     try:
+        if no_cache:
+            return ch.open_in_memory(repo_root)
         return ch.open_for(repo_root)
     except OSError:
         return None
@@ -115,6 +126,37 @@ def _require_tracked(path_arg: str) -> tuple[Path, str]:
     return repo_root, rel
 
 
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+
+def _propagate_failures(func: _F) -> _F:
+    """Convert any uncaught exception into ``typer.Exit(2)``.
+
+    A read-only field test against psf/requests caught a bug where a single
+    bad-timezone commit raised ``ValueError`` deep inside ``_parse_log_records``;
+    Rich rendered the traceback to stderr, but the process exited with status
+    0. CI integrations could not tell that the run had silently failed
+    (a ``whycode diff --fail-on history`` step was reported as green even
+    though it had crashed). We wrap each command body so any unhandled
+    exception leaves the existing rich traceback rendering in place but
+    forces a non-zero exit code (``2`` for general failure). ``typer.Exit``
+    and ``KeyboardInterrupt`` propagate untouched so explicit exit-code
+    paths and Ctrl-C still behave normally.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return func(*args, **kwargs)
+        except (typer.Exit, typer.Abort, KeyboardInterrupt):
+            raise
+        except Exception as exc:
+            err.print_exception(show_locals=False)
+            raise typer.Exit(2) from exc
+
+    return wrapper  # type: ignore[return-value]
+
+
 # --- shared: band threshold parsing ----------------------------------------
 
 _BAND_THRESHOLDS_BY_KEY: dict[str, int] = {
@@ -148,6 +190,7 @@ def _print_brief(card: rc.RiskCard) -> None:
 
 
 @app.command()
+@_propagate_failures
 def why(
     path: str = typer.Argument(..., help="File path to inspect."),
     json_out: bool = typer.Option(
@@ -317,6 +360,7 @@ def _resolve_base_ref(repo_root: Path, requested: str | None) -> str:
 
 
 @app.command()
+@_propagate_failures
 def diff(
     base: str | None = typer.Option(
         None, "--base", help="Base ref (default: origin/main → main → HEAD~1)."
@@ -390,7 +434,9 @@ def diff(
                 cards.append(rc.build(repo_root, f, cache=cache))
             except gf.GitError:
                 continue
-        cards.sort(key=lambda c: -c.score.value)
+        # Stable tie-break: lex smallest path on identical scores so cache
+        # and --no-cache truncate the same files at --top N.
+        cards.sort(key=lambda c: (-c.score.value, c.path))
         cards = cards[:top]
     finally:
         if cache is not None:
@@ -482,6 +528,7 @@ def diff(
 
 
 @app.command()
+@_propagate_failures
 def highlights(
     invariants: int = typer.Option(
         5, "--invariants", help="How many invariant lines to surface."
@@ -529,16 +576,17 @@ def highlights(
 
     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)
+    deduped = gf.dedupe_invariant_lines(inv_pairs, sha_to_commit)
     inv_records: list[tuple[str, str, gf.Commit]] = []
-    for line, sha in seen_lines.items():
+    for sha, line in deduped:
         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)
+    # Sort newest first; on identical timestamps fall back to lexicographically
+    # smallest sha so cache and --no-cache emit byte-identical output.
+    inv_records.sort(key=lambda t: t[1])  # secondary: sha asc
+    inv_records.sort(key=lambda t: t[2].authored_at, reverse=True)  # primary
     inv_records = inv_records[:invariants]
 
     incident_records = gf.find_incidents(commits)[:incidents]
@@ -636,6 +684,7 @@ def _sample_indices(total: int, max_samples: int) -> list[int]:
 
 
 @app.command()
+@_propagate_failures
 def timeline(
     path: str = typer.Argument(..., help="File path to inspect."),
     samples: int = typer.Option(
@@ -677,6 +726,12 @@ def timeline(
                     top,
                 )
             )
+    # Field-test report F14: ``timeline`` used to render rows in whatever
+    # non-monotonic order ``_sample_indices`` produced (uniform-across-index
+    # selection on a list whose ordering is git's parent traversal).  Sort
+    # by date ascending before rendering so a reader can scan left-to-right
+    # without misreading the trajectory.
+    rows.sort(key=lambda r: r[0])
 
     if json_out:
         console.print_json(
@@ -714,6 +769,7 @@ def timeline(
 
 
 @app.command()
+@_propagate_failures
 def scan(
     top: int = typer.Option(10, "--top", help="How many files to list."),
     sample: int = typer.Option(
@@ -783,7 +839,10 @@ def scan(
         if cache is not None:
             cache.close()
 
-    cards.sort(key=lambda c: -c.score.value)
+    # Stable tie-break on identical scores: lexicographically smallest path
+    # so cache and --no-cache produce byte-identical text output for the
+    # same HEAD. Without this, the truncation at --top N is non-deterministic.
+    cards.sort(key=lambda c: (-c.score.value, c.path))
     top_cards = cards[:top]
     if not top_cards:
         # Be honest about what "no flagged files" actually means. A user who
@@ -811,6 +870,7 @@ def scan(
 
 
 @app.command()
+@_propagate_failures
 def honest(
     path: str = typer.Argument(..., help="File path to inspect."),
     json_out: bool = typer.Option(False, "--json", help="Emit JSON instead of prose."),
@@ -874,6 +934,7 @@ def honest(
 
 
 @app.command()
+@_propagate_failures
 def show(
     sha: str = typer.Argument(..., help="Commit SHA (full or short) to inspect."),
     repo: Path = typer.Option(Path("."), "--repo", help="Path inside the repo."),
@@ -903,7 +964,8 @@ def show(
             cards.append(rc.build(repo_root, change.path))
         except gf.GitError:
             continue
-    cards.sort(key=lambda c: -c.score.value)
+    # Stable tie-break on identical scores: lex smallest path.
+    cards.sort(key=lambda c: (-c.score.value, c.path))
 
     if json_out:
         console.print_json(
@@ -981,6 +1043,7 @@ _MCP_SNIPPET = '''    {
 
 
 @app.command()
+@_propagate_failures
 def tour(
     repo: Path = typer.Option(Path("."), "--repo", help="Path inside the repo."),
     no_cache: bool = typer.Option(
@@ -1018,29 +1081,50 @@ def tour(
 
         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)
+        deduped = gf.dedupe_invariant_lines(inv_pairs, sha_to_commit)
+        # Sort newest first with sha-asc tie-break so cache and --no-cache
+        # surface the same three lines in the same order.
+        deduped_sorted = sorted(
+            (p for p in deduped if p[0] in sha_to_commit),
+            key=lambda p: p[0],
+        )
+        deduped_sorted.sort(
+            key=lambda p: sha_to_commit[p[0]].authored_at, reverse=True
+        )
         invariants_top = [
-            (line, sha_to_commit[sha])
-            for line, sha in seen_lines.items()
-            if sha in sha_to_commit
+            (line, sha_to_commit[sha]) for sha, line in deduped_sorted
         ][:3]
         incidents_top = gf.find_incidents(commits)[:3]
 
         if invariants_top or incidents_top:
-            console.print("[bold yellow]Decisions and incidents[/bold yellow]")
-            for line, c in invariants_top:
-                console.print(f"  [italic]{line}[/italic]")
+            # Field-test report F16: the original tour rendered both classes
+            # under one ``Decisions and incidents`` header, so a parenthetical
+            # invariant prose line was visually indistinguishable from a real
+            # incident commit. Render two subheads matching the layout
+            # ``highlights`` already uses.
+            if invariants_top:
                 console.print(
-                    f"  [dim]{c.sha[:7]}  {c.authored_at.date()}  {c.author_name}[/dim]\n"
+                    f"[bold yellow]Stated invariants[/bold yellow] "
+                    f"[dim]({len(invariants_top)} most recent)[/dim]"
                 )
-            for c in incidents_top:
-                subj = c.subject if len(c.subject) <= 70 else c.subject[:69] + "…"
-                console.print(f"  [red]{subj}[/red]")
+                for line, c in invariants_top:
+                    console.print(f"  [italic]{line}[/italic]")
+                    console.print(
+                        f"  [dim]{c.sha[:7]}  {c.authored_at.date()}  "
+                        f"{c.author_name}[/dim]\n"
+                    )
+            if incidents_top:
                 console.print(
-                    f"  [dim]{c.sha[:7]}  {c.authored_at.date()}  {c.author_name}[/dim]\n"
+                    f"[bold red]Recent incidents[/bold red] "
+                    f"[dim]({len(incidents_top)} most recent)[/dim]"
                 )
+                for c in incidents_top:
+                    subj = c.subject if len(c.subject) <= 70 else c.subject[:69] + "…"
+                    console.print(f"  [red]{subj}[/red]")
+                    console.print(
+                        f"  [dim]{c.sha[:7]}  {c.authored_at.date()}  "
+                        f"{c.author_name}[/dim]\n"
+                    )
         else:
             console.print(
                 "[dim]No headline decisions or incidents in recent history.[/dim]"
@@ -1072,7 +1156,8 @@ def tour(
                     ]
                     if useful:
                         cards.append(card)
-            cards.sort(key=lambda c: -c.score.value)
+            # Stable tie-break: lex smallest path on identical scores.
+            cards.sort(key=lambda c: (-c.score.value, c.path))
 
         if cards:
             console.print("[bold red]Top 3 risky files[/bold red]")
@@ -1113,6 +1198,7 @@ def tour(
 
 
 @app.command()
+@_propagate_failures
 def init(
     force: bool = typer.Option(
         False, "--force", "-f", help="Overwrite existing files instead of skipping."