absolutelyright 0.2.0a2__py3-none-any.whl

absolutelyright/__init__.py

@@ -0,0 +1,29 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("absolutelyright")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+from absolutelyright._records import (
+    Prompt,
+    Session,
+    load_sessions,
+    parse_session,
+    session_files,
+)
+from absolutelyright._stats import (
+    by_project,
+    claudeisms,
+    corrections,
+    daily_counts,
+    hour_histogram,
+    model_mix,
+    overview,
+    repeated_prompts,
+    session_rows,
+    shipped,
+    slash_counts,
+    tool_counts,
+    vibe,
+)

absolutelyright/_records.py

@@ -0,0 +1,224 @@
+"""parsing for claude code session transcripts.
+
+each session is a jsonl file under ~/.claude/projects/<encoded-cwd>/<uuid>.jsonl.
+user-role records are a grab bag: typed prompts, tool results, slash-command
+expansions, bash passthroughs, and interrupt markers all share `type: "user"`.
+this module separates what a human actually typed from harness noise — and
+mines the rest of the record stream (titles, pr links, models, usage, tics)
+in the same single pass.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from collections import Counter
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+
+def default_claude_dir() -> Path:
+    """where claude code keeps its data: $CLAUDE_CONFIG_DIR, else ~/.claude."""
+    return Path(os.environ.get("CLAUDE_CONFIG_DIR") or Path.home() / ".claude")
+
+
+DEFAULT_CLAUDE_DIR = default_claude_dir()
+
+# substrings that mark a user-role record as harness traffic, not a typed prompt
+NOISE_MARKERS = (
+    "<command-name>",
+    "<command-message>",
+    "<bash-input>",
+    "<bash-stdout>",
+    "<local-command-stdout>",
+    "<task-notification>",
+    "<system-reminder>",
+    "[Request interrupted",
+    "Caveat: the messages below",
+)
+
+# things claude says
+ISM_PATTERNS = {
+    "you're absolutely right": re.compile(r"you'?re absolutely right", re.I),
+    "let me …": re.compile(r"^let me ", re.I | re.M),
+    "now i see": re.compile(r"\bnow i see\b", re.I),
+    "the issue is": re.compile(r"\bthe (?:real )?issue is\b", re.I),
+    "should now work": re.compile(r"\bshould (?:now )?work\b", re.I),
+    "great question": re.compile(r"\bgreat question\b", re.I),
+    "perfect!": re.compile(r"\bperfect!", re.I),
+}
+
+# things you say
+VIBE_PATTERNS = {
+    "please": re.compile(r"\bplease\b|\bpls\b", re.I),
+    "thanks": re.compile(r"\bthanks?\b|\bty\b", re.I),
+    "dude": re.compile(r"\bdude\b", re.I),
+    "bro": re.compile(r"\bbro\b", re.I),
+    "lol": re.compile(r"\blo+l\b|\blmao\b", re.I),
+    "profanity": re.compile(r"\b(?:fuck\w*|shit\w*|damn|wtf)\b", re.I),
+}
+
+IMAGE_RE = re.compile(r"\[Image #\d+\]")
+SLASH_RE = re.compile(r"<command-name>(\S+?)</command-name>")
+
+# gaps longer than this don't count toward active time (you walked away)
+IDLE_CAP_SECONDS = 300
+
+
+@dataclass(slots=True)
+class Prompt:
+    text: str
+    project: str
+    session_id: str
+    timestamp: datetime | None
+
+
+@dataclass(slots=True)
+class Session:
+    path: Path
+    session_id: str
+    project: str
+    title: str = ""
+    prompts: list[Prompt] = field(default_factory=list)
+    interrupts: int = 0
+    tool_calls: Counter[str] = field(default_factory=Counter)
+    output_tokens: int = 0
+    input_tokens: int = 0
+    cache_read_tokens: int = 0
+    models: Counter[str] = field(default_factory=Counter)
+    isms: Counter[str] = field(default_factory=Counter)
+    vibe: Counter[str] = field(default_factory=Counter)
+    slash_commands: Counter[str] = field(default_factory=Counter)
+    pr_urls: set[str] = field(default_factory=set)
+    images: int = 0
+    first_ts: datetime | None = None
+    last_ts: datetime | None = None
+    active_seconds: float = 0.0
+
+
+def _parse_timestamp(raw: str | None) -> datetime | None:
+    if not raw:
+        return None
+    try:
+        return datetime.fromisoformat(raw.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+
+
+def _flatten_text(content: Any) -> str | None:
+    """collapse message content to text, or None if there is none (e.g. pure tool_result)."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        texts = [
+            block.get("text", "")
+            for block in content
+            if isinstance(block, dict) and block.get("type") == "text"
+        ]
+        if texts:
+            return "\n".join(texts)
+    return None
+
+
+def _shorten_home(cwd: str) -> str:
+    home = str(Path.home())
+    if cwd == home:
+        return "~"
+    return cwd.removeprefix(home + "/")
+
+
+def session_files(claude_dir: Path) -> list[Path]:
+    """top-level session transcripts. subdirectories hold subagent sidechains."""
+    return sorted(claude_dir.glob("projects/*/*.jsonl"))
+
+
+def parse_session(path: Path, since: datetime | None = None) -> Session:
+    session = Session(path=path, session_id=path.stem, project="?")
+
+    with path.open() as f:
+        for line in f:
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if record.get("isSidechain"):
+                continue
+
+            kind = record.get("type")
+            if kind == "ai-title":
+                session.title = record.get("aiTitle") or session.title
+                continue
+            if kind == "pr-link":
+                if url := record.get("prUrl"):
+                    session.pr_urls.add(url)
+                continue
+
+            timestamp = _parse_timestamp(record.get("timestamp"))
+            if since and timestamp and timestamp < since:
+                continue
+            if timestamp:
+                if session.first_ts is None:
+                    session.first_ts = timestamp
+                elif session.last_ts is not None:
+                    gap = (timestamp - session.last_ts).total_seconds()
+                    if 0 < gap <= IDLE_CAP_SECONDS:
+                        session.active_seconds += gap
+                session.last_ts = timestamp
+            if session.project == "?" and record.get("cwd"):
+                session.project = _shorten_home(record["cwd"])
+
+            message = record.get("message") or {}
+            if kind == "assistant":
+                if model := message.get("model"):
+                    if not model.startswith("<"):  # `<synthetic>` placeholder rows
+                        session.models[model] += 1
+                for block in message.get("content") or []:
+                    if not isinstance(block, dict):
+                        continue
+                    if block.get("type") == "tool_use":
+                        session.tool_calls[block.get("name", "?")] += 1
+                    elif block.get("type") == "text":
+                        for name, pattern in ISM_PATTERNS.items():
+                            session.isms[name] += len(pattern.findall(block["text"]))
+                usage = message.get("usage") or {}
+                session.output_tokens += usage.get("output_tokens", 0)
+                session.input_tokens += usage.get("input_tokens", 0)
+                session.cache_read_tokens += usage.get("cache_read_input_tokens", 0)
+            elif kind == "user":
+                text = _flatten_text(message.get("content"))
+                if text is None:
+                    continue
+                if "[Request interrupted" in text:
+                    session.interrupts += 1
+                    continue
+                if match := SLASH_RE.search(text):
+                    session.slash_commands[match.group(1)] += 1
+                    continue
+                if record.get("isMeta") or any(m in text for m in NOISE_MARKERS):
+                    continue
+                text = text.strip()
+                if text:
+                    session.images += len(IMAGE_RE.findall(text))
+                    for name, pattern in VIBE_PATTERNS.items():
+                        session.vibe[name] += len(pattern.findall(text))
+                    session.prompts.append(
+                        Prompt(
+                            text=text,
+                            project=session.project,
+                            session_id=record.get("sessionId", session.session_id),
+                            timestamp=timestamp,
+                        )
+                    )
+
+    return session
+
+
+def load_sessions(
+    claude_dir: Path = DEFAULT_CLAUDE_DIR, days: int | None = None
+) -> list[Session]:
+    since = datetime.now(UTC) - timedelta(days=days) if days is not None else None
+    sessions = [parse_session(path, since=since) for path in session_files(claude_dir)]
+    return [s for s in sessions if s.prompts or s.tool_calls or s.interrupts]

