agitrack 0.2.2__tar.gz → 0.2.4__tar.gz

{agitrack-0.2.2 → agitrack-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agitrack
-Version: 0.2.2
+Version: 0.2.4
 Summary: Interactive coding-agent CLI that commits AI changes to git with traceable metadata.
 Author: aGiTrack contributors
 License: Apache-2.0
@@ -283,7 +283,7 @@ agitrack -d text            # one-shot plain-text report instead (pipe it, paste
 
 - **aGiTrack-tracked AI vs non-tracked lines** — what the agents wrote (tracked by aGiTrack) versus everything else; it never claims a human wrote what the model did.
 - **Filter live** — narrow the whole dashboard to one committer (merged to their GitHub ID), a backend, a model, or a time range.
-- **Tokens, efficiency, and loop detection**, plus a commit log you can click to read the full message and jump to the commit on GitHub.
+- **Tokens, efficiency, and loop detection**, plus a commit log you can click to read the full message and show each commit's **file diff right in the page** (served from your local clone — no GitHub needed).
 
 See [Repository dashboard](#repository-dashboard) below for the full breakdown.
 
@@ -428,7 +428,7 @@ The [Dashboard](#dashboard) section above covers how to run it (`-d`, and `-d te
 - **Breakdowns** by backend, by model (a cover commit's bucket includes the lines of the backend-made commits it covers), and by committer. Committer identities are merged to **GitHub IDs** via the `gh` CLI when available (every commit GitHub knows is keyed by its real login); without `gh` it falls back to merging by email and no-reply login. Each committer's lines are split into the aGiTrack-tracked AI they drove versus non-tracked.
 - **Possible loops**: runs of three or more consecutive turns with near-identical prompts (or the same prompt repeated within one turn's trace), with the output tokens they consumed — a sign the conversation is going in circles.
 
-The web page (styled like the [project page](https://github.com/core-aix/agitrack/tree/main/docs)) lets you **filter live** — narrow the whole dashboard to one committer or view the entire team, slice by backend or model, or restrict to a **time range** (presets or a custom from/to). The server recomputes the metrics for each filter, and the **commit log is paginated** (fetched a page at a time), so the browser never holds the whole history — memory stays bounded no matter how big the repo is. Each log line shows per-line token metrics; clicking a line opens the full commit message **rendered as Markdown** with a link to the commit on GitHub, and a squash expands into its original commits (each itself expandable). Agent commits also record when the AI-driven conversation started and ended (`agent_started_at` / `agent_ended_at` in the metadata block).
+The web page (styled like the [project page](https://github.com/core-aix/agitrack/tree/main/docs)) lets you **filter live** — narrow the whole dashboard to one committer or view the entire team, slice by backend or model, or restrict to a **time range** (presets or a custom from/to). The server recomputes the metrics for each filter, and the **commit log is paginated** (fetched a page at a time), so the browser never holds the whole history — memory stays bounded no matter how big the repo is. Each log line shows per-line token metrics; clicking a line opens the full commit message **rendered as Markdown** and a **"show file diff"** button that renders that commit's diff inline — computed from your **local clone**, so the whole dashboard works with no GitHub (a "view on GitHub" link is offered only when a remote is configured). Merge/cover commits show their first-parent diff (the AI work they account for). A squash expands into its original commits (each itself expandable). Agent commits also record when the AI-driven conversation started and ended (`agent_started_at` / `agent_ended_at` in the metadata block).
 
 The dashboard is read-only in either form (served or `-d text`): it never commits, never prompts, and skips the privacy acknowledgment.
 

{agitrack-0.2.2 → agitrack-0.2.4}/README.md

@@ -266,7 +266,7 @@ agitrack -d text            # one-shot plain-text report instead (pipe it, paste
 
 - **aGiTrack-tracked AI vs non-tracked lines** — what the agents wrote (tracked by aGiTrack) versus everything else; it never claims a human wrote what the model did.
 - **Filter live** — narrow the whole dashboard to one committer (merged to their GitHub ID), a backend, a model, or a time range.
-- **Tokens, efficiency, and loop detection**, plus a commit log you can click to read the full message and jump to the commit on GitHub.
+- **Tokens, efficiency, and loop detection**, plus a commit log you can click to read the full message and show each commit's **file diff right in the page** (served from your local clone — no GitHub needed).
 
 See [Repository dashboard](#repository-dashboard) below for the full breakdown.
 
@@ -411,7 +411,7 @@ The [Dashboard](#dashboard) section above covers how to run it (`-d`, and `-d te
 - **Breakdowns** by backend, by model (a cover commit's bucket includes the lines of the backend-made commits it covers), and by committer. Committer identities are merged to **GitHub IDs** via the `gh` CLI when available (every commit GitHub knows is keyed by its real login); without `gh` it falls back to merging by email and no-reply login. Each committer's lines are split into the aGiTrack-tracked AI they drove versus non-tracked.
 - **Possible loops**: runs of three or more consecutive turns with near-identical prompts (or the same prompt repeated within one turn's trace), with the output tokens they consumed — a sign the conversation is going in circles.
 
-The web page (styled like the [project page](https://github.com/core-aix/agitrack/tree/main/docs)) lets you **filter live** — narrow the whole dashboard to one committer or view the entire team, slice by backend or model, or restrict to a **time range** (presets or a custom from/to). The server recomputes the metrics for each filter, and the **commit log is paginated** (fetched a page at a time), so the browser never holds the whole history — memory stays bounded no matter how big the repo is. Each log line shows per-line token metrics; clicking a line opens the full commit message **rendered as Markdown** with a link to the commit on GitHub, and a squash expands into its original commits (each itself expandable). Agent commits also record when the AI-driven conversation started and ended (`agent_started_at` / `agent_ended_at` in the metadata block).
+The web page (styled like the [project page](https://github.com/core-aix/agitrack/tree/main/docs)) lets you **filter live** — narrow the whole dashboard to one committer or view the entire team, slice by backend or model, or restrict to a **time range** (presets or a custom from/to). The server recomputes the metrics for each filter, and the **commit log is paginated** (fetched a page at a time), so the browser never holds the whole history — memory stays bounded no matter how big the repo is. Each log line shows per-line token metrics; clicking a line opens the full commit message **rendered as Markdown** and a **"show file diff"** button that renders that commit's diff inline — computed from your **local clone**, so the whole dashboard works with no GitHub (a "view on GitHub" link is offered only when a remote is configured). Merge/cover commits show their first-parent diff (the AI work they account for). A squash expands into its original commits (each itself expandable). Agent commits also record when the AI-driven conversation started and ended (`agent_started_at` / `agent_ended_at` in the metadata block).
 
 The dashboard is read-only in either form (served or `-d text`): it never commits, never prompts, and skips the privacy acknowledgment.
 

{agitrack-0.2.2 → agitrack-0.2.4}/agitrack/commits/message.py

@@ -276,6 +276,18 @@ def _insert_before_version_line(lines: list[str], extra: list[str]) -> list[str]
     return lines + list(extra)
 
 
+def _trace_role_lines(item: dict) -> list[str]:
+    """The rendered lines for one trace turn — its "## User"/"## Agent" role heading plus the
+    masked, heading-nested body — or an EMPTY list when the entry has no textual content. A
+    blank/whitespace entry (e.g. a garbled or empty proxy capture of a follow-up typed while the
+    agent was busy) must never produce a bare "## User" heading with nothing under it."""
+    content = _nest_headings_under_role(_mask_secrets(item.get("content", "")))
+    if not content.strip():
+        return []
+    label = "User" if item.get("role", "").strip().lower() == "user" else "Agent"
+    return [f"## {label}", "", *_body_lines(content), ""]
+
+
 def render_interaction_trace(trace: list[dict], trace_turn_limit: int) -> str:
     """The interaction-trace body exactly as it is appended to an aGiTrack commit:
     role headings plus masked, heading-nested content (same as the commit's
@@ -284,10 +296,7 @@ def render_interaction_trace(trace: list[dict], trace_turn_limit: int) -> str:
     nothing else — no diff, no out-of-band context."""
     lines: list[str] = []
     for item in _limit_trace_turns(trace, trace_turn_limit):
-        role = item.get("role", "").strip().lower()
-        content = _nest_headings_under_role(_mask_secrets(item.get("content", "")))
-        label = "User" if role == "user" else "Agent"
-        lines.extend([f"## {label}", "", *_body_lines(content), ""])
+        lines.extend(_trace_role_lines(item))
     return "\n".join(lines).strip()
 
 
@@ -316,12 +325,9 @@ def _trace_and_metadata_lines(
     # itself shows when the context — and the token counts riding on it — changed.
     lines.extend(_session_event_note_lines(compactions=compactions, origin_event=origin_event))
     for item in _limit_trace_turns(trace, trace_turn_limit):
-        role = item.get("role", "").strip().lower()
-        # Nest the message's own headings under the "## User"/"## Agent" heading so
-        # a message's "# Title" can't outrank the role it belongs to in the log.
-        content = _nest_headings_under_role(_mask_secrets(item.get("content", "")))
-        label = "User" if role == "user" else "Agent"
-        lines.extend([f"## {label}", "", *_body_lines(content), ""])
+        # Nest each message's own headings under its "## User"/"## Agent" role heading (so a
+        # message's "# Title" can't outrank the role) and skip empty entries (see _trace_role_lines).
+        lines.extend(_trace_role_lines(item))
 
     lines.extend(
         [

{agitrack-0.2.2 → agitrack-0.2.4}/agitrack/config/state.py

@@ -10,6 +10,10 @@ from typing import Any
 
 from agitrack.proc import console_isolation_kwargs
 
+# The git-resolved .git/info/exclude path per repo root — invariant for a run, so resolve it once
+# (see AgitrackState._exclude_path) instead of spawning `git rev-parse` on every save/ensure.
+_EXCLUDE_PATH_CACHE: dict[Path, Path] = {}
+
 
 class AgitrackState:
     def __init__(self, repo: Path, *, default_backend: str | None = None) -> None:
@@ -144,6 +148,21 @@ class AgitrackState:
             handle.write(".agitrack/\n")
 
     def _exclude_path(self) -> Path | None:
+        # The info/exclude location is invariant for a repo, but ensure_local_ignore() /
+        # save() ask for it constantly (every state save, every daemon poll). Resolving it via
+        # git each time spawns a `git rev-parse` subprocess — dozens during the startup burst
+        # (a chunk of the slow start + the terminal "git" title flicker). Cache it per repo so
+        # the git call happens once; the (cheap) file read/append in _ensure_repo_local_ignore
+        # still runs each time, so an externally emptied exclude file is still re-populated.
+        cached = _EXCLUDE_PATH_CACHE.get(self.repo)
+        if cached is not None:
+            return cached
+        resolved = self._resolve_exclude_path()
+        if resolved is not None:
+            _EXCLUDE_PATH_CACHE[self.repo] = resolved
+        return resolved
+
+    def _resolve_exclude_path(self) -> Path | None:
         # Resolve the info/exclude path via git so it works inside a worktree,
         # where ``.git`` is a file pointing at the shared git dir rather than a
         # directory. Fall back to the conventional location when git is not

{agitrack-0.2.2 → agitrack-0.2.4}/agitrack/git/repo.py

@@ -292,6 +292,25 @@ class GitRepo:
     def diff_range(self, base: str, head: str) -> str:
         return self._run(["git", "diff", f"{base}..{head}"], check=False).stdout
 
+    def show_commit(self, ref: str, *, max_bytes: int = 400_000) -> tuple[str, bool]:
+        """The file diffs a commit introduced — a diffstat followed by the unified patch —
+        for the dashboard's local diff view (so the dashboard is fully usable off GitHub).
+
+        ``--first-parent`` makes a merge or cover commit show its change against the mainline
+        parent (the AI work a cover commit accounts for) instead of the near-empty combined
+        diff; it's a no-op for ordinary single-parent commits, and a root commit shows as
+        all-additions. All local: it reads blobs already in the clone, never the network.
+
+        Returns ``(patch, truncated)`` — the patch is capped at ``max_bytes`` so one enormous
+        commit can't produce an unbounded response; ``truncated`` is True when it was cut."""
+        out = self._run(
+            ["git", "show", "--no-color", "--first-parent", "--format=", "--stat", "--patch", ref],
+            check=False,
+        ).stdout
+        if len(out) > max_bytes:
+            return out[:max_bytes], True
+        return out, False
+
     # --- branches / worktrees / merges (used by concurrent-session support) ---
 
     def current_branch(self) -> str:

{agitrack-0.2.2 → agitrack-0.2.4}/agitrack/metrics/collect.py

@@ -557,7 +557,7 @@ def collect_commit_stats(repo: GitRepo, ref: str = "HEAD") -> list[CommitStat]:
         committed_at, _, body = rest.partition(_FIELD_SEP)
         stats.append(_parse_commit(sha.strip(), author, email, committed_at.strip(), body))
 
-    stats = _drop_inherited_metadata(repo, ref, stats)
+    _neutralize_inherited_metadata(repo, ref, stats)
 
     _apply_numstat(repo, ref, {stat.sha: stat for stat in stats})
 
@@ -636,8 +636,8 @@ def _dedupe_squash_constituents(stats: list[CommitStat]) -> None:
             stat.tokens = _sum_tokens(kept)
 
 
-def _drop_inherited_metadata(repo: GitRepo, ref: str, stats: list[CommitStat]) -> list[CommitStat]:
-    """Drop commits that merely inherit a parent's aGiTrack metadata block.
+def _neutralize_inherited_metadata(repo: GitRepo, ref: str, stats: list[CommitStat]) -> None:
+    """Strip the aGiTrack metadata from commits that merely inherit a parent's block.
 
     When a session branch is integrated with a real merge commit (e.g. a GitHub
     PR merged with "Create a merge commit"), GitHub copies the PR title and body
@@ -648,24 +648,48 @@ def _drop_inherited_metadata(repo: GitRepo, ref: str, stats: list[CommitStat]) -
 
     The fingerprint is a *merge* commit (>1 parent) that shares an identical
     metadata block with one of its parents: that parent is the cover commit it
-    merges, and the block was copied wholesale. We keep the original (the parent)
-    and discard the inheriting merge. Restricting to merges is what separates this
-    from a genuine run of repeated turns, which is linear — each such commit has a
-    single parent, so an identical neighbouring block is a real (repeated) turn,
-    not a copy. Cover commits and integration merges are themselves merge-shaped
-    but never share a parent's block, so they are untouched."""
+    merges, and the block was copied wholesale. Rather than drop the merge (which
+    would make the dashboard show fewer commits than GitHub does), we keep it in
+    the log but wipe the inherited metadata in place — tokens, covered_commits,
+    trace, backend/model — and reclassify it as the plain merge it really is, so
+    the turn's figures are still counted only once (on the cover parent).
+    Restricting to merges is what separates this from a genuine run of repeated
+    turns, which is linear — each such commit has a single parent, so an identical
+    neighbouring block is a real (repeated) turn, not a copy. Cover commits and
+    integration merges are themselves merge-shaped but never share a parent's
+    block, so they are untouched."""
     block_by_sha = {stat.sha: stat.metadata_block for stat in stats if stat.metadata_block}
     if not block_by_sha:
-        return stats
+        return
     parents = _parents(repo, ref)
-    duplicates = {
-        stat.sha
-        for stat in stats
-        if stat.metadata_block
-        and len(parents.get(stat.sha, ())) > 1
-        and any(block_by_sha.get(parent) == stat.metadata_block for parent in parents[stat.sha])
-    }
-    return [stat for stat in stats if stat.sha not in duplicates]
+    for stat in stats:
+        inherited = (
+            stat.metadata_block
+            and len(parents.get(stat.sha, ())) > 1
+            and any(block_by_sha.get(parent) == stat.metadata_block for parent in parents[stat.sha])
+        )
+        if not inherited:
+            continue
+        # Keep the commit (so the count matches GitHub) but scrub every field that
+        # the copied block populated, so nothing about this turn is counted twice.
+        stat.kind = _neutralized_merge_kind(stat.subject)
+        stat.tokens = {}
+        stat.covered_commits = []
+        stat.constituents = []
+        stat.started_at = stat.ended_at = ""
+        stat.backend = stat.model = None
+        stat.prompt = ""
+        stat.user_prompts = []
+        stat.metadata_block = ""
+
+
+def _neutralized_merge_kind(subject: str) -> str:
+    """The kind a merge should carry once its inherited aGiTrack metadata is stripped:
+    aGiTrack's own integration plumbing if it names a session branch, else untracked —
+    mirroring the metadata-less classification in :func:`_parse_commit`."""
+    if subject.startswith("Merge ") and _AGITRACK_BRANCH_RE.search(subject):
+        return "agitrack-ops"
+    return "untracked"
 
 
 def _parents(repo: GitRepo, ref: str) -> dict[str, list[str]]:

{agitrack-0.2.2 → agitrack-0.2.4}/agitrack/metrics/server.py

@@ -20,7 +20,7 @@ from typing import Any
 from agitrack.git import GitRepo
 from agitrack.metrics.collect import Dashboard, build_dashboard
 from agitrack.metrics.github import cached_logins
-from agitrack.metrics.web import aggregates_payload, log_page, shared_sessions_for, shell_html
+from agitrack.metrics.web import aggregates_payload, commit_diff, log_page, shared_sessions_for, shell_html
 
 DEFAULT_HOST = "127.0.0.1"
 DEFAULT_PORT = 8765
@@ -83,6 +83,10 @@ class _DashboardHandler(http.server.BaseHTTPRequestHandler):
                     sort=_str(query, "sort"),
                 )
                 self._respond("application/json", self._json(page))
+            elif parsed.path == "/diff":
+                # This commit's file diffs, straight from the local clone — so the dashboard
+                # shows changes without GitHub. The sha is validated as a hex id in commit_diff.
+                self._respond("application/json", self._json(commit_diff(self.repo, _str(query, "sha"))))
             else:
                 self.send_error(404, "not found")
         except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):

{agitrack-0.2.2 → agitrack-0.2.4}/agitrack/metrics/web.py

@@ -25,6 +25,7 @@ and ad-hoc use; the live page does not embed it.
 from __future__ import annotations
 
 import json
+import re
 from datetime import datetime, timedelta, timezone
 
 from agitrack.commits import METADATA_HEADER
@@ -473,6 +474,7 @@ def _log_entry(dash: Dashboard, stat: CommitStat, covers: dict[str, CommitStat])
     eff_backend, eff_model = _effective(stat, covers)
     return {
         "short": stat.short,
+        "sha": stat.sha,  # full sha so the live page can fetch this commit's diff from /diff
         "author": dash.label_of(stat),
         "committers": dash.committers_of(stat),
         "subject": stat.subject,
@@ -529,6 +531,24 @@ def log_page(
     }
 
 
+# A commit id must be a bare hex object name before it is handed to git, so a crafted
+# ?sha= value can never become a git option (e.g. --upload-pack) or reach the shell.
+_SHA_RE = re.compile(r"^[0-9a-fA-F]{4,64}$")
+
+
+def commit_diff(repo: GitRepo, sha: str) -> dict:
+    """The file diffs a single commit introduced (a diffstat + unified patch), for the
+    dashboard's local diff view — computed entirely from the local clone, so the dashboard
+    needs no GitHub. ``sha`` is validated as a hex object id before touching git."""
+    if not _SHA_RE.match(sha or ""):
+        return {"sha": sha, "diff": "", "error": "invalid commit id"}
+    try:
+        patch, truncated = repo.show_commit(sha)
+    except Exception:
+        return {"sha": sha, "diff": "", "error": "could not read this commit's diff"}
+    return {"sha": sha, "diff": patch, "truncated": truncated}
+
+
 def initial_payload(dash: Dashboard, *, shared_sessions: list[dict] | None = None) -> dict:
     """What the page embeds for an instant first paint: unfiltered aggregates,
     the first log page, repo metadata, the page size, and any shared sessions."""
@@ -557,7 +577,7 @@ _TEMPLATE = r"""<!DOCTYPE html>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>aGiTrack - Dashboard · __REPO_NAME__</title>
-<!-- Inline SVG favicon (the aGiTrack wordmark mark) — the server only serves /, /data, /log, so it can't host a file. -->
+<!-- Inline SVG favicon (the aGiTrack wordmark mark) — the server only serves /, /data, /log, /diff, so it can't host a file. -->
 <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%2064%2064'%3E%3Crect%20width='64'%20height='64'%20rx='13'%20fill='%23070b09'/%3E%3Ctext%20x='32'%20y='45'%20text-anchor='middle'%20font-family='ui-monospace,monospace'%20font-weight='700'%20font-size='42'%20letter-spacing='-1'%3E%3Ctspan%20fill='%23ffb454'%3Ea%3C/tspan%3E%3Ctspan%20fill='%233dffa0'%3EG%3C/tspan%3E%3C/text%3E%3C/svg%3E">
 <link rel="preconnect" href="https://fonts.googleapis.com">
 <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
@@ -680,8 +700,10 @@ h2.section::before{content:"# ";color:var(--amber)}
 /* No text-transform: the "aGiTrack" brand must never render all-caps. */
 .card .label{font-size:11.5px;color:var(--amber);letter-spacing:.5px}
 .card .value{font-family:var(--display);font-size:42px;line-height:1.05;color:var(--phosphor);margin-top:6px;
-  text-shadow:0 0 14px rgba(61,255,160,.3)}
+  text-shadow:0 0 14px rgba(61,255,160,.3);white-space:nowrap}
 .card .value.amber{color:var(--amber);text-shadow:0 0 14px rgba(255,180,84,.3)}
+/* scientific-notation exponent: noticeably smaller than the mantissa (e.g. 1.01×10⁸) */
+.card .value sup{font-size:.5em;vertical-align:super;line-height:0;margin-left:1px}
 .card .note{font-size:12px;color:var(--fg-dim);margin-top:4px}
 
 /* ---- time-series chart ---- */
@@ -795,6 +817,21 @@ h2.section::before{content:"# ";color:var(--amber)}
 .entry .detail .dmeta{color:var(--ops);font-size:12px;margin-bottom:6px}
 .entry .detail .dmsg{font-size:12.5px;color:var(--fg-dim);background:var(--ink);border:1px solid var(--line);
   padding:4px 12px;max-height:440px;overflow:auto;word-break:break-word}
+/* local (off-GitHub) per-commit file diff — the button flips this one box to the diff, so in diff
+   mode the box drops its own frame and the .diffbox (with its own border/scroll) becomes the pane */
+.entry .detail .dmsg.diff{padding:0;border:none;background:none;max-height:none;overflow:visible}
+.entry .detail .diffbtn{margin-right:10px;font-family:inherit;font-size:11.5px;color:var(--phosphor);
+  background:transparent;border:1px solid var(--phosphor-dim);padding:1px 8px;cursor:pointer;letter-spacing:.3px}
+.entry .detail .diffbtn:hover{background:var(--phosphor);color:var(--ink)}
+.diffbox{border:1px solid var(--line);background:var(--ink);max-height:460px;overflow:auto;
+  font-size:12px;line-height:1.5;white-space:pre}
+.diffbox .dl{display:block;padding:0 10px}
+.diffbox .dfile{color:var(--amber);background:rgba(255,180,84,.06)}
+.diffbox .dhunk{color:var(--ops);background:rgba(103,184,214,.09)}
+.diffbox .dmeta2{color:var(--fg-dim)}
+.diffbox .dadd{color:var(--phosphor);background:rgba(61,255,160,.08)}
+.diffbox .ddel{color:var(--red);background:rgba(255,107,107,.08)}
+.dmsg .diffempty{color:var(--fg-dim);font-size:12px;font-style:italic;padding:8px 12px}
 /* rendered Markdown inside the expanded message */
 .dmsg.md p{margin:7px 0}
 .dmsg.md .md-h{font-family:var(--mono);color:var(--amber);margin:11px 0 5px;font-size:13px;font-weight:600}
@@ -1090,7 +1127,21 @@ function subBarRow(name, value, max, numHtml, min){
 }
 function card(label, value, note, amber){
   return `<div class="card"><div class="label">${esc(label)}</div>`+
-    `<div class="value ${amber?"amber":""}">${value}</div><div class="note">${esc(note||"")}</div></div>`;
+    `<div class="value ${amber?"amber":""}">${bigValue(value)}</div><div class="note">${esc(note||"")}</div></div>`;
+}
+// Keep the big display font, but when a plain integer is too long to fit the card (e.g. 100M+
+// output tokens) show it in scientific notation instead — nicer than shrinking the type. Percents,
+// ratios, "—", and already-short numbers are shown verbatim.
+function bigValue(value){
+  const m = String(value).match(/^([+\-]?)([\d,]+)$/);   // a signed, comma-grouped integer only
+  if(!m || m[2].length <= 9) return value;               // ≤ 9 chars incl. commas still fits at 42px
+  return m[1] + sci(Number(m[2].replace(/,/g,"")));
+}
+function sci(n){
+  if(!isFinite(n) || n===0) return "0";
+  const exp = Math.floor(Math.log10(n));
+  const mant = (n/Math.pow(10,exp)).toFixed(2).replace(/\.?0+$/,"");  // 1.01, 1.2, 5, …
+  return mant + "×10<sup>" + exp + "</sup>";                          // e.g. 1.01×10⁸ (exp in a <sup>)
 }
 function tokenBrief(t){
   if(!t) return "";
@@ -1423,19 +1474,71 @@ function toggleDetail(i){
   const c = LOG_ENTRIES[i], detail = $("detail-"+i);
   if(!c || !detail) return;
   if(detail.hidden){
+    // Local file diff (served from the clone by /diff) is the primary, GitHub-free action;
+    // the GitHub link is kept as an optional extra when a remote is configured. A squash has
+    // no single diff worth showing here (its parts expand separately), so skip the button then.
+    const diffBtn = (LIVE && c.sha && !(c.parts&&c.parts.length))
+      ? `<button class="diffbtn" data-diff="${i}">show file diff</button>` : "";
     const link = c.url ? `<a href="${esc(c.url)}" target="_blank" rel="noopener">view on GitHub ↗</a>` : "";
     const span = (c.started||c.ended)
       ? `<div class="dmeta">AI conversation: ${esc(c.started||"?")} → ${esc(c.ended||"?")}</div>` : "";
     const who = (c.committers&&c.committers.length)
       ? `<div class="dmeta">committer${c.committers.length>1?"s":""}: ${c.committers.map(esc).join(", ")}</div>` : "";
-    detail.innerHTML = `<div class="dhead">${esc(c.short)} ${link}</div>${who}${span}`+
-      `<div class="dmsg md">${md(c.message||"(no message recorded)")}</div>${partsHtml(c.parts)}`;
+    detail.innerHTML = `<div class="dhead">${esc(c.short)} ${diffBtn}${link}</div>${who}${span}`+
+      `<div class="dmsg md" id="dbody-${i}" data-mode="msg">${md(c.message||"(no message recorded)")}</div>`+
+      partsHtml(c.parts);
     detail.hidden = false;
   } else {
     detail.hidden = true;
   }
 }
 
+// One box that flips between the commit message and this commit's file diff — the button toggles
+// which is shown, so you never juggle two panes. The diff (from the local clone via /diff, no
+// GitHub) is fetched once and cached by sha, so flipping back and forth is instant.
+const _diffCache = {};
+async function toggleDiff(i){
+  const c = LOG_ENTRIES[i], body = $("dbody-"+i);
+  const btn = document.querySelector('.diffbtn[data-diff="'+i+'"]');
+  if(!c || !body) return;
+  if(body.dataset.mode === "diff"){                       // diff → back to the commit message
+    body.dataset.mode = "msg"; body.className = "dmsg md";
+    body.innerHTML = md(c.message||"(no message recorded)");
+    if(btn) btn.textContent = "show file diff";
+    return;
+  }
+  // commit message → file diff. Flip the mode + button label now for instant feedback, but KEEP the
+  // message visible until the diff is ready, then swap the box in a single paint — so there's no
+  // "loading…" placeholder flashing on the first (uncached) switch.
+  body.dataset.mode = "diff";
+  if(btn) btn.textContent = "show commit message";
+  const apply = html => { if(body.dataset.mode === "diff"){ body.className = "dmsg diff"; body.innerHTML = html; } };
+  if(_diffCache[c.sha] !== undefined){ apply(_diffCache[c.sha]); return; }
+  try{
+    const r = await fetch("diff?sha="+encodeURIComponent(c.sha), {cache:"no-store"});
+    const d = r.ok ? await r.json() : {error:"server error"};
+    let html;
+    if(d.error) html = '<div class="diffempty">'+esc(d.error)+'</div>';
+    else if(!d.diff || !d.diff.trim()) html = '<div class="diffempty">no file changes in this commit</div>';
+    else html = renderDiff(d.diff) + (d.truncated?'<div class="diffempty">…diff truncated (very large commit)</div>':"");
+    _diffCache[c.sha] = html;
+    apply(html);  // apply() no-ops if the user flipped back to the message mid-fetch
+  }catch(e){ apply('<div class="diffempty">couldn\'t load the diff (server unreachable)</div>'); }
+}
+// Color a unified diff (diffstat + patch) line-by-line: file headers, hunk headers, +adds, −dels.
+function renderDiff(text){
+  const rows = (text||"").replace(/\r\n/g,"\n").replace(/\n+$/,"").split("\n").map(raw => {
+    let cls = "dl";
+    if(/^(diff --git |index |new file|deleted file|similarity |rename |old mode|new mode)/.test(raw)) cls="dl dfile";
+    else if(raw.startsWith("@@")) cls="dl dhunk";
+    else if(raw.startsWith("+++")||raw.startsWith("---")) cls="dl dmeta2";
+    else if(raw.startsWith("+")) cls="dl dadd";
+    else if(raw.startsWith("-")) cls="dl ddel";
+    return '<span class="'+cls+'">'+(esc(raw)||"&nbsp;")+'</span>';
+  });
+  return '<pre class="diffbox">'+rows.join("")+'</pre>';
+}
+
 function fillSelect(id, values, allLabel, keep){
   const sel = $(id);
   sel.innerHTML = `<option value="">${allLabel}</option>` +
@@ -1571,6 +1674,8 @@ async function init(){
   // inside the opened detail (links, the squash <details> tree, the pager) are
   // left alone.
   $("commitlog").addEventListener("click", e => {
+    const dbtn = e.target.closest(".diffbtn");
+    if(dbtn){ e.preventDefault(); toggleDiff(+dbtn.dataset.diff); return; }
     if(e.target.closest("a") || e.target.closest(".detail") || e.target.closest(".pager")) return;
     const entry = e.target.closest(".entry");
     if(entry) toggleDetail(+entry.dataset.i);

{agitrack-0.2.2 → agitrack-0.2.4}/agitrack/proc.py

@@ -131,13 +131,23 @@ def console_isolation_kwargs(*, detach_stdin: bool = True) -> dict:
 
     Pass ``detach_stdin=False`` for a call that already feeds the child via ``input=`` (the two
     are mutually exclusive in ``subprocess``); the ``input=`` pipe already keeps it off the
-    console. On POSIX there is no console coupling, so only the stdin detach (harmless) applies.
+    console.
+
+    On POSIX, run the child in its OWN session (``start_new_session`` → ``setsid``). aGiTrack fires
+    many short git subprocesses (per-turn commits, status/branch polls); left in aGiTrack's process
+    group they sit in the controlling terminal's FOREGROUND group, so the terminal keeps retitling
+    its tab to "git" and back — a visible flicker during the startup burst. A new session takes the
+    child out of the foreground group so the title stays put. It's safe here because these children
+    are output-captured with stdin detached (``DEVNULL`` or an ``input=`` pipe): they never need the
+    controlling terminal — no pager, no credential prompt on the tty.
     """
     kwargs: dict = {}
     if detach_stdin:
         kwargs["stdin"] = subprocess.DEVNULL
     if _IS_WINDOWS:
         kwargs["creationflags"] = getattr(subprocess, "CREATE_NO_WINDOW", 0)
+    else:
+        kwargs["start_new_session"] = True
     return kwargs
 
 

{agitrack-0.2.2 → agitrack-0.2.4}/agitrack/proxy/commit_engine.py

@@ -153,6 +153,21 @@ def _prompt_covered_by(pending: str, prompt: str) -> bool:
     return len(pt & tt) / len(pt) >= 0.9
 
 
+def _garbled_short_duplicate(pending: str, prompt: str) -> bool:
+    """True when a SHORT *pending* leftover looks like a garbled capture of *prompt* already in the
+    trace. The proxy reconstructs the raw typed bytes, so a follow-up typed while the agent was busy
+    can be captured with a dropped leading/trailing character (e.g. "ontinue" for "Continue"). Such a
+    one-word near-copy is too short for the word-overlap / containment checks above (which need ≥3
+    words), so it would leak in as a spurious extra ## User heading. For short prompts (≤2 words),
+    treat them as the same when one's normalized text is a substring of the other's AND covers most
+    of it (≥0.7) — which catches a dropped edge character without matching unrelated short words."""
+    a, b = _norm(pending).lower(), _norm(prompt).lower()
+    if not a or not b or len(_TOKEN_RE.findall(a)) > 2 or len(_TOKEN_RE.findall(b)) > 2:
+        return False
+    short, long = (a, b) if len(a) <= len(b) else (b, a)
+    return len(short) >= 3 and short in long and len(short) / len(long) >= 0.7
+
+
 class CommitEngine:
     """Stateless agent-commit engine bound to a ``(repo, state)`` pair.
 
@@ -270,7 +285,8 @@ class CommitEngine:
                 # Each message the user queued mid-turn gets its OWN ## User heading (it was sent
                 # after the agent had already said something), not merged into the base prompt.
                 for followup in turn.queued_followups:
-                    self.state.append_trace("user", followup)
+                    if followup.strip():
+                        self.state.append_trace("user", followup)
                 for message in self._agent_messages_for(turn):
                     self.state.append_trace("agent", message)
                 self.state.add_token_usage(turn.tokens)
@@ -297,6 +313,8 @@ class CommitEngine:
                 # A mid-turn queued message gets its own ## User heading (sent after the agent
                 # already responded), rather than being merged into the base prompt.
                 for followup in turn.queued_followups:
+                    if not followup.strip():
+                        continue
                     subject_prompts.append(followup)
                     entries.append(("user", followup))
                 for message in self._agent_messages_for(turn):
@@ -320,7 +338,9 @@ class CommitEngine:
                 # (_same_prompt) OR because the turn aggregated it as a queued follow-up so the
                 # base is CONTAINED in the (longer) combined turn prompt (_prompt_covered_by).
                 if any(
-                    _same_prompt(pending_user, prompt) or _prompt_covered_by(pending_user, prompt)
+                    _same_prompt(pending_user, prompt)
+                    or _prompt_covered_by(pending_user, prompt)
+                    or _garbled_short_duplicate(pending_user, prompt)
                     for prompt in turn_prompts
                 ):
                     continue
@@ -766,7 +786,7 @@ class CommitEngine:
         slash command). Slash commands (``/compact``, ``/model``, …) are backend
         directives, not prompts, and are kept out of the trace — see
         :func:`_is_slash_command`."""
-        if prompt_text and not _is_slash_command(prompt_text):
+        if prompt_text and prompt_text.strip() and not _is_slash_command(prompt_text):
             self.state.append_trace("user", prompt_text)
 
     def await_followup(self, prompt_text: str, awaited: list[str]) -> list[str]:

{agitrack-0.2.2 → agitrack-0.2.4}/agitrack/proxy/modal.py

@@ -120,20 +120,27 @@ class PromptModal:
         if data == b"\x1b":
             return ("cancel", None)
 
+        # Only redraw when something actually changed. Mouse-motion reports (and other dropped
+        # sequences) arrive as escape sequences here; without this a moving mouse would return
+        # "redraw" for every report and repaint the popup dozens of times a second (title flash +
+        # slowdown). Such no-op input returns "noop" so the caller keeps reading without repainting.
+        changed = False
         for byte in data:
             char = bytes([byte])
 
             # Inside an escape sequence: accumulate until complete. PgUp/PgDn scroll the
-            # detail list; any other complete sequence (arrows, etc.) is dropped.
+            # detail list; any other complete sequence (arrows, mouse reports, etc.) is dropped.
             if self._escape_buffer is not None:
                 self._escape_buffer.extend(char)
                 sequence = bytes(self._escape_buffer)
                 if sequence == b"\x1b[5~":  # PageUp — scroll the detail list up
                     self.detail_scroll = max(0, self.detail_scroll - max(1, self._detail_window() - 1))
                     self._escape_buffer = None
+                    changed = True
                 elif sequence == b"\x1b[6~":  # PageDown — scroll the detail list down
                     self.detail_scroll += max(1, self._detail_window() - 1)
                     self._escape_buffer = None
+                    changed = True
                 elif _escape_sequence_complete(sequence):
                     self._escape_buffer = None
                 continue
@@ -150,10 +157,12 @@ class PromptModal:
 
             if char in {b"\x7f", b"\b"}:
                 self.value = self.value[:-1]
+                changed = True
             elif byte >= 32:
                 self.value += char.decode(errors="ignore")
+                changed = True
 
-        return ("redraw", None)
+        return ("redraw", None) if changed else ("noop", None)
 
 
 class SelectModal:
@@ -281,6 +290,10 @@ class SelectModal:
         if data == b"\x1b":
             return ("cancel", None)
 
+        # See PromptModal.feed: return "redraw" only on a real change so a moving mouse (whose
+        # motion reports arrive here as dropped escape sequences) doesn't repaint the menu on
+        # every report — which flashed the title and slowed everything down.
+        changed = False
         for byte in data:
             char = bytes([byte])
 
@@ -290,15 +303,19 @@ class SelectModal:
                 if sequence == b"\x1b[A":
                     self._advance(-1)
                     self._escape_buffer = None
+                    changed = True
                 elif sequence == b"\x1b[B":
                     self._advance(1)
                     self._escape_buffer = None
+                    changed = True
                 elif sequence == b"\x1b[5~":  # PageUp — scroll the detail list up
                     self.detail_scroll = max(0, self.detail_scroll - max(1, self._detail_window() - 1))
                     self._escape_buffer = None
+                    changed = True
                 elif sequence == b"\x1b[6~":  # PageDown — scroll the detail list down
                     self.detail_scroll += max(1, self._detail_window() - 1)
                     self._escape_buffer = None
+                    changed = True
                 elif _escape_sequence_complete(sequence):
                     self._escape_buffer = None
                 continue
@@ -313,4 +330,4 @@ class SelectModal:
             if char in {b"\r", b"\n"}:
                 return ("done", self.options[self.selected])
 
-        return ("redraw", None)
+        return ("redraw", None) if changed else ("noop", None)