Migrate frontend to Preact + signals; decouple fetch / render / view

api/cache.py

@@ -67,7 +67,20 @@
 # ALWAYS_SKIP. Cached manifests that observed lockfiles (or that came
 # from include_all=true scans) would no longer match a fresh scan;
 # bumping forces every repo to re-cache and drops the orphans.
-_MANIFEST_SCHEMA_VERSION = 2
+# v3: DirNode gained descendants_ext_breakdown and the manifest gained
+# top-level busyness thresholds. Pre-v3 cached manifests lack both, so
+# consumers (street view, commit-pane busyness label, scene tree color)
+# would mis-render until a fresh scan; bumping forces the re-cache.
+# v4: a latent bug in cache_load_git_history dropped each commit's authors
+# + subject when reconstructing from the git-history cache. It never bit
+# until the v3 bump invalidated the manifest blobs and forced a re-scan that
+# rebuilds commits FROM that cache — which then cached author-less manifests
+# (fireflies/header crash on commit.authors). The loader is fixed; this bump
+# discards the polluted v3 blobs so a normal load re-scans correctly.
+# v5: each CommitEntry gained same_day_total (commits sharing its date),
+# baked at wrap time so the commit pane + scene tree-color read one field
+# instead of recomputing the per-day grouping. Pre-v5 blobs lack it.
+_MANIFEST_SCHEMA_VERSION = 5
 # Composite cache version: invalidates when EITHER the manifest
 # schema OR the git-history cache shape changes. Stored as a string
 # in the cache file's `version` field; the loader's equality check
@@ -235,11 +248,26 @@ def cache_load_git_history(
         date = c.get("date")
         files = c.get("files")
         sha = c.get("sha")
+        authors = c.get("authors")
+        subject = c.get("subject")
+        # Reconstruct the FULL CommitEntry — authors + subject are part of the
+        # shape (v9/v11) and manifest consumers (fireflies iterate authors,
+        # the commit pane shows subject) break without them. Drop any commit
+        # missing/malformed on any field rather than emit a partial entry.
         if (isinstance(date, str)
                 and isinstance(files, int) and not isinstance(files, bool)
                 and isinstance(sha, str)
-                and _SHA_HEX_RE.fullmatch(sha) is not None):
-            commits.append({"date": date, "files": files, "sha": sha})
+                and _SHA_HEX_RE.fullmatch(sha) is not None
+                and isinstance(authors, list)
+                and all(isinstance(a, str) for a in authors)
+                and isinstance(subject, str)):
+            commits.append({
+                "date": date,
+                "files": files,
+                "sha": sha,
+                "authors": authors,
+                "subject": subject,
+            })
     return created, modified, commits
 
 

api/scan.py