absolutelyright/_stats.py

@@ -0,0 +1,163 @@
+"""aggregations over parsed sessions."""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+from datetime import UTC, date, datetime, timedelta
+from typing import Any
+
+from absolutelyright._records import Prompt, Session
+
+CORRECTION_RE = re.compile(
+    r"^(no|nope|wait|stop|actually|wrong|not that|undo|revert|that's not)\b", re.I
+)
+
+MAX_REPEAT_LEN = 200  # longer prompts are never literal repeats worth surfacing
+
+
+def all_prompts(sessions: list[Session]) -> list[Prompt]:
+    return [p for s in sessions for p in s.prompts]
+
+
+def overview(sessions: list[Session]) -> dict[str, Any]:
+    prompts = all_prompts(sessions)
+    timestamps = sorted(p.timestamp for p in prompts if p.timestamp)
+    return {
+        "sessions": len(sessions),
+        "prompts": len(prompts),
+        "interrupts": sum(s.interrupts for s in sessions),
+        "toolCalls": sum(sum(s.tool_calls.values()) for s in sessions),
+        "outputTokens": sum(s.output_tokens for s in sessions),
+        "cacheReadTokens": sum(s.cache_read_tokens for s in sessions),
+        "prsShipped": len({url for s in sessions for url in s.pr_urls}),
+        "projects": len({s.project for s in sessions}),
+        "first": timestamps[0].isoformat() if timestamps else None,
+        "last": timestamps[-1].isoformat() if timestamps else None,
+    }
+
+
+def repeated_prompts(
+    sessions: list[Session], top: int = 15, min_count: int = 2
+) -> list[tuple[str, int]]:
+    counts = Counter(
+        p.text.lower() for p in all_prompts(sessions) if len(p.text) <= MAX_REPEAT_LEN
+    )
+    return [(text, n) for text, n in counts.most_common(top) if n >= min_count]
+
+
+def corrections(sessions: list[Session]) -> list[Prompt]:
+    return [p for p in all_prompts(sessions) if CORRECTION_RE.match(p.text)]
+
+
+def by_project(sessions: list[Session]) -> list[dict[str, Any]]:
+    rows: dict[str, dict[str, Any]] = {}
+    for s in sessions:
+        row = rows.setdefault(
+            s.project,
+            {
+                "project": s.project,
+                "sessions": 0,
+                "prompts": 0,
+                "interrupts": 0,
+                "outputTokens": 0,
+            },
+        )
+        row["sessions"] += 1
+        row["prompts"] += len(s.prompts)
+        row["interrupts"] += s.interrupts
+        row["outputTokens"] += s.output_tokens
+    return sorted(rows.values(), key=lambda r: r["prompts"], reverse=True)
+
+
+def tool_counts(sessions: list[Session]) -> list[tuple[str, int]]:
+    totals: Counter[str] = Counter()
+    for s in sessions:
+        totals.update(s.tool_calls)
+    return totals.most_common()
+
+
+def hour_histogram(sessions: list[Session]) -> dict[int, int]:
+    """prompts by local hour of day."""
+    hours: Counter[int] = Counter()
+    for p in all_prompts(sessions):
+        if p.timestamp:
+            hours[p.timestamp.astimezone().hour] += 1
+    return dict(sorted(hours.items()))
+
+
+def claudeisms(sessions: list[Session]) -> list[tuple[str, int]]:
+    """things claude says, counted across all assistant turns."""
+    totals: Counter[str] = Counter()
+    for s in sessions:
+        totals.update(s.isms)
+    return totals.most_common()
+
+
+def vibe(sessions: list[Session]) -> list[tuple[str, int]]:
+    """things you say."""
+    totals: Counter[str] = Counter()
+    for s in sessions:
+        totals.update(s.vibe)
+    totals["images pasted"] = sum(s.images for s in sessions)
+    return totals.most_common()
+
+
+def model_mix(sessions: list[Session]) -> list[tuple[str, int]]:
+    totals: Counter[str] = Counter()
+    for s in sessions:
+        totals.update(s.models)
+    return totals.most_common()
+
+
+def slash_counts(sessions: list[Session]) -> list[tuple[str, int]]:
+    totals: Counter[str] = Counter()
+    for s in sessions:
+        totals.update(s.slash_commands)
+    return totals.most_common()
+
+
+def shipped(sessions: list[Session]) -> list[dict[str, str]]:
+    """unique PRs opened, most recent project first."""
+    epoch = datetime.min.replace(tzinfo=UTC)
+    seen: dict[str, str] = {}
+    for s in sorted(
+        sessions, key=lambda s: s.last_ts or s.first_ts or epoch, reverse=True
+    ):
+        for url in sorted(s.pr_urls):
+            seen.setdefault(url, s.project)
+    return [{"url": url, "project": project} for url, project in seen.items()]
+
+
+def session_rows(sessions: list[Session]) -> list[dict[str, Any]]:
+    """one row per session for the sessions browser, most recent first."""
+    rows = []
+    for s in sessions:
+        if s.first_ts is None:
+            continue
+        rows.append(
+            {
+                "when": s.first_ts.astimezone().strftime("%m-%d %H:%M"),
+                "title": s.title or "(untitled)",
+                "project": s.project,
+                "activeMinutes": round(s.active_seconds / 60),
+                "prompts": len(s.prompts),
+                "interrupts": s.interrupts,
+                "outputTokens": s.output_tokens,
+                "_sort": s.first_ts,
+            }
+        )
+    rows.sort(key=lambda r: r["_sort"], reverse=True)
+    for row in rows:
+        del row["_sort"]
+    return rows
+
+
+def daily_counts(sessions: list[Session], days: int = 30) -> list[int]:
+    """prompts per day for the trailing window, oldest first (sparkline food)."""
+    today = date.today()
+    counts: Counter[date] = Counter()
+    for p in all_prompts(sessions):
+        if p.timestamp:
+            counts[p.timestamp.astimezone().date()] += 1
+    return [counts.get(today - timedelta(days=i), 0) for i in range(days - 1, -1, -1)]

