cctally 1.8.0 → 1.8.2

package/bin/cctally

@@ -80,6 +80,7 @@ import textwrap
 import threading
 import time
 import traceback
+import unicodedata
 import urllib.error
 import urllib.request
 from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
@@ -358,6 +359,19 @@ TrendView = _lib_view_models.TrendView
 build_trend_view = _lib_view_models.build_trend_view
 SessionsView = _lib_view_models.SessionsView
 build_sessions_view = _lib_view_models.build_sessions_view
+BlocksView = _lib_view_models.BlocksView
+build_blocks_view = _lib_view_models.build_blocks_view
+build_blocks_view_from_table_rows = _lib_view_models.build_blocks_view_from_table_rows
+ForecastView = _lib_view_models.ForecastView
+build_forecast_view = _lib_view_models.build_forecast_view
+CodexDailyView = _lib_view_models.CodexDailyView
+build_codex_daily_view = _lib_view_models.build_codex_daily_view
+CodexMonthlyView = _lib_view_models.CodexMonthlyView
+build_codex_monthly_view = _lib_view_models.build_codex_monthly_view
+CodexWeeklyView = _lib_view_models.CodexWeeklyView
+build_codex_weekly_view = _lib_view_models.build_codex_weekly_view
+CodexSessionView = _lib_view_models.CodexSessionView
+build_codex_session_view = _lib_view_models.build_codex_session_view
 
 _lib_render = _load_sibling("_lib_render")
 _CODEX_MONTHS = _lib_render._CODEX_MONTHS
@@ -776,6 +790,7 @@ _dashboard_build_monthly_periods = _cctally_dashboard._dashboard_build_monthly_p
 _dashboard_build_weekly_periods = _cctally_dashboard._dashboard_build_weekly_periods
 _build_block_detail = _cctally_dashboard._build_block_detail
 _dashboard_build_blocks_panel = _cctally_dashboard._dashboard_build_blocks_panel
+_dashboard_build_blocks_view = _cctally_dashboard._dashboard_build_blocks_view
 _dashboard_build_daily_panel = _cctally_dashboard._dashboard_build_daily_panel
 _empty_dashboard_snapshot = _cctally_dashboard._empty_dashboard_snapshot
 _iso_z = _cctally_dashboard._iso_z
@@ -2691,6 +2706,29 @@ def _supports_unicode_stdout() -> bool:
     return "UTF" in encoding
 
 