@@ -34,8 +34,10 @@
 )
 from .media import probe_media_dims
 from .types import (
+    BusynessThresholds,
     CommitEntry,
     DirNode,
+    ExtBreakdownEntry,
     FileEntry,
     FileNode,
     GitMeta,
@@ -409,7 +411,10 @@ def _collect_git_metadata(
     tracked = _collect_tracked_set(root)
     _log(f"    {len(tracked)} tracked entries (files + dirs)")
 
-    if use_cache and head_sha:
+    # Always write the cache (only `head_sha` is required to key it) —
+    # `use_cache` gates the READ above, not the write. A skip-cache scan
+    # still refreshes the cache so the next normal run is up to date.
+    if head_sha:
         try:
             cache_save_git_history(root, head_sha, created, modified, commits)
         except OSError:
@@ -804,26 +809,27 @@ def _populate_file_metadata(
                 raise
         _log(f"    read {len(miss_paths)}/{len(miss_paths)} files")
 
-    if use_cache:
-        # Union-merge: start from the loaded cache (preserves entries
-        # for files not visited this scan, e.g. when .codecityignore flips)
-        # and overwrite with current values for everything we did visit.
-        for node in nodes:
-            entry: FileEntry = {
-                "size": node["size"],
-                "mtime": _node_mtime(node),
-                "lines": node["lines"],
-                "binary": node["binary"],
-                "ext": node["extension"],
-            }
-            if "media_width" in node and "media_height" in node:
-                entry["media_width"] = node["media_width"]
-                entry["media_height"] = node["media_height"]
-            cache_entries[node["path"]] = entry
-        try:
-            cache_save_files(abs_root, cache_entries)
-        except OSError:
-            pass
+    # Always write the file-stat cache — `use_cache` gates only the READ.
+    # On a warm scan cache_entries holds the loaded cache, so this is a
+    # union-merge (preserves entries for files not visited this scan, e.g.
+    # when .codecityignore flips); on a skip-cache scan it starts empty and
+    # records exactly the files this fresh scan visited.
+    for node in nodes:
+        entry: FileEntry = {
+            "size": node["size"],
+            "mtime": _node_mtime(node),
+            "lines": node["lines"],
+            "binary": node["binary"],
+            "ext": node["extension"],
+        }
+        if "media_width" in node and "media_height" in node:
+            entry["media_width"] = node["media_width"]
+            entry["media_height"] = node["media_height"]
+        cache_entries[node["path"]] = entry
+    try:
+        cache_save_files(abs_root, cache_entries)
+    except OSError:
+        pass
 
 
 def _iter_file_nodes(tree: DirNode) -> Iterator[FileNode]:
@@ -901,6 +907,7 @@ class _DirFrame:
         "pending_entries", "files", "subdirs",
         "descendants_count", "descendants_file_count",
         "descendants_dir_count", "descendants_size",
+        "ext_breakdown",
     )
 
     def __init__(self, abs_dir: str, rel_dir: str) -> None:
@@ -921,6 +928,9 @@ def __init__(self, abs_dir: str, rel_dir: str) -> None:
         self.descendants_file_count = 0
         self.descendants_dir_count = 0
         self.descendants_size = 0
+        # ext (lowercase, "(none)" if absent) -> [count, total_size], over
+        # all descendant files. Merged up from child frames as they pop.
+        self.ext_breakdown: dict[str, list[int]] = {}
 
 
 def _build_tree(
@@ -971,6 +981,13 @@ def _build_tree(
                 top.descendants_count += 1
                 top.descendants_file_count += 1
                 top.descendants_size += node["size"]
+                ext = (node["extension"] or "(none)").lower()
+                bucket = top.ext_breakdown.get(ext)
+                if bucket is None:
+                    top.ext_breakdown[ext] = [1, node["size"]]
+                else:
+                    bucket[0] += 1
+                    bucket[1] += node["size"]
                 heartbeat.tick()
             elif entry.is_dir(follow_symlinks=False):
                 # Descend by pushing a new frame; rollup happens when it
@@ -982,6 +999,13 @@ def _build_tree(
         # (root) or attach to the parent.
         finished = stack.pop()
         children: list[FileNode | DirNode] = [*finished.files, *finished.subdirs]
+        # Sort by count desc, then ext asc for deterministic output.
+        ext_breakdown_out: list[ExtBreakdownEntry] = [
+            {"ext": ext, "count": cnt, "size": size}
+            for ext, (cnt, size) in sorted(
+                finished.ext_breakdown.items(), key=lambda kv: (-kv[1][0], kv[0])
+            )
+        ]
         node_out: DirNode = {
             "name": finished.name,
             "type": NodeKind.DIRECTORY,
@@ -994,6 +1018,7 @@ def _build_tree(
             "descendants_file_count": finished.descendants_file_count,
             "descendants_dir_count": finished.descendants_dir_count,
             "descendants_size": finished.descendants_size,
+            "descendants_ext_breakdown": ext_breakdown_out,
             "children": children,
         }
         if not stack:
@@ -1004,6 +1029,14 @@ def _build_tree(
         parent.descendants_file_count += node_out["descendants_file_count"]
         parent.descendants_dir_count += 1 + node_out["descendants_dir_count"]
         parent.descendants_size += node_out["descendants_size"]
+        # Merge the child's per-extension breakdown up into the parent.
+        for ext, (cnt, size) in finished.ext_breakdown.items():
+            bucket = parent.ext_breakdown.get(ext)
+            if bucket is None:
+                parent.ext_breakdown[ext] = [cnt, size]
+            else:
+                bucket[0] += cnt
+                bucket[1] += size
 
 
 # ── Public entry ─────────────────────────────────────────────────────────────
@@ -1038,6 +1071,27 @@ def _walk(node: dict) -> None:
     return h.hexdigest()
 
 
+def _compute_busyness(commits: list[CommitEntry]) -> BusynessThresholds:
+    """Repo-relative per-day commit-count thresholds. avg = median commits/day
+    (over days with >= 1 commit); busy = 75th percentile, clamped to avg+1 so
+    the three bands stay distinct. Both the scene tree-color gradient and the
+    commit pane's label read these, so a busy day looks consistent in both.
+    Returns {avg:1, busy:1} for an empty history so consumers needn't guard."""
+    if not commits:
+        return {"avg": 1, "busy": 1}
+    per_day: dict[str, int] = {}
+    for c in commits:
+        per_day[c["date"]] = per_day.get(c["date"], 0) + 1
+    counts = sorted(per_day.values())
+
+    def _quantile(p: float) -> int:
+        return counts[min(len(counts) - 1, int(len(counts) * p))]
+
+    avg = _quantile(0.5)
+    busy = max(_quantile(0.75), avg + 1)
+    return {"avg": avg, "busy": busy}
+
+
 def _wrap_manifest(
     root_abs: str, tree: DirNode, sig: Any, tree_signature: str,
     repo_info: RepoInfo, commits: list[CommitEntry],
@@ -1048,6 +1102,7 @@ def _wrap_manifest(
     has placeholder lines/binary set by _force_skeleton_placeholders;
     final has the real per-file metadata). The envelope shape is the
     same either way."""
+    _annotate_same_day_totals(commits)
     return {
         "root": root_abs,
         "scanned_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
@@ -1056,9 +1111,22 @@ def _wrap_manifest(
         "tree": tree,
         "repo": repo_info,
         "commits": commits,
+        "busyness": _compute_busyness(commits),
     }
 
 
+def _annotate_same_day_totals(commits: list[CommitEntry]) -> None:
+    """In-place: set each commit's same_day_total to the number of commits
+    sharing its calendar date. A derived aggregate (like busyness), so it's
+    baked at wrap time rather than during git collection — both the commit
+    pane's badge and the scene tree-color read this one field (#35)."""
+    per_day: dict[str, int] = {}
+    for c in commits:
+        per_day[c["date"]] = per_day.get(c["date"], 0) + 1
+    for c in commits:
+        c["same_day_total"] = per_day[c["date"]]
+
+
 def _force_skeleton_placeholders(node: DirNode | FileNode) -> None:
     """In-place: set every FileNode under `node` to lines=1, binary=False
     so the skeleton renders with uniform-height buildings."""

api/server.py

@@ -748,13 +748,15 @@ def _run_scan() -> None:
     try:
         _stream_events(handler, _events(), cancel_event)
 
-        # Only cache on successful completion AND only when use_cache.
+        # Always write the cache on a successful scan — `use_cache` only
+        # controls whether we READ from it. A skip-cache (no_cache) scan still
+        # persists its fresh result, so the next normal load is served the
+        # up-to-date manifest instead of a stale one.
         final_manifest = state["final_manifest"]
         scan_target = state["scan_target"]
         sig = state["sig"]
         if (
-            use_cache
-            and final_manifest is not None
+            final_manifest is not None
             and scan_target is not None
             and sig is not None
         ):

api/tests/test_cache.py

@@ -119,6 +119,37 @@ def test_hit_on_matching_head(self) -> None:
         result = cache_mod.cache_load_git_history(root, "abc123")
         self.assertEqual(result, (created, modified, []))
 
+    def test_round_trips_full_commit_entries(self) -> None:
+        # The loader must reconstruct the WHOLE CommitEntry — authors +
+        # subject included. A previous bug dropped them, so commits loaded
+        # from a warm cache had no `authors`, crashing the fireflies
+        # consumer (`for author of c.authors`). Round-trip a populated commit.
+        root = Path("/some/repo")
+        commits = [
+            {
+                "date": "2024-01-01",
+                "files": 3,
+                "sha": "a" * 40,
+                "authors": ["Alice", "Bob"],
+                "subject": "Initial commit",
+            },
+            {
+                "date": "2024-01-02",
+                "files": 1,
+                "sha": "b" * 40,
+                "authors": [],
+                "subject": "Empty-authors edge case",
+            },
+        ]
+        cache_mod.cache_save_git_history(root, "head1", {}, {}, commits)
+        result = cache_mod.cache_load_git_history(root, "head1")
+        assert result is not None
+        _, _, loaded = result
+        self.assertEqual(loaded, commits)
+        # Every loaded commit carries an iterable authors list.
+        for c in loaded:
+            self.assertIsInstance(c["authors"], list)
+
     def test_miss_on_different_head(self) -> None:
         root = Path("/some/repo")
         cache_mod.cache_save_git_history(root, "abc123", {}, {}, [])
@@ -178,8 +209,10 @@ def test_git_history_cache_round_trips_commits(self):
         """Round-trip a small commits list through the cache."""
         root = Path("/some/repo")
         commits: list[CommitEntry] = [
-            {"date": "2024-01-01", "files": 3, "sha": "a" * 40},
-            {"date": "2024-02-15", "files": 7, "sha": "b" * 40},
+            {"date": "2024-01-01", "files": 3, "sha": "a" * 40,
+             "authors": ["Alice"], "subject": "first"},
+            {"date": "2024-02-15", "files": 7, "sha": "b" * 40,
+             "authors": ["Bob", "Carol"], "subject": "second"},
         ]
         cache_mod.cache_save_git_history(
             root, head_sha="abc",
@@ -208,26 +241,41 @@ def test_git_history_cache_drops_malformed_commits(self):
             "created": {},
             "modified": {},
             "commits": [
-                {"date": "2024-01-01", "files": 3, "sha": sha_a},   # valid
+                {"date": "2024-01-01", "files": 3, "sha": sha_a,
+                 "authors": ["Alice"], "subject": "ok"},              # valid
                 "not a dict",                                         # dropped: not a dict
-                {"date": 12345, "files": 5, "sha": sha_a},           # dropped: date not str
-                {"date": "2024-02-01", "sha": sha_a},                # dropped: missing files
-                {"date": "2024-03-01", "files": True, "sha": sha_a}, # dropped: files is bool
-                {"files": 4, "sha": sha_a},                          # dropped: missing date
-                {"date": "2024-04-01", "files": 7},                  # dropped: missing sha
-                {"date": "2024-05-01", "files": 2, "sha": "short"},  # dropped: sha too short
-                {"date": "2024-05-15", "files": 4, "sha": "Z" * 40}, # sha contains non-hex characters
-                {"date": "2024-06-01", "files": 1, "sha": sha_b},    # valid
+                {"date": 12345, "files": 5, "sha": sha_a,
+                 "authors": [], "subject": "x"},                      # dropped: date not str
+                {"date": "2024-02-01", "sha": sha_a,
+                 "authors": [], "subject": "x"},                      # dropped: missing files
+                {"date": "2024-03-01", "files": True, "sha": sha_a,
+                 "authors": [], "subject": "x"},                      # dropped: files is bool
+                {"files": 4, "sha": sha_a,
+                 "authors": [], "subject": "x"},                      # dropped: missing date
+                {"date": "2024-04-01", "files": 7,
+                 "authors": [], "subject": "x"},                      # dropped: missing sha
+                {"date": "2024-05-01", "files": 2, "sha": "short",
+                 "authors": [], "subject": "x"},                      # dropped: sha too short
+                {"date": "2024-05-15", "files": 4, "sha": "Z" * 40,
+                 "authors": [], "subject": "x"},                      # dropped: non-hex sha
+                {"date": "2024-07-01", "files": 1, "sha": sha_a,
+                 "authors": "Alice", "subject": "x"},                 # dropped: authors not a list
+                {"date": "2024-08-01", "files": 1, "sha": sha_a,
+                 "authors": ["Alice"]},                               # dropped: missing subject
+                {"date": "2024-06-01", "files": 1, "sha": sha_b,
+                 "authors": ["Bob"], "subject": "ok2"},               # valid
             ],
         }), encoding="utf-8")
         loaded = cache_mod.cache_load_git_history(root, "abc")
         self.assertIsNotNone(loaded)
         assert loaded is not None
         _created, _modified, commits = loaded
-        # Only the two well-formed entries survive.
+        # Only the two well-formed entries survive (with authors + subject).
         self.assertEqual(commits, [
-            {"date": "2024-01-01", "files": 3, "sha": sha_a},
-            {"date": "2024-06-01", "files": 1, "sha": sha_b},
+            {"date": "2024-01-01", "files": 3, "sha": sha_a,
+             "authors": ["Alice"], "subject": "ok"},
+            {"date": "2024-06-01", "files": 1, "sha": sha_b,
+             "authors": ["Bob"], "subject": "ok2"},
         ])
 
     def test_git_history_rejects_old_version(self):