absolutelyright/cli.py

@@ -0,0 +1,185 @@
+"""command-line interface for absolutelyright.
+
+machine-readable by default: lists are ndjson (one json object per line) and
+single results are one json object, so output pipes straight into jq or an
+agent. pass --pretty for human-formatted output.
+"""
+
+import json
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+import cyclopts
+
+import absolutelyright
+from absolutelyright import _stats
+from absolutelyright._records import DEFAULT_CLAUDE_DIR, Session, load_sessions
+
+app = cyclopts.App(
+    name="absolutelyright",
+    help="analytics over your claude code session transcripts",
+    version=absolutelyright.__version__,
+)
+
+
+def _emit(data: dict[str, Any]) -> None:
+    print(json.dumps(data))
+
+
+@app.default
+def tui(*, days: int | None = None, claude_dir: Path = DEFAULT_CLAUDE_DIR) -> None:
+    """interactive dashboard (the default — just run `absolutelyright`)."""
+    if not (claude_dir / "projects").is_dir():
+        raise SystemExit(f"no transcripts found under {claude_dir}/projects")
+    from absolutelyright.tui import run
+
+    run(claude_dir=claude_dir, days=days)
+
+
+@lru_cache  # `report` runs every command in-process; parse transcripts once
+def _load(claude_dir: Path, days: int | None) -> list[Session]:
+    if not (claude_dir / "projects").is_dir():
+        raise SystemExit(f"no transcripts found under {claude_dir}/projects")
+    return load_sessions(claude_dir, days=days)
+
+
+@app.command
+def overview(
+    *,
+    days: int | None = None,
+    claude_dir: Path = DEFAULT_CLAUDE_DIR,
+    pretty: bool = False,
+) -> None:
+    """totals: sessions, prompts, interrupts, tokens, date range."""
+    stats = _stats.overview(_load(claude_dir, days))
+    if not pretty:
+        _emit(stats)
+        return
+    span = ""
+    if stats["first"]:
+        span = f"   {stats['first'][:10]} → {stats['last'][:10]}"
+    print(f"{stats['sessions']} sessions across {stats['projects']} projects{span}")
+    print(f"  prompts: {stats['prompts']}")
+    print(f"  interrupts: {stats['interrupts']}")
+    print(f"  tool calls: {stats['toolCalls']}")
+    print(f"  output tokens: {stats['outputTokens']:,}")
+
+
+@app.command
+def prompts(
+    top: int = 15,
+    *,
+    days: int | None = None,
+    claude_dir: Path = DEFAULT_CLAUDE_DIR,
+    pretty: bool = False,
+) -> None:
+    """your most-repeated literal prompts."""
+    for text, count in _stats.repeated_prompts(_load(claude_dir, days), top=top):
+        if pretty:
+            print(f"{count:5d}  {text}")
+        else:
+            _emit({"count": count, "text": text})
+
+
+@app.command
+def corrections(
+    *,
+    days: int | None = None,
+    claude_dir: Path = DEFAULT_CLAUDE_DIR,
+    pretty: bool = False,
+) -> None:
+    """prompts that open with no / wait / stop / actually."""
+    sessions = _load(claude_dir, days)
+    found = _stats.corrections(sessions)
+    total = len(_stats.all_prompts(sessions))
+    if pretty:
+        rate = 100 * len(found) / total if total else 0
+        print(f"{len(found)} of {total} prompts ({rate:.1f}%)\n")
+        for p in found:
+            first_line = p.text.splitlines()[0]
+            print(f"  [{p.project}] {first_line[:100]}")
+        return
+    for p in found:
+        _emit(
+            {
+                "text": p.text,
+                "project": p.project,
+                "timestamp": p.timestamp.isoformat() if p.timestamp else None,
+            }
+        )
+
+
+@app.command
+def projects(
+    *,
+    days: int | None = None,
+    claude_dir: Path = DEFAULT_CLAUDE_DIR,
+    pretty: bool = False,
+) -> None:
+    """per-project sessions, prompts, interrupts, and output tokens."""
+    rows = _stats.by_project(_load(claude_dir, days))
+    if not pretty:
+        for row in rows:
+            _emit(row)
+        return
+    width = max((len(r["project"]) for r in rows), default=7)
+    print(f"{'project':<{width}}  sessions  prompts  interrupts  output tokens")
+    for r in rows:
+        print(
+            f"{r['project']:<{width}}  {r['sessions']:8d}  {r['prompts']:7d}"
+            f"  {r['interrupts']:10d}  {r['outputTokens']:13,}"
+        )
+
+
+@app.command
+def tools(
+    *,
+    days: int | None = None,
+    claude_dir: Path = DEFAULT_CLAUDE_DIR,
+    pretty: bool = False,
+) -> None:
+    """tool call counts across all sessions."""
+    for name, count in _stats.tool_counts(_load(claude_dir, days)):
+        if pretty:
+            print(f"{count:7d}  {name}")
+        else:
+            _emit({"tool": name, "count": count})
+
+
+@app.command
+def hours(
+    *,
+    days: int | None = None,
+    claude_dir: Path = DEFAULT_CLAUDE_DIR,
+    pretty: bool = False,
+) -> None:
+    """prompts by local hour of day."""
+    histogram = _stats.hour_histogram(_load(claude_dir, days))
+    if not pretty:
+        _emit({f"{h:02d}": n for h, n in histogram.items()})
+        return
+    peak = max(histogram.values(), default=1)
+    for hour, count in histogram.items():
+        bar = "█" * max(1, round(40 * count / peak))
+        print(f"{hour:02d}:00  {count:5d}  {bar}")
+
+
+@app.command
+def report(
+    *,
+    days: int | None = None,
+    claude_dir: Path = DEFAULT_CLAUDE_DIR,
+) -> None:
+    """the whole picture, human-formatted."""
+    for section in (overview, prompts, corrections, projects, tools, hours):
+        print(f"\n── {section.__name__} {'─' * (40 - len(section.__name__))}")
+        section(days=days, claude_dir=claude_dir, pretty=True)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