+def _display_width(s: str) -> int:
+    """Terminal cells consumed by ``s``.
+
+    Counts each codepoint by its East Asian Width: ``W`` / ``F`` (Wide
+    / Fullwidth) → 2 cells; combining marks → 0; everything else → 1.
+    Ambiguous (``A``) defaults to 1, matching every non-CJK terminal
+    locale — cctally has no CJK content in cell data, and `→` / `—` /
+    `·` (all `A`) are intentionally rendered narrow.
+
+    Used by `_boxed_table` so cells containing wide glyphs (notably
+    `⚡` U+26A1 on credit-row annotations) pad to the right cell count
+    rather than the right codepoint count. Without this, `len()`-based
+    padding under-pads by one cell per wide glyph and the right border
+    drifts off-column on those rows only.
+    """
+    width = 0
+    for ch in s:
+        if unicodedata.combining(ch):
+            continue
+        width += 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1
+    return width
+
+
 def _boxed_table(
     headers: list[str],
     rows: list[list[str]],
@@ -2714,15 +2752,20 @@ def _boxed_table(
 
     widths: list[int] = []
     for idx, header in enumerate(headers):
-        max_cell = max((len(r[idx]) for r in sanitized_rows), default=0)
-        widths.append(max(len(header), max_cell))
+        max_cell = max((_display_width(r[idx]) for r in sanitized_rows), default=0)
+        widths.append(max(_display_width(header), max_cell))
 
     def _pad(text: str, width: int, align: str) -> str:
+        deficit = width - _display_width(text)
+        if deficit <= 0:
+            return text
+        pad = " " * deficit
         if align == "right":
-            return text.rjust(width)
+            return pad + text
         if align == "center":
-            return text.center(width)
-        return text.ljust(width)
+            left = deficit // 2
+            return (" " * left) + text + (" " * (deficit - left))
+        return text + pad
 
     if _supports_unicode_stdout():
         chars = {
@@ -4987,13 +5030,30 @@ def cmd_blocks(args: argparse.Namespace) -> int:
         range_start - BLOCK_DURATION, range_end + BLOCK_DURATION,
     )
 
-    # Group into blocks
-    blocks = _group_entries_into_blocks(
-        all_entries, mode="auto",
+    # Group into blocks via the view-model kernel (issue #56). The
+    # heuristic-aware ``aggregated`` tuple holds the full Block list
+    # (gaps included, oldest-first) — same shape the JSON / table
+    # renderers expect. We materialize back to a list because
+    # ``_maybe_swap_active_block_to_canonical`` mutates in-place.
+    #
+    # ``skip_rows=True`` (issue #60 review fix) opts out of the
+    # dashboard-row construction inside ``build_blocks_view`` — the
+    # per-block per-model enrichment that scans every entry per
+    # non-gap block (O(B × N)). The CLI never reads ``view.rows``
+    # (only ``view.aggregated`` here), so on large all-history blocks
+    # runs we avoid quadratic-ish work we'd discard.
+    view = build_blocks_view(
+        all_entries,
+        now_utc=now_utc,
         recorded_windows=recorded_windows,
         block_start_overrides=block_start_overrides,
-        now=now_utc,
+        range_start=range_start,
+        range_end=range_end,
+        display_tz=tz,
+        mode="auto",
+        skip_rows=True,
     )
+    blocks = list(view.aggregated)
 
     # Bug E (v1.7.2 round-4): when the ACTIVE block is heuristic-anchored
     # but a canonical ``five_hour_blocks`` row exists for the current 5h
@@ -5508,7 +5568,14 @@ def cmd_codex_daily(args: argparse.Namespace) -> int:
     range_start, range_end = range
 
     entries = get_codex_entries(range_start, range_end)
-    days = _aggregate_codex_daily(entries, tz_name=tz_name)
+    # Route through ``build_codex_daily_view`` (issue #58). The View
+    # wraps ``_aggregate_codex_daily`` without changing it — preserves
+    # LiteLLM token semantics, intentional dedup vs upstream, and
+    # ``CODEX_LEGACY_FALLBACK_MODEL`` warning end-to-end.
+    view = build_codex_daily_view(
+        entries, now_utc=_command_as_of(), tz_name=tz_name,
+    )
+    days = list(view.rows)                  # asc — matches aggregator default
     if args.order == "desc":
         days = list(reversed(days))
 
@@ -5530,7 +5597,7 @@ def cmd_codex_daily(args: argparse.Namespace) -> int:
         y, m, d = bucket.split("-")
         return f"{_CODEX_MONTHS[int(m) - 1]} {int(d):02d},\n{y}"
 
-    tz_label = tz_name or _local_tz_name()
+    tz_label = view.display_tz_label
     title = f"Codex Token Usage Report - Daily (Timezone: {tz_label})"
     print(_render_codex_bucket_table(
         days,
@@ -5560,7 +5627,11 @@ def cmd_codex_monthly(args: argparse.Namespace) -> int:
     range_start, range_end = range
 
     entries = get_codex_entries(range_start, range_end)
-    months = _aggregate_codex_monthly(entries, tz_name=tz_name)
+    # Route through ``build_codex_monthly_view`` (issue #58).
+    view = build_codex_monthly_view(
+        entries, now_utc=_command_as_of(), tz_name=tz_name,
+    )
+    months = list(view.rows)
     if args.order == "desc":
         months = list(reversed(months))
 
@@ -5582,7 +5653,7 @@ def cmd_codex_monthly(args: argparse.Namespace) -> int:
         y, m = bucket.split("-")
         return f"{_CODEX_MONTHS[int(m) - 1]}\n{y}"
 
-    tz_label = tz_name or _local_tz_name()
+    tz_label = view.display_tz_label
     title = f"Codex Token Usage Report - Monthly (Timezone: {tz_label})"
     print(_render_codex_bucket_table(
         months,
@@ -5615,7 +5686,12 @@ def cmd_codex_weekly(args: argparse.Namespace) -> int:
     week_start_idx = WEEKDAY_MAP[week_start_name]
 
     entries = get_codex_entries(range_start, range_end)
-    weeks = _aggregate_codex_weekly(entries, tz_name, week_start_idx)
+    # Route through ``build_codex_weekly_view`` (issue #58).
+    view = build_codex_weekly_view(
+        entries, now_utc=now_utc, tz_name=tz_name,
+        week_start_idx=week_start_idx,
+    )
+    weeks = list(view.rows)
     if args.order == "desc":
         weeks = list(reversed(weeks))
 
@@ -5640,7 +5716,7 @@ def cmd_codex_weekly(args: argparse.Namespace) -> int:
         y, m, d = bucket.split("-")
         return f"{_CODEX_MONTHS[int(m) - 1]} {int(d):02d},\n{y}"
 
-    tz_label = tz_name or _local_tz_name()
+    tz_label = view.display_tz_label
     title = f"Codex Token Usage Report - Weekly (Timezone: {tz_label})"
     print(_render_codex_bucket_table(
         weeks,
@@ -5670,8 +5746,13 @@ def cmd_codex_session(args: argparse.Namespace) -> int:
     range_start, range_end = range
 
     entries = get_codex_entries(range_start, range_end)
-    sessions = _aggregate_codex_sessions(entries)
-    # Aggregator returns descending by last_activity; --order asc reverses.
+    # Route through ``build_codex_session_view`` (issue #58). View rows
+    # come descending by last_activity (aggregator default + upstream
+    # parity); --order asc reverses.
+    view = build_codex_session_view(
+        entries, now_utc=_command_as_of(), tz_name=tz_name,
+    )
+    sessions = list(view.rows)
     if args.order == "asc":
         sessions = list(reversed(sessions))
 
@@ -5685,7 +5766,7 @@ def cmd_codex_session(args: argparse.Namespace) -> int:
         print(_codex_sessions_to_json(sessions))
         return 0
 
-    tz_label = tz_name or _local_tz_name()
+    tz_label = view.display_tz_label
     # Upstream uses "Sessions" (plural) in the session banner title.
     title = f"Codex Token Usage Report - Sessions (Timezone: {tz_label})"
     print(_render_codex_session_table(
@@ -8241,7 +8322,16 @@ def cmd_forecast(args: argparse.Namespace) -> int:
     # sync_cache(conn) here — that prior call ran on the stats DB connection
     # (wrong conn) and was a no-op for the real cache anyway.
 
-    inputs = _load_forecast_inputs(conn, now_utc, skip_sync=args.no_sync)
+    # Route through ``build_forecast_view`` (issue #57). The View is the
+    # kernel-pattern wrapper; ``view.output`` carries the existing
+    # ``ForecastOutput`` math result so every downstream renderer here
+    # (text / JSON / status-line / share) reuses the same projection,
+    # verdict, budgets, and per-method rate fields without recomputing.
+    view = build_forecast_view(
+        conn, now_utc=now_utc, targets=tuple(targets),
+        skip_sync=args.no_sync, display_tz=args._resolved_tz,
+    )
+    inputs = view.output.inputs if view.output is not None else None
     if inputs is None:
         # No snapshot for the current week.
         if getattr(args, "format", None):
@@ -8307,12 +8397,12 @@ def cmd_forecast(args: argparse.Namespace) -> int:
             print("forecast: no data for current week yet")
         return 0
 
-    output = _compute_forecast(inputs, targets)
+    output = view.output
 
     # Shareable-reports gate: --format short-circuits the JSON / status-line /
     # terminal dispatch via `_share_render_and_emit`. The mutex in
     # `_add_share_args(has_status_line=True)` keeps `--format`, `--json`, and
-    # `--status-line` from coexisting. The gate fires AFTER `_compute_forecast`
+    # `--status-line` from coexisting. The gate fires AFTER ``build_forecast_view``
     # so the snapshot reuses the same projection math as the terminal/JSON
     # paths — no parallel computation.
     if getattr(args, "format", None):
@@ -8857,10 +8947,21 @@ def cmd_five_hour_blocks(args: argparse.Namespace) -> int:
                 )
             else:
                 period_end = _share_now_utc()
-            snap = _build_five_hour_blocks_snapshot(
+            # Build a BlocksView from the API-anchored table rows
+            # (issue #56). Reset-aware totals come from the table's
+            # per-block columns (CLAUDE.md 5-hour gotcha block) so the
+            # share snapshot's footer reads from the single typed
+            # source rather than re-summing inline.
+            view = build_blocks_view_from_table_rows(
                 block_dicts,
                 period_start=period_start,
                 period_end=period_end,
+                display_tz=args._resolved_tz,
+            )
+            snap = _build_five_hour_blocks_snapshot(
+                view,
+                period_start=period_start,
+                period_end=period_end,
                 display_tz=display_tz_str,
                 version=_share_resolve_version(),
                 theme=args.theme,
@@ -13182,7 +13283,7 @@ def _build_project_snapshot(
 
 
 def _build_five_hour_blocks_snapshot(
-    rows: list[dict],
+    view: "BlocksView",
     *,
     period_start: dt.datetime,
     period_end: dt.datetime,
@@ -13194,13 +13295,18 @@ def _build_five_hour_blocks_snapshot(
 ) -> "ShareSnapshot":
     """Build a ShareSnapshot for `cctally five-hour-blocks`.
 
-    `rows` is the list of per-block dicts produced inside
-    `cmd_five_hour_blocks` (sqlite Row converted to dict, with the
-    `__is_active` side-channel attached). Schema fields used:
-    `block_start_at` (ISO timestamp), `total_cost_usd`,
-    `final_five_hour_percent`, `crossed_seven_day_reset` (0/1 int),
-    `seven_day_pct_at_block_start`, `seven_day_pct_at_block_end`, plus
-    the synthetic `__is_active` flag.
+    `view` is the ``BlocksView`` produced by
+    ``build_blocks_view_from_table_rows`` (issue #56). The
+    API-anchored block dicts (sqlite Row → dict with the
+    ``__is_active`` / ``__credits`` side-channels attached) live on
+    ``view.aggregated``; reset-aware totals come from
+    ``view.total_cost_usd`` so the share footer reads from the typed
+    single source rather than re-summing inline. Schema fields used
+    from each dict: ``block_start_at`` (ISO timestamp),
+    ``total_cost_usd``, ``final_five_hour_percent``,
+    ``crossed_seven_day_reset`` (0/1 int),
+    ``seven_day_pct_at_block_start``, ``seven_day_pct_at_block_end``,
+    plus the synthetic ``__is_active`` flag.
 
     Deviations from the plan sketch (which assumed dict rows with keys
     `block_start` / `cost_usd` / `used_pct_5h` / `top_model` /
@@ -13232,11 +13338,12 @@ def _build_five_hour_blocks_snapshot(
     the builder owns the canonical subtitle shape — no post-build
     re-stamp at the gate site.
 
-    Caller MUST pass `rows` already in the desired chronological order
-    (cmd_five_hour_blocks pulls newest-first; we reverse here so the
-    BarChart bars line up oldest→newest left-to-right). Tabular row
-    order in the snapshot is irrelevant because the snapshot is what
-    gets rendered (the gate site short-circuits the table renderer).
+    Caller MUST pass a view whose ``aggregated`` block dicts are
+    already in the desired chronological order (cmd_five_hour_blocks
+    pulls newest-first; we reverse here so the BarChart bars line up
+    oldest→newest left-to-right). Tabular row order in the snapshot is
+    irrelevant because the snapshot is what gets rendered (the gate
+    site short-circuits the table renderer).
     """
     _lib_share = _share_load_lib()
     columns = (
@@ -13249,9 +13356,11 @@ def _build_five_hour_blocks_snapshot(
         _lib_share.ColumnSpec(key="cross_reset", label="Reset",
                               align="left"),
     )
-    # Reverse so BarChart x-axis runs oldest→newest (cmd_five_hour_blocks
-    # produces newest-first DESC); table-row order in the snapshot tracks
-    # chart order so consumer expectations align.
+    # `view.aggregated` carries the newest-first DESC block dicts the
+    # caller built from the SELECT. Reverse so BarChart x-axis runs
+    # oldest→newest; table-row order tracks chart order so consumer
+    # expectations align.
+    rows = list(view.aggregated)
     chrono_rows = list(reversed(rows))
     snap_rows: list = []
     chart_pts: list = []
@@ -13307,7 +13416,11 @@ def _build_five_hour_blocks_snapshot(
         _lib_share.BarChart(points=tuple(chart_pts), y_label="$")
         if chart_pts else None
     )
-    sum_cost = sum(p.y_value for p in chart_pts)
+    # Reset-aware total comes from the BlocksView (issue #56); avg
+    # divides by `chart_pts` count so the share footer "Sum" totalled
+    # and the per-block `chart_pts` cost values share a single source-
+    # of-truth at `view.total_cost_usd`.
+    sum_cost = view.total_cost_usd
     avg_cost = (sum_cost / len(chart_pts)) if chart_pts else 0.0
     crossed_count = sum(
         1 for r in chrono_rows if bool(r.get("crossed_seven_day_reset"))