kiro-usage 0.1.0__tar.gz

kiro_usage-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: kiro-usage
+Version: 0.1.0
+Summary: Track token usage and costs across Kiro CLI sessions
+License-Expression: MIT
+Classifier: Environment :: Console
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# kiro-usage
+
+Track token usage and costs across [Kiro CLI](https://kiro.dev) sessions.
+
+Real-time terminal dashboard with session archiving that persists across `/clear` and restarts.
+
+## Install
+
+```sh
+# install uv if you don't have it
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+uv tool install kiro-usage && kiro-usage install
+```
+
+## Usage
+
+```sh
+kiro-usage              # today's usage, live refresh
+kiro-usage week         # last 7 days
+kiro-usage month        # last 30 days
+kiro-usage all          # all time
+kiro-usage --json       # JSON output
+kiro-usage --no-live    # print once and exit
+```
+
+## Service Management
+
+```sh
+kiro-usage install      # register background archiver (launchd / systemd)
+kiro-usage uninstall    # remove background archiver
+kiro-usage status       # check archiver status
+```
+
+The background archiver watches the Kiro CLI database and snapshots sessions to `~/.kiro_sessions/` every 10 seconds. This ensures session data is preserved even if you `/clear` or quit Kiro CLI.
+
+## How It Works
+
+```
+kiro-cli SQLite DB
+       │
+       │ mtime change (every 10s)
+       ▼
+  kiro-usage-archiver  ──► ~/.kiro_sessions/*.json
+  (launchd / systemd)
+
+  kiro-usage viewer    ◄── ~/.kiro_sessions/*.json
+  (on-demand)
+```
+
+**Metrics:**
+- **CacheWrite** — new tokens per turn (estimated, chars/4)
+- **CacheRead** — prior context resent to API (estimated)
+- **Output** — tokens streamed back (from chunks, accurate)
+- **Cost** — cache-aware pricing estimate (5-min cache write rate)
+
+## Uninstall
+
+```sh
+kiro-usage uninstall
+uv tool uninstall kiro-usage
+```
+
+## License
+
+MIT

kiro_usage-0.1.0/README.md

@@ -0,0 +1,66 @@
+# kiro-usage
+
+Track token usage and costs across [Kiro CLI](https://kiro.dev) sessions.
+
+Real-time terminal dashboard with session archiving that persists across `/clear` and restarts.
+
+## Install
+
+```sh
+# install uv if you don't have it
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+uv tool install kiro-usage && kiro-usage install
+```
+
+## Usage
+
+```sh
+kiro-usage              # today's usage, live refresh
+kiro-usage week         # last 7 days
+kiro-usage month        # last 30 days
+kiro-usage all          # all time
+kiro-usage --json       # JSON output
+kiro-usage --no-live    # print once and exit
+```
+
+## Service Management
+
+```sh
+kiro-usage install      # register background archiver (launchd / systemd)
+kiro-usage uninstall    # remove background archiver
+kiro-usage status       # check archiver status
+```
+
+The background archiver watches the Kiro CLI database and snapshots sessions to `~/.kiro_sessions/` every 10 seconds. This ensures session data is preserved even if you `/clear` or quit Kiro CLI.
+
+## How It Works
+
+```
+kiro-cli SQLite DB
+       │
+       │ mtime change (every 10s)
+       ▼
+  kiro-usage-archiver  ──► ~/.kiro_sessions/*.json
+  (launchd / systemd)
+
+  kiro-usage viewer    ◄── ~/.kiro_sessions/*.json
+  (on-demand)
+```
+
+**Metrics:**
+- **CacheWrite** — new tokens per turn (estimated, chars/4)
+- **CacheRead** — prior context resent to API (estimated)
+- **Output** — tokens streamed back (from chunks, accurate)
+- **Cost** — cache-aware pricing estimate (5-min cache write rate)
+
+## Uninstall
+
+```sh
+kiro-usage uninstall
+uv tool uninstall kiro-usage
+```
+
+## License
+
+MIT

kiro_usage-0.1.0/kiro_usage/__init__.py

@@ -0,0 +1,128 @@
+"""Kiro Usage Tracker — shared constants and utilities."""
+
+import os, re, sqlite3, json, unicodedata, platform
+from pathlib import Path
+
+# ── Platform paths ────────────────────────────────────────────────────────────
+if platform.system() == "Darwin":
+    CLI_DB = Path.home() / "Library/Application Support/kiro-cli/data.sqlite3"
+else:
+    CLI_DB = Path.home() / ".local/share/kiro-cli/data.sqlite3"
+
+SESSIONS_DIR = Path.home() / ".kiro_sessions"
+CHARS_PER_TOKEN = 4
+
+# ── Pricing ($/MTok) — Anthropic 5-min cache write rate ──────────────────────
+PRICING = {
+    "claude-opus-4.6":   (6.25, 0.50, 25),
+    "claude-opus-4.5":   (6.25, 0.50, 25),
+    "claude-opus-4.1":   (18.75, 1.50, 75),
+    "claude-opus-4":     (18.75, 1.50, 75),
+    "claude-sonnet-4.6": (3.75, 0.30, 15),
+    "claude-sonnet-4.5": (3.75, 0.30, 15),
+    "claude-sonnet-4":   (3.75, 0.30, 15),
+}
+DEFAULT_PRICING = (6.25, 0.50, 25)
+
+def price_for(model_id):
+    if not model_id:
+        return DEFAULT_PRICING
+    m = model_id.lower()
+    for prefix, p in PRICING.items():
+        if prefix in m:
+            return p
+    return DEFAULT_PRICING
+
+def calc_cost(cw, cr, out, model_id=None):
+    pw, pr, po = price_for(model_id)
+    return (cw * pw + cr * pr + out * po) / 1_000_000
+
+# ── ANSI ──────────────────────────────────────────────────────────────────────
+C = {
+    "reset": "\033[0m", "bold": "\033[1m", "dim": "\033[2m",
+    "green": "\033[32m", "yellow": "\033[33m", "blue": "\033[34m",
+    "cyan": "\033[36m", "red": "\033[31m", "magenta": "\033[35m",
+    "white": "\033[97m", "gray": "\033[90m",
+    "bg_cyan": "\033[46m", "bg_blue": "\033[44m", "bg_magenta": "\033[45m",
+    "bg_green": "\033[42m", "bg_yellow": "\033[43m", "bg_red": "\033[41m",
+    "underline": "\033[4m",
+}
+NO_COLOR = os.environ.get("NO_COLOR") is not None
+
+def c(text, *styles):
+    if NO_COLOR:
+        return str(text)
+    return "".join(C[s] for s in styles) + str(text) + C["reset"]
+
+def fmt(n):
+    if n >= 1_000_000: return "{:.1f}M".format(n / 1_000_000)
+    if n >= 1_000: return "{:.1f}K".format(n / 1_000)
+    return str(n)
+
+def fmt_cost(v):
+    if v >= 1: return "${:.2f}".format(v)
+    if v >= 0.01: return "${:.3f}".format(v)
+    return "${:.4f}".format(v)
+
+def bar(pct, width=20):
+    filled = int(pct / 100 * width)
+    if pct < 40:
+        return c("━" * filled, "green") + c("╌" * (width - filled), "dim")
+    elif pct < 70:
+        return c("━" * filled, "yellow") + c("╌" * (width - filled), "dim")
+    else:
+        return c("━" * filled, "red") + c("╌" * (width - filled), "dim")
+
+def tw():
+    try: return os.get_terminal_size().columns
+    except: return 80
+
+# ── Box drawing helpers ───────────────────────────────────────────────────────
+_ansi_re = re.compile(r'\033\[[0-9;]*m')
+
+def vlen(s):
+    plain = _ansi_re.sub('', s)
+    w = 0
+    for ch in plain:
+        eaw = unicodedata.east_asian_width(ch)
+        w += 2 if eaw in ('W', 'F') else 1
+    return w
+
+def vrpad(s, width):
+    return s + " " * max(width - vlen(s), 0)
+
+def vlpad(s, width):
+    return " " * max(width - vlen(s), 0) + s
+
+def vpad(s, width):
+    return vrpad(s, width)
+
+def box_top(title, width):
+    inner = width - 2
+    label = " {} ".format(title)
+    lw = vlen(label)
+    left = (inner - lw) // 2
+    right = inner - lw - left
+    return (c("╭", "dim") + c("─" * left, "dim") +
+            c(label, "bold", "cyan") + c("─" * right, "dim") + c("╮", "dim"))
+
+def box_bot(width):
+    return c("╰" + "─" * (width - 2) + "╯", "dim")
+
+def box_sep(width):
+    return c("├" + "─" * (width - 2) + "┤", "dim")
+
+def box_line(content, width):
+    inner = width - 2
+    return c("│", "dim") + vpad(" " + content, inner) + c("│", "dim")
+
+# ── DB ────────────────────────────────────────────────────────────────────────
+def query(db_path, sql, params=()):
+    if not db_path.exists():
+        return []
+    conn = sqlite3.connect("file:{}?mode=ro".format(db_path), uri=True)
+    conn.row_factory = sqlite3.Row
+    try:
+        return conn.execute(sql, params).fetchall()
+    finally:
+        conn.close()

kiro_usage-0.1.0/kiro_usage/archiver.py

@@ -0,0 +1,90 @@
+"""Background archiver — watches Kiro CLI DB and snapshots sessions to disk.
+
+Runs as a persistent background process (launchd on macOS, systemd on Linux).
+Polls the DB file's mtime every 10s and archives any new/updated conversations
+to ~/.kiro_sessions/<conversation_id>.json.
+"""
+
+import json, sys, os, time, signal
+from . import CLI_DB, SESSIONS_DIR, query
+
+def ensure_sessions_dir():
+    SESSIONS_DIR.mkdir(exist_ok=True)
+
+def archive_sessions():
+    """Snapshot all live conversations from the CLI DB into ~/.kiro_sessions/."""
+    ensure_sessions_dir()
+    rows = query(CLI_DB, """
+        SELECT conversation_id, key as cwd, created_at, updated_at, value
+        FROM conversations_v2
+    """)
+    archived = 0
+    for row in rows:
+        path = SESSIONS_DIR / "{}.json".format(row["conversation_id"])
+        if path.exists():
+            try:
+                existing = json.loads(path.read_text())
+                if existing.get("updated_at") >= row["updated_at"]:
+                    continue
+            except (json.JSONDecodeError, KeyError):
+                pass
+        snapshot = {
+            "conversation_id": row["conversation_id"],
+            "cwd": row["cwd"],
+            "created_at": row["created_at"],
+            "updated_at": row["updated_at"],
+            "value": json.loads(row["value"]),
+        }
+        path.write_text(json.dumps(snapshot, separators=(",", ":")))
+        archived += 1
+    return archived
+
+def load_archived_sessions():
+    """Load all snapshots from ~/.kiro_sessions/."""
+    ensure_sessions_dir()
+    sessions = []
+    for path in SESSIONS_DIR.glob("*.json"):
+        try:
+            sessions.append(json.loads(path.read_text()))
+        except (json.JSONDecodeError, OSError):
+            continue
+    return sessions
+
+def _log(msg):
+    sys.stderr.write("[kiro-archiver] {}\n".format(msg))
+    sys.stderr.flush()
+
+def main():
+    """Poll CLI_DB mtime every 10s, archive on change."""
+    running = True
+    def _stop(*_):
+        nonlocal running
+        running = False
+    signal.signal(signal.SIGTERM, _stop)
+    signal.signal(signal.SIGINT, _stop)
+
+    interval = int(os.environ.get("KIRO_ARCHIVE_INTERVAL", "10"))
+    _log("started — watching {} every {}s".format(CLI_DB, interval))
+
+    last_mtime = 0.0
+    while running:
+        try:
+            if CLI_DB.exists():
+                mtime = CLI_DB.stat().st_mtime
+                if mtime != last_mtime:
+                    last_mtime = mtime
+                    n = archive_sessions()
+                    if n:
+                        _log("archived {} session(s)".format(n))
+        except Exception as e:
+            _log("error: {}".format(e))
+        # Sleep in small increments so SIGTERM is responsive
+        for _ in range(interval):
+            if not running:
+                break
+            time.sleep(1)
+
+    _log("stopped")
+
+if __name__ == "__main__":
+    main()

kiro_usage-0.1.0/kiro_usage/service.py

@@ -0,0 +1,164 @@
+"""Service installer — register/unregister the archiver as a background service.
+
+macOS: ~/Library/LaunchAgents/dev.kiro.usage-archiver.plist  (launchctl)
+Linux: ~/.config/systemd/user/kiro-usage-archiver.service    (systemd --user)
+"""
+
+import os, platform, shutil, subprocess, textwrap
+from pathlib import Path
+
+LABEL = "dev.kiro.usage-archiver"
+
+def _find_archiver_bin():
+    """Find the kiro-usage-archiver binary on PATH."""
+    p = shutil.which("kiro-usage-archiver")
+    if p:
+        return p
+    # Fallback: same directory as the current Python interpreter
+    d = Path(os.sys.executable).parent / "kiro-usage-archiver"
+    if d.exists():
+        return str(d)
+    return None
+
+# ── macOS (launchd) ───────────────────────────────────────────────────────────
+def _launchd_plist_path():
+    return Path.home() / "Library/LaunchAgents/{}.plist".format(LABEL)
+
+def _launchd_install():
+    bin_path = _find_archiver_bin()
+    if not bin_path:
+        print("Error: kiro-usage-archiver not found on PATH")
+        return False
+    plist = textwrap.dedent("""\
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+          "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>Label</key>
+            <string>{label}</string>
+            <key>ProgramArguments</key>
+            <array>
+                <string>{bin}</string>
+            </array>
+            <key>RunAtLoad</key>
+            <true/>
+            <key>KeepAlive</key>
+            <true/>
+            <key>StandardErrorPath</key>
+            <string>{log}</string>
+            <key>StandardOutPath</key>
+            <string>{log}</string>
+        </dict>
+        </plist>
+    """).format(
+        label=LABEL,
+        bin=bin_path,
+        log=str(Path.home() / ".kiro_sessions/archiver.log"),
+    )
+    path = _launchd_plist_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # Unload first if already loaded
+    if path.exists():
+        subprocess.run(["launchctl", "bootout", "gui/{}".format(os.getuid()), str(path)],
+                       capture_output=True)
+    path.write_text(plist)
+    r = subprocess.run(["launchctl", "bootstrap", "gui/{}".format(os.getuid()), str(path)],
+                       capture_output=True, text=True)
+    if r.returncode != 0:
+        print("Warning: launchctl bootstrap: {}".format(r.stderr.strip()))
+    return True
+
+def _launchd_uninstall():
+    path = _launchd_plist_path()
+    if not path.exists():
+        print("Not installed.")
+        return False
+    subprocess.run(["launchctl", "bootout", "gui/{}".format(os.getuid()), str(path)],
+                   capture_output=True)
+    path.unlink()
+    return True
+
+# ── Linux (systemd --user) ────────────────────────────────────────────────────
+def _systemd_unit_path():
+    return Path.home() / ".config/systemd/user/kiro-usage-archiver.service"
+
+def _systemd_install():
+    bin_path = _find_archiver_bin()
+    if not bin_path:
+        print("Error: kiro-usage-archiver not found on PATH")
+        return False
+    unit = textwrap.dedent("""\
+        [Unit]
+        Description=Kiro Usage Session Archiver
+
+        [Service]
+        ExecStart={bin}
+        Restart=on-failure
+        RestartSec=5
+
+        [Install]
+        WantedBy=default.target
+    """).format(bin=bin_path)
+    path = _systemd_unit_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(unit)
+    subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+    subprocess.run(["systemctl", "--user", "enable", "--now", "kiro-usage-archiver"],
+                   capture_output=True)
+    return True
+
+def _systemd_uninstall():
+    path = _systemd_unit_path()
+    if not path.exists():
+        print("Not installed.")
+        return False
+    subprocess.run(["systemctl", "--user", "disable", "--now", "kiro-usage-archiver"],
+                   capture_output=True)
+    path.unlink()
+    subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+    return True
+
+# ── Public API ────────────────────────────────────────────────────────────────
+def install():
+    if platform.system() == "Darwin":
+        ok = _launchd_install()
+    else:
+        ok = _systemd_install()
+    if ok:
+        print("✅ Archiver installed and running.")
+        print("   Sessions will be archived to ~/.kiro_sessions/")
+    return ok
+
+def uninstall():
+    if platform.system() == "Darwin":
+        ok = _launchd_uninstall()
+    else:
+        ok = _systemd_uninstall()
+    if ok:
+        print("✅ Archiver uninstalled.")
+    return ok
+
+def status():
+    if platform.system() == "Darwin":
+        path = _launchd_plist_path()
+        if not path.exists():
+            print("Archiver: not installed")
+            return
+        r = subprocess.run(
+            ["launchctl", "print", "gui/{}/{}".format(os.getuid(), LABEL)],
+            capture_output=True, text=True)
+        if r.returncode == 0:
+            # Extract state line
+            for line in r.stdout.splitlines():
+                if "state" in line.lower():
+                    print("Archiver: {}".format(line.strip()))
+                    return
+            print("Archiver: loaded")
+        else:
+            print("Archiver: installed but not running")
+    else:
+        r = subprocess.run(
+            ["systemctl", "--user", "is-active", "kiro-usage-archiver"],
+            capture_output=True, text=True)
+        print("Archiver: {}".format(r.stdout.strip() or "not installed"))

kiro_usage-0.1.0/kiro_usage/viewer.py

@@ -0,0 +1,336 @@
+"""Kiro Usage Tracker — terminal viewer.
+
+Reads archived sessions from ~/.kiro_sessions/ and live DB,
+renders a TUI dashboard with token usage, costs, and session details.
+"""
+
+import json, sys, os, time, signal
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from . import (CLI_DB, SESSIONS_DIR, CHARS_PER_TOKEN, calc_cost, query,
+               c, fmt, fmt_cost, bar, tw,
+               vpad, vlpad, box_top, box_bot, box_sep, box_line)
+from .archiver import archive_sessions, load_archived_sessions
+
+# ── Parse a single conversation snapshot into display-ready stats ─────────────
+def parse_conversation(conv_id, cwd, created_at_ms, updated_at_ms, data):
+    turns = data.get("history", [])
+    totals = {"cw": 0, "cr": 0, "out": 0, "cost": 0.0}
+    cumulative, prev_asst = 0, 0
+    models, tools = set(), []
+    daily = {}
+
+    for i, turn in enumerate(turns):
+        meta = turn.get("request_metadata") or {}
+        user_tok = len(json.dumps(turn.get("user", {}))) // CHARS_PER_TOKEN
+        asst_tok = len(json.dumps(turn.get("assistant", {}))) // CHARS_PER_TOKEN
+        out_tok = len(meta.get("time_between_chunks", []))
+        model = meta.get("model_id")
+
+        cr = cumulative if i > 0 else 0
+        cw = user_tok + (prev_asst if i > 0 else 0)
+        tc = calc_cost(cw, cr, out_tok, model)
+
+        totals["cw"] += cw; totals["cr"] += cr
+        totals["out"] += out_tok; totals["cost"] += tc
+        cumulative += user_tok + asst_tok
+        prev_asst = asst_tok
+
+        if model:
+            models.add(model)
+        for t in meta.get("tool_use_ids_and_names", []):
+            if len(t) > 1:
+                tools.append(t[1])
+
+        ts_ms = meta.get("request_start_timestamp_ms")
+        if ts_ms:
+            day = datetime.fromtimestamp(ts_ms / 1000).strftime("%Y-%m-%d")
+            if day not in daily:
+                daily[day] = {"cw": 0, "cr": 0, "out": 0, "cost": 0.0, "reqs": 0}
+            daily[day]["cw"] += cw; daily[day]["cr"] += cr
+            daily[day]["out"] += out_tok; daily[day]["cost"] += tc
+            daily[day]["reqs"] += 1
+
+    return {
+        "id": conv_id[:8], "full_id": conv_id, "cwd": cwd,
+        "created": datetime.fromtimestamp(created_at_ms / 1000),
+        "updated": datetime.fromtimestamp(updated_at_ms / 1000),
+        "turns": len(turns), **totals,
+        "models": models, "tools": tools, "daily": daily,
+    }
+
+# ── Load all sessions (live DB + archive), deduplicated ───────────────────────
+def load_all_sessions(days=None):
+    cutoff_ms = None
+    if days and days < 9000:
+        cutoff_ms = int((datetime.now() - timedelta(days=days)).timestamp() * 1000)
+
+    archive_sessions()
+    seen = {}
+
+    for snap in load_archived_sessions():
+        if cutoff_ms and snap["updated_at"] < cutoff_ms:
+            continue
+        try:
+            seen[snap["conversation_id"]] = parse_conversation(
+                snap["conversation_id"], snap["cwd"],
+                snap["created_at"], snap["updated_at"], snap["value"])
+        except Exception:
+            continue
+
+    for row in query(CLI_DB, "SELECT conversation_id, key as cwd, created_at, updated_at, value FROM conversations_v2 ORDER BY updated_at DESC"):
+        if cutoff_ms and row["updated_at"] < cutoff_ms:
+            continue
+        try:
+            data = json.loads(row["value"])
+        except Exception:
+            continue
+        seen[row["conversation_id"]] = parse_conversation(
+            row["conversation_id"], row["cwd"],
+            row["created_at"], row["updated_at"], data)
+
+    return sorted(seen.values(), key=lambda x: x["updated"], reverse=True)
+
+# ── Render ────────────────────────────────────────────────────────────────────
+def render(days):
+    cli_convos = load_all_sessions(days)
+    w = min(tw(), 120)
+    L = []
+    now = datetime.now().strftime("%H:%M:%S")
+    label = "all time" if days > 9000 else "last {} day{}".format(days, "s" if days != 1 else "")
+
+    L.append("")
+    L.append("  " + c("Kiro Usage Tracker", "bold", "cyan") +
+             "   " + c("{}  {}".format(label, now), "dim"))
+    L.append("")
+
+    L.append(box_top("Terminal", w))
+    if cli_convos:
+        t_cw   = sum(cv["cw"]   for cv in cli_convos)
+        t_cr   = sum(cv["cr"]   for cv in cli_convos)
+        t_out  = sum(cv["out"]  for cv in cli_convos)
+        t_cost = sum(cv["cost"] for cv in cli_convos)
+        t_reqs = sum(cv["turns"] for cv in cli_convos)
+        all_models = set()
+        for cv in cli_convos:
+            all_models.update(cv["models"])
+
+        L.append(box_line(
+            "{} reqs  CWrite {}  CRead {}  Output {}  Cost {}".format(
+                c(t_reqs, "bold", "white"), c(fmt(t_cw), "green"),
+                c(fmt(t_cr), "yellow"), c(fmt(t_out), "blue"),
+                c(fmt_cost(t_cost), "red", "bold")), w))
+        if all_models:
+            L.append(box_line(
+                "Models: " + "  ".join(c(m, "magenta") for m in sorted(all_models)), w))
+
+        # Daily breakdown
+        cli_daily = {}
+        for cv in cli_convos:
+            for d, v in cv["daily"].items():
+                if d not in cli_daily:
+                    cli_daily[d] = {"cw": 0, "cr": 0, "out": 0, "cost": 0.0, "reqs": 0}
+                for k in ("cw", "cr", "out", "cost", "reqs"):
+                    cli_daily[d][k] += v[k]
+
+        if cli_daily:
+            L.append(box_sep(w))
+            max_r = max(v["reqs"] for v in cli_daily.values())
+            hdr = "{} {:>5} {:>8} {:>8} {:>7} {:>8}  {}".format(
+                vpad("Date", 12), "Reqs", "CWrite", "CRead", "Output", "Cost", "Activity")
+            L.append(box_line(c(hdr, "dim"), w))
+
+            for d in sorted(cli_daily.keys(), reverse=True):
+                v = cli_daily[d]
+                pct = v["reqs"] / max_r * 100 if max_r else 0
+                is_today = d == datetime.now().strftime("%Y-%m-%d")
+                day_c  = c(d, "bold", "white") if is_today else c(d, "dim")
+                marker = c("> ", "cyan") if is_today else "  "
+                reqs_c = c(str(v["reqs"]), "bold") if is_today else str(v["reqs"])
+                cost_c = c(fmt_cost(v["cost"]), "red") if v["cost"] >= 0.1 else fmt_cost(v["cost"])
+                line = "{}{} {} {} {} {} {}  {}".format(
+                    marker, vpad(day_c, 10), vlpad(reqs_c, 5),
+                    vlpad(fmt(v["cw"]), 8), vlpad(fmt(v["cr"]), 8),
+                    vlpad(fmt(v["out"]), 7), vlpad(cost_c, 8), bar(pct))
+                L.append(box_line(line, w))
+
+        # Tool usage
+        all_tools = {}
+        for cv in cli_convos:
+            for t in cv["tools"]:
+                all_tools[t] = all_tools.get(t, 0) + 1
+        if all_tools:
+            L.append(box_sep(w))
+            top = sorted(all_tools.items(), key=lambda x: -x[1])[:6]
+            inner = w - 4
+            parts, cur = [], 7
+            for n, cnt in top:
+                part = "{}{}{}".format(c(n, "cyan"), c("x", "dim"), c(cnt, "bold"))
+                plen = len(n) + 1 + len(str(cnt))
+                if cur + plen + 2 > inner:
+                    break
+                parts.append(part)
+                cur += plen + 2
+            L.append(box_line("Tools: " + "  ".join(parts), w))
+
+        # Sessions
+        L.append(box_sep(w))
+        shdr = "{} {} {:>5} {:>7} {:>7} {:>6} {:>6} {}".format(
+            vpad("ID", 8), vpad("Directory", 18),
+            "Turns", "CWrite", "CRead", "Out", "Cost", "Updated")
+        L.append(box_line(c(shdr, "dim"), w))
+
+        for cv in cli_convos:
+            cwd = cv["cwd"].replace(str(Path.home()), "~")
+            if len(cwd) > 17:
+                cwd = ".." + cwd[-15:]
+            age = datetime.now() - cv["updated"]
+            if age < timedelta(hours=1):
+                dot, ts = c("*", "green"), cv["updated"].strftime("%H:%M")
+            elif age < timedelta(hours=6):
+                dot, ts = c("*", "yellow"), cv["updated"].strftime("%H:%M")
+            else:
+                dot, ts = c(".", "dim"), cv["updated"].strftime("%m-%d %H:%M")
+            updated = vpad("{} {}".format(dot, ts), 13)
+            line = "{} {} {:>5} {:>7} {:>7} {:>6} {:>6} {}".format(
+                vpad(c(cv["id"], "cyan"), 8), vpad(cwd, 18), cv["turns"],
+                fmt(cv["cw"]), fmt(cv["cr"]), fmt(cv["out"]),
+                fmt_cost(cv["cost"]), updated)
+            L.append(box_line(line, w))
+    else:
+        L.append(box_line(c("No CLI data found.", "dim"), w))
+
+    L.append(box_bot(w))
+    L.append("  " + c(
+        "📁 Sessions archived to ~/.kiro_sessions/ — history persists across /clear and restarts",
+        "dim", "green"))
+    L.append("")
+    return "\n".join(L)
+
+# ── Modes ─────────────────────────────────────────────────────────────────────
+def _clear():
+    sys.stdout.write("\033[2J\033[H"); sys.stdout.flush()
+
+def live(days, interval=5):
+    signal.signal(signal.SIGINT, lambda *_: (sys.stdout.write("\033[?25h\n"), sys.exit(0)))
+    sys.stdout.write("\033[?25l")
+    try:
+        while True:
+            _clear()
+            print(render(days))
+            print(c("  ⏸  Ctrl+C to exit  │  🔄 refreshing every {}s".format(interval), "dim"))
+            time.sleep(interval)
+    finally:
+        sys.stdout.write("\033[?25h")
+
+def view_json(days):
+    cli_convos = load_all_sessions(days)
+    out = {"cli": {"daily": {}, "sessions": []}}
+    for cv in cli_convos:
+        for d, v in cv["daily"].items():
+            if d not in out["cli"]["daily"]:
+                out["cli"]["daily"][d] = {
+                    "requests": 0, "cache_write_est": 0,
+                    "cache_read_est": 0, "output_tokens": 0, "cost_est_usd": 0.0,
+                }
+            for k, jk in [("reqs", "requests"), ("cw", "cache_write_est"),
+                           ("cr", "cache_read_est"), ("out", "output_tokens"),
+                           ("cost", "cost_est_usd")]:
+                out["cli"]["daily"][d][jk] += v[k]
+        out["cli"]["sessions"].append({
+            "id": cv["id"], "cwd": cv["cwd"], "turns": cv["turns"],
+            "cache_write_est": cv["cw"], "cache_read_est": cv["cr"],
+            "output_tokens": cv["out"], "cost_est_usd": round(cv["cost"], 4),
+            "models": list(cv["models"]),
+            "created": cv["created"].isoformat(),
+            "updated": cv["updated"].isoformat(),
+        })
+    for d in out["cli"]["daily"]:
+        out["cli"]["daily"][d]["cost_est_usd"] = round(
+            out["cli"]["daily"][d]["cost_est_usd"], 4)
+    print(json.dumps(out, indent=2))
+
+# ── CLI entry point ───────────────────────────────────────────────────────────
+PERIODS = {"today": 1, "week": 7, "month": 30, "all": 9999}
+
+def main():
+    from . import service
+
+    args = sys.argv[1:]
+    as_json = "--json" in args
+    if as_json:
+        args.remove("--json")
+    no_live = "--no-live" in args
+    if no_live:
+        args.remove("--no-live")
+    cmd = args[0] if args else "today"
+
+    # Service management subcommands
+    if cmd == "install":
+        service.install()
+        return
+    if cmd == "uninstall":
+        service.uninstall()
+        return
+    if cmd == "status":
+        service.status()
+        return
+
+    if cmd in ("help", "-h", "--help"):
+        print("""
+  {} {}
+
+  {} kiro-usage [command] [flags]
+
+  {}
+    today     Last 24 hours (default, live refresh)
+    week      Last 7 days
+    month     Last 30 days
+    all       All time
+    install   Register background archiver as a system service
+    uninstall Remove background archiver service
+    status    Show archiver service status
+
+  {}
+    --json      JSON output (no live mode)
+    --no-live   Print once and exit
+
+  {} (CLI only)
+    ✏️  CacheWrite  = new tokens per turn (estimated, chars/4)
+    📖 CacheRead   = prior context resent to API (estimated)
+    📤 Output      = tokens streamed back (from chunks, accurate)
+    💰 Cost        = cache-aware pricing estimate
+
+  {} (5-min cache write rate)
+    Model              CWrite    CRead    Output
+    claude-opus-4.6    $6.25     $0.50    $25/MTok
+    claude-opus-4.5    $6.25     $0.50    $25/MTok
+    claude-opus-4.1    $18.75    $1.50    $75/MTok
+    claude-sonnet-4.x  $3.75     $0.30    $15/MTok
+
+  {} 📂
+    CLI DB:   {}
+    Archive:  {}
+""".format(
+            c("⚡", "yellow"), c("Kiro Usage Tracker", "bold", "cyan"),
+            c("Usage:", "bold"), c("📋 Commands:", "bold"),
+            c("🚩 Flags:", "bold"), c("📊 Metrics:", "bold"),
+            c("💲 Pricing $/MTok:", "bold"),
+            c("Data sources:", "dim"), CLI_DB, SESSIONS_DIR))
+        return
+
+    period = PERIODS.get(cmd)
+    if period is None:
+        print("Unknown command: " + cmd)
+        sys.exit(1)
+
+    if as_json:
+        view_json(period)
+    elif no_live or not sys.stdout.isatty():
+        print(render(period))
+    else:
+        live(period)
+
+if __name__ == "__main__":
+    main()

kiro_usage-0.1.0/kiro_usage.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: kiro-usage
+Version: 0.1.0
+Summary: Track token usage and costs across Kiro CLI sessions
+License-Expression: MIT
+Classifier: Environment :: Console
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# kiro-usage
+
+Track token usage and costs across [Kiro CLI](https://kiro.dev) sessions.
+
+Real-time terminal dashboard with session archiving that persists across `/clear` and restarts.
+
+## Install
+
+```sh
+# install uv if you don't have it
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+uv tool install kiro-usage && kiro-usage install
+```
+
+## Usage
+
+```sh
+kiro-usage              # today's usage, live refresh
+kiro-usage week         # last 7 days
+kiro-usage month        # last 30 days
+kiro-usage all          # all time
+kiro-usage --json       # JSON output
+kiro-usage --no-live    # print once and exit
+```
+
+## Service Management
+
+```sh
+kiro-usage install      # register background archiver (launchd / systemd)
+kiro-usage uninstall    # remove background archiver
+kiro-usage status       # check archiver status
+```
+
+The background archiver watches the Kiro CLI database and snapshots sessions to `~/.kiro_sessions/` every 10 seconds. This ensures session data is preserved even if you `/clear` or quit Kiro CLI.
+
+## How It Works
+
+```
+kiro-cli SQLite DB
+       │
+       │ mtime change (every 10s)
+       ▼
+  kiro-usage-archiver  ──► ~/.kiro_sessions/*.json
+  (launchd / systemd)
+
+  kiro-usage viewer    ◄── ~/.kiro_sessions/*.json
+  (on-demand)
+```
+
+**Metrics:**
+- **CacheWrite** — new tokens per turn (estimated, chars/4)
+- **CacheRead** — prior context resent to API (estimated)
+- **Output** — tokens streamed back (from chunks, accurate)
+- **Cost** — cache-aware pricing estimate (5-min cache write rate)
+
+## Uninstall
+
+```sh
+kiro-usage uninstall
+uv tool uninstall kiro-usage
+```
+
+## License
+
+MIT

kiro_usage-0.1.0/kiro_usage.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+kiro_usage/__init__.py
+kiro_usage/archiver.py
+kiro_usage/service.py
+kiro_usage/viewer.py
+kiro_usage.egg-info/PKG-INFO
+kiro_usage.egg-info/SOURCES.txt
+kiro_usage.egg-info/dependency_links.txt
+kiro_usage.egg-info/entry_points.txt
+kiro_usage.egg-info/top_level.txt

kiro_usage-0.1.0/kiro_usage.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kiro_usage-0.1.0/kiro_usage.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+kiro-usage = kiro_usage.viewer:main
+kiro-usage-archiver = kiro_usage.archiver:main

kiro_usage-0.1.0/kiro_usage.egg-info/top_level.txt

@@ -0,0 +1 @@
+kiro_usage

kiro_usage-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kiro-usage"
+version = "0.1.0"
+description = "Track token usage and costs across Kiro CLI sessions"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+classifiers = [
+    "Environment :: Console",
+    "Topic :: Utilities",
+    "Programming Language :: Python :: 3",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+]
+
+[project.scripts]
+kiro-usage = "kiro_usage.viewer:main"
+kiro-usage-archiver = "kiro_usage.archiver:main"
+
+[tool.setuptools.packages.find]
+include = ["kiro_usage*"]

kiro_usage-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+