absolutelyright/tui.py

@@ -0,0 +1,396 @@
+"""textual dashboard for absolutelyright.
+
+one screen, no scrolling walls of text: a sidebar of sections and a detail
+pane. number keys narrow the time window without leaving the app.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, ClassVar
+
+from textual import work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.widgets import (
+    ContentSwitcher,
+    DataTable,
+    Digits,
+    Footer,
+    Label,
+    ListItem,
+    ListView,
+    Sparkline,
+    Static,
+)
+from textual_plotext import PlotextPlot
+
+from absolutelyright import _stats
+from absolutelyright._records import DEFAULT_CLAUDE_DIR, Session, load_sessions
+
+SECTIONS = (
+    "overview",
+    "sessions",
+    "prompts",
+    "corrections",
+    "vibe",
+    "projects",
+    "tools",
+    "hours",
+)
+
+TERRACOTTA = "#d97757"
+TERRACOTTA_RGB = (217, 119, 87)
+
+
+def _compact(n: int | float) -> str:
+    for threshold, suffix in ((1_000_000_000, "b"), (1_000_000, "m"), (1_000, "k")):
+        if n >= threshold:
+            return f"{n / threshold:.1f}{suffix}"
+    return str(round(n))
+
+
+class AbsolutelyApp(App[None]):
+    """analytics over your claude code sessions, one screen at a time."""
+
+    TITLE = "absolutely right."
+
+    CSS = f"""
+    Screen {{
+        background: #16120e;
+        color: #e8dcc8;
+    }}
+
+    #hero {{
+        height: 4;
+        padding: 1 2 0 2;
+        background: #1f1913;
+        border-bottom: solid {TERRACOTTA};
+    }}
+
+    #title {{
+        text-style: bold;
+        color: {TERRACOTTA};
+    }}
+
+    #stats {{
+        color: #97896f;
+    }}
+
+    #main {{
+        height: 1fr;
+    }}
+
+    #sidebar {{
+        width: 20;
+        background: #1f1913;
+        border-right: solid #3a2e22;
+    }}
+
+    #sidebar ListView {{
+        height: 1fr;
+        padding: 1;
+        background: #1f1913;
+    }}
+
+    #sidebar ListItem {{
+        padding: 0 1;
+        background: #1f1913;
+        color: #97896f;
+    }}
+
+    #sidebar ListItem.--highlight {{
+        background: {TERRACOTTA};
+        color: #16120e;
+        text-style: bold;
+    }}
+
+    #detail {{
+        width: 1fr;
+        padding: 1 2;
+    }}
+
+    DataTable {{
+        height: 1fr;
+        background: #16120e;
+    }}
+
+    DataTable > .datatable--header {{
+        background: #16120e;
+        color: {TERRACOTTA};
+        text-style: bold;
+    }}
+
+    DataTable > .datatable--cursor {{
+        background: #3a2e22;
+    }}
+
+    .muted {{
+        color: #97896f;
+        padding: 0 0 1 0;
+    }}
+
+    #overview {{
+        padding: 1 2;
+    }}
+
+    #digits-row {{
+        height: 6;
+    }}
+
+    .stat {{
+        width: 1fr;
+        height: 6;
+    }}
+
+    .stat Digits {{
+        color: {TERRACOTTA};
+        width: auto;
+    }}
+
+    .stat Label {{
+        color: #97896f;
+    }}
+
+    #spark-caption {{
+        padding: 1 0 0 0;
+        color: #97896f;
+    }}
+
+    Sparkline {{
+        height: 3;
+        margin: 0 0 1 0;
+    }}
+
+    Sparkline > .sparkline--max-color {{
+        color: {TERRACOTTA};
+    }}
+
+    Sparkline > .sparkline--min-color {{
+        color: #3a2e22;
+    }}
+
+    #vibe Horizontal {{
+        height: 1fr;
+    }}
+
+    .vibe-col {{
+        width: 1fr;
+        padding: 0 2 0 0;
+    }}
+
+    .vibe-col > Label {{
+        text-style: bold;
+        color: {TERRACOTTA};
+        padding: 0 0 1 0;
+    }}
+
+    PlotextPlot {{
+        height: 1fr;
+    }}
+    """
+
+    BINDINGS: ClassVar = [
+        Binding("q", "quit", "quit"),
+        Binding("7", "window(7)", "week"),
+        Binding("3", "window(30)", "month"),
+        Binding("a", "window(None)", "all"),
+    ]
+
+    def __init__(
+        self, claude_dir: Path = DEFAULT_CLAUDE_DIR, days: int | None = None
+    ) -> None:
+        super().__init__()
+        self.claude_dir = claude_dir
+        self.days = days
+        self.sessions: list[Session] = []
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="hero"):
+            yield Static("absolutely right.", id="title")
+            yield Static("loading transcripts…", id="stats")
+        with Horizontal(id="main"):
+            with Vertical(id="sidebar"):
+                yield ListView(
+                    *[ListItem(Label(name), id=f"nav-{name}") for name in SECTIONS],
+                    id="nav",
+                )
+            with ContentSwitcher(initial="overview", id="detail"):
+                with Vertical(id="overview"):
+                    with Horizontal(id="digits-row"):
+                        for stat in ("prompts", "interrupts", "prs", "hours-active"):
+                            with Vertical(classes="stat", id=f"stat-{stat}"):
+                                yield Digits("0", id=f"digits-{stat}")
+                                yield Label(stat.replace("-", " "))
+                    yield Static("", id="spark-caption")
+                    yield Sparkline([0], summary_function=max, id="spark")
+                    yield Static("", id="model-mix", classes="muted")
+                    yield Static("", id="token-line", classes="muted")
+                yield DataTable(id="sessions", cursor_type="row", zebra_stripes=True)
+                yield DataTable(id="prompts", cursor_type="row", zebra_stripes=True)
+                with Vertical(id="corrections"):
+                    yield Label("", id="corrections-rate", classes="muted")
+                    yield DataTable(
+                        id="corrections-table", cursor_type="row", zebra_stripes=True
+                    )
+                with Vertical(id="vibe"), Horizontal():
+                    with Vertical(classes="vibe-col"):
+                        yield Label("you said")
+                        yield DataTable(id="vibe-you", cursor_type="row")
+                    with Vertical(classes="vibe-col"):
+                        yield Label("claude said")
+                        yield DataTable(id="vibe-claude", cursor_type="row")
+                yield DataTable(id="projects", cursor_type="row", zebra_stripes=True)
+                yield DataTable(id="tools", cursor_type="row", zebra_stripes=True)
+                yield PlotextPlot(id="hours")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.query_one("#sessions", DataTable).add_columns(
+            "when", "title", "project", "active", "prompts", "stops"
+        )
+        self.query_one("#prompts", DataTable).add_columns("count", "prompt")
+        self.query_one("#corrections-table", DataTable).add_columns("project", "prompt")
+        self.query_one("#vibe-you", DataTable).add_columns("word", "count")
+        self.query_one("#vibe-claude", DataTable).add_columns("tic", "count")
+        self.query_one("#projects", DataTable).add_columns(
+            "project", "sessions", "prompts", "stops", "output tokens"
+        )
+        self.query_one("#tools", DataTable).add_columns("count", "tool")
+        self._load()
+
+    def on_list_view_highlighted(self, event: ListView.Highlighted) -> None:
+        if event.item is not None and event.item.id is not None:
+            self.query_one(
+                "#detail", ContentSwitcher
+            ).current = event.item.id.removeprefix("nav-")
+
+    def action_window(self, days: int | None) -> None:
+        self.days = days
+        self.query_one("#stats", Static).update("reloading…")
+        self._load()
+
+    @work(thread=True, exclusive=True)
+    def _load(self) -> None:
+        sessions = load_sessions(self.claude_dir, days=self.days)
+        self.call_from_thread(self._render, sessions)
+
+    def _render(self, sessions: list[Session]) -> None:
+        self.sessions = sessions
+        stats = _stats.overview(sessions)
+        isms = dict(_stats.claudeisms(sessions))
+
+        window = f"last {self.days}d" if self.days else "all local history"
+        span = (
+            f"   {stats['first'][:10]} → {stats['last'][:10]}" if stats["first"] else ""
+        )
+        right = isms.get("you're absolutely right", 0)
+        self.query_one("#stats", Static).update(
+            f"{window}{span}   ·   claude was absolutely right {right} times"
+        )
+
+        self._render_overview(sessions, stats)
+
+        table = self.query_one("#sessions", DataTable)
+        table.clear()
+        for row in _stats.session_rows(sessions):
+            table.add_row(
+                row["when"],
+                row["title"][:60],
+                row["project"],
+                f"{row['activeMinutes']}m",
+                str(row["prompts"]),
+                str(row["interrupts"]),
+            )
+
+        prompts = self.query_one("#prompts", DataTable)
+        prompts.clear()
+        for text, count in _stats.repeated_prompts(sessions, top=50, min_count=2):
+            prompts.add_row(str(count), text.replace("\n", " ")[:120])
+
+        corrections = _stats.corrections(sessions)
+        total = len(_stats.all_prompts(sessions))
+        rate = 100 * len(corrections) / total if total else 0
+        self.query_one("#corrections-rate", Label).update(
+            f"{len(corrections)} of {total} prompts ({rate:.1f}%) open with no / wait / stop / actually"
+        )
+        ctable = self.query_one("#corrections-table", DataTable)
+        ctable.clear()
+        for p in corrections:
+            ctable.add_row(p.project, p.text.splitlines()[0][:120])
+
+        you = self.query_one("#vibe-you", DataTable)
+        you.clear()
+        for word, count in _stats.vibe(sessions):
+            you.add_row(word, str(count))
+        claude = self.query_one("#vibe-claude", DataTable)
+        claude.clear()
+        for tic, count in _stats.claudeisms(sessions):
+            claude.add_row(tic, str(count))
+
+        projects = self.query_one("#projects", DataTable)
+        projects.clear()
+        for row in _stats.by_project(sessions):
+            projects.add_row(
+                row["project"],
+                str(row["sessions"]),
+                str(row["prompts"]),
+                str(row["interrupts"]),
+                f"{row['outputTokens']:,}",
+            )
+
+        tools = self.query_one("#tools", DataTable)
+        tools.clear()
+        for name, count in _stats.tool_counts(sessions):
+            tools.add_row(str(count), name)
+
+        self._render_hours(sessions)
+
+    def _render_overview(self, sessions: list[Session], stats: dict[str, Any]) -> None:
+        hours_active = sum(s.active_seconds for s in sessions) / 3600
+        self.query_one("#digits-prompts", Digits).update(_compact(stats["prompts"]))
+        self.query_one("#digits-interrupts", Digits).update(
+            _compact(stats["interrupts"])
+        )
+        self.query_one("#digits-prs", Digits).update(_compact(stats["prsShipped"]))
+        self.query_one("#digits-hours-active", Digits).update(f"{hours_active:.0f}")
+
+        days = min(self.days or 30, 30)
+        self.query_one("#spark-caption", Static).update(
+            f"prompts per day · last {days} days"
+        )
+        spark = self.query_one("#spark", Sparkline)
+        spark.data = _stats.daily_counts(sessions, days=days)
+
+        mix = _stats.model_mix(sessions)
+        total_turns = sum(n for _, n in mix) or 1
+        mix_text = "   ".join(
+            f"{name.removeprefix('claude-')} {100 * n / total_turns:.0f}%"
+            for name, n in mix[:4]
+        )
+        self.query_one("#model-mix", Static).update(f"models   {mix_text}")
+        self.query_one("#token-line", Static).update(
+            f"tokens   {_compact(stats['outputTokens'])} out"
+            f" · {_compact(stats['cacheReadTokens'])} cache read"
+            f" · {stats['sessions']} sessions across {stats['projects']} projects"
+        )
+
+    def _render_hours(self, sessions: list[Session]) -> None:
+        histogram = _stats.hour_histogram(sessions)
+        plot = self.query_one("#hours", PlotextPlot)
+        plt = plot.plt
+        plt.clear_data()
+        hours = list(range(24))
+        plt.bar(
+            [f"{h:02d}" for h in hours],
+            [histogram.get(h, 0) for h in hours],
+            color=TERRACOTTA_RGB,
+            marker="hd",
+        )
+        plt.title("prompts by local hour")
+        plot.refresh()
+
+
+def run(claude_dir: Path = DEFAULT_CLAUDE_DIR, days: int | None = None) -> None:
+    AbsolutelyApp(claude_dir=claude_dir, days=days).run()

absolutelyright-0.2.0a2.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: absolutelyright
+Version: 0.2.0a2
+Summary: analytics over your claude code session transcripts
+Author-email: zzstoatzz <thrast36@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: analytics,claude,claude-code,cli,transcripts
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: cyclopts>=4.17.0
+Requires-Dist: textual-plotext>=1.0.1
+Requires-Dist: textual>=8.2.7
+Description-Content-Type: text/markdown
+
+# absolutelyright
+
+analytics over your claude code session transcripts.
+
+claude code keeps a jsonl transcript of every session under `~/.claude/projects/`.
+absolutelyright separates what you actually typed from harness noise (tool results,
+slash-command expansions, subagent sidechains) and tells you things like:
+
+- your most-repeated literal prompts (everyone has a "make the PR description not suck")
+- how often you open with `no` / `wait` / `stop` / `actually`
+- where your prompts, interrupts, and output tokens go, per project
+- which tools claude leans on, and what hours you really work
+
+## install
+
+```bash
+uv tool install absolutelyright
+```
+
+## usage
+
+```bash
+absolutelyright report            # the whole picture, human-formatted
+absolutelyright prompts --pretty  # most-repeated literal prompts
+absolutelyright hours --pretty    # prompts by local hour of day
+absolutelyright overview --days 7 # recent only
+```
+
+machine-readable by default — lists are ndjson, single results are one json
+object — so output pipes straight into jq or an agent:
+
+```bash
+absolutelyright projects | jq -r '.project'
+```
+
+note: claude code prunes local transcripts (30 days by default, see
+`cleanupPeriodDays`), so absolutelyright sees a rolling window, not all time.
+
+## library
+
+```python
+from absolutelyright import load_sessions, repeated_prompts
+
+sessions = load_sessions(days=30)
+for text, count in repeated_prompts(sessions, top=10):
+    print(count, text)
+```

absolutelyright-0.2.0a2.dist-info/RECORD

@@ -0,0 +1,10 @@
+absolutelyright/__init__.py,sha256=QpATqoVnZt4baJJ576XvAFsxQhX9yxYmHYDzURbbS0o,544
+absolutelyright/_records.py,sha256=57z8mjYZyElePTPc7uSHwZ7kcy273hg6kXyOfB9JT6s,8130
+absolutelyright/_stats.py,sha256=4_aFoZlXsd54-GHuKKFHBcqptiMZxw2OkPJGeIx7DJ8,5514
+absolutelyright/cli.py,sha256=NCyMPDjA8abjniZFo0RxzTiBRLj73m7Yu52PaDgFcck,5454
+absolutelyright/tui.py,sha256=eFH6ghbaajSNX76nztKHiIXJABNfTWsIAln8V6hh5W8,12243
+absolutelyright-0.2.0a2.dist-info/METADATA,sha256=AU-4nQNJrhFCW8d1y22y8fzwArFs3bBSRBl66BWsncQ,2340
+absolutelyright-0.2.0a2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+absolutelyright-0.2.0a2.dist-info/entry_points.txt,sha256=jA0gLcOeOWQig0whqQG8Iv7Q8Q9TWQsKMOXfkGK9ank,61
+absolutelyright-0.2.0a2.dist-info/licenses/LICENSE,sha256=GCaBhyWUE9SeLzklZVA9BKgh424EOjDzofeP-9_OB-8,1066
+absolutelyright-0.2.0a2.dist-info/RECORD,,

absolutelyright-0.2.0a2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

absolutelyright-0.2.0a2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+absolutelyright = absolutelyright.cli:main

absolutelyright-0.2.0a2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zzstoatzz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.