claude-code-tracker 1.2.4 → 1.4.0-beta.4

package/src/patch-durations.py

@@ -1,24 +1,25 @@
 #!/usr/bin/env python3
 """
-Patch duration_seconds for per-turn entries that have duration 0,
-and migrate old single-entry-per-session entries to per-turn format.
+Patch duration_seconds for per-turn entries that have duration 0.
 
 Usage:
   python3 patch-durations.py <project_root>
 """
-import sys, json, os, glob
+import sys, json, os
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+import storage
+
 from datetime import datetime
 
 project_root = os.path.abspath(sys.argv[1])
 tracking_dir = os.path.join(project_root, ".claude", "tracking")
-tokens_file = os.path.join(tracking_dir, "tokens.json")
 
 slug = project_root.replace("/", "-")
 transcripts_dir = os.path.expanduser("~/.claude/projects/" + slug)
-project_name = os.path.basename(project_root)
 
-with open(tokens_file) as f:
-    data = json.load(f)
+data = storage.get_all_turns(tracking_dir)
 
 def parse_transcript(jf):
     msgs = []
@@ -26,7 +27,7 @@ def parse_transcript(jf):
     model = "unknown"
     first_ts = None
     try:
-        with open(jf) as f:
+        with open(jf, encoding='utf-8') as f:
             for line in f:
                 try:
                     obj = json.loads(line)
@@ -52,15 +53,9 @@ def parse_transcript(jf):
         pass
     return msgs, usages, model, first_ts
 
-# Separate old-format (no turn_index) from new-format entries
-old_entries = [e for e in data if "turn_index" not in e]
-new_entries = [e for e in data if "turn_index" in e]
-
-# For new-format entries with duration 0, patch from transcript
-existing_keys = {(e.get("session_id"), e.get("turn_index")): i for i, e in enumerate(new_entries)}
 patched = 0
 
-for entry in new_entries:
+for entry in data:
     if entry.get("duration_seconds", 0) > 0:
         continue
     sid = entry.get("session_id")
@@ -85,7 +80,7 @@ for entry in new_entries:
                     t1 = datetime.fromisoformat(msgs[j][1].replace("Z", "+00:00"))
                     duration = max(0, int((t1 - t0).total_seconds()))
                     if duration > 0:
-                        entry["duration_seconds"] = duration
+                        storage.patch_turn_duration(tracking_dir, sid, turn_index, duration)
                         patched += 1
                         print(f"  patched {sid[:8]}#{turn_index}  {duration}s")
                 except Exception:
@@ -99,103 +94,8 @@ for entry in new_entries:
         else:
             i += 1
 
-# Migrate old-format entries to per-turn
-migrated_sessions = 0
-new_turn_entries = []
-for old_entry in old_entries:
-    sid = old_entry.get("session_id")
-    if not sid:
-        continue
-    jf = os.path.join(transcripts_dir, sid + ".jsonl")
-    if not os.path.exists(jf):
-        # Keep old entry as-is if we can't reprocess
-        new_entries.append(old_entry)
-        continue
-
-    msgs, usages, model, first_ts = parse_transcript(jf)
-
-    turn_index = 0
-    usage_index = 0
-    i = 0
-    session_date = old_entry.get("date")
-
-    while i < len(msgs):
-        if msgs[i][0] == "user":
-            user_ts = msgs[i][1]
-            j = i + 1
-            while j < len(msgs) and msgs[j][0] != "assistant":
-                j += 1
-            if j < len(msgs):
-                asst_ts = msgs[j][1]
-                usage = {}
-                if usage_index < len(usages):
-                    usage = usages[usage_index]
-                    usage_index += 1
-
-                inp = usage.get("input_tokens", 0)
-                out = usage.get("output_tokens", 0)
-                cache_create = usage.get("cache_creation_input_tokens", 0)
-                cache_read = usage.get("cache_read_input_tokens", 0)
-                total = inp + cache_create + cache_read + out
-
-                if total > 0:
-                    duration = 0
-                    try:
-                        t0 = datetime.fromisoformat(user_ts.replace("Z", "+00:00"))
-                        t1 = datetime.fromisoformat(asst_ts.replace("Z", "+00:00"))
-                        duration = max(0, int((t1 - t0).total_seconds()))
-                    except Exception:
-                        pass
-
-                    if "opus" in model:
-                        cost = inp * 15 / 1e6 + cache_create * 18.75 / 1e6 + cache_read * 1.50 / 1e6 + out * 75 / 1e6
-                    else:
-                        cost = inp * 3 / 1e6 + cache_create * 3.75 / 1e6 + cache_read * 0.30 / 1e6 + out * 15 / 1e6
-
-                    try:
-                        turn_ts = datetime.fromisoformat(user_ts.replace("Z", "+00:00")).strftime("%Y-%m-%dT%H:%M:%SZ")
-                        turn_date = datetime.fromisoformat(user_ts.replace("Z", "+00:00")).strftime("%Y-%m-%d")
-                    except Exception:
-                        turn_ts = user_ts
-                        turn_date = session_date
-
-                    new_turn_entries.append({
-                        "date": turn_date,
-                        "project": project_name,
-                        "session_id": sid,
-                        "turn_index": turn_index,
-                        "turn_timestamp": turn_ts,
-                        "input_tokens": inp,
-                        "cache_creation_tokens": cache_create,
-                        "cache_read_tokens": cache_read,
-                        "output_tokens": out,
-                        "total_tokens": total,
-                        "estimated_cost_usd": round(cost, 4),
-                        "model": model,
-                        "duration_seconds": duration,
-                    })
-                turn_index += 1
-                i = j + 1
-            else:
-                i += 1
-        else:
-            i += 1
-
-    if turn_index > 0:
-        migrated_sessions += 1
-        print(f"  migrated {sid[:8]}  {turn_index} turn(s)")
-    else:
-        new_entries.append(old_entry)
-
-new_entries.extend(new_turn_entries)
-new_entries.sort(key=lambda x: (x.get("date", ""), x.get("session_id", ""), x.get("turn_index", 0)))
-
-if patched > 0 or migrated_sessions > 0:
-    with open(tokens_file, "w") as f:
-        json.dump(new_entries, f, indent=2)
-        f.write("\n")
-    script_dir = os.path.dirname(os.path.abspath(__file__))
+if patched > 0:
     charts_html = os.path.join(tracking_dir, "charts.html")
-    os.system(f'python3 "{script_dir}/generate-charts.py" "{tokens_file}" "{charts_html}" 2>/dev/null')
+    os.system(f'python3 "{SCRIPT_DIR}/generate-charts.py" "{tracking_dir}" "{charts_html}" 2>/dev/null')
 
-print(f"{patched} turn(s) patched, {migrated_sessions} session(s) migrated to per-turn format.")
+print(f"{patched} turn(s) patched.")

package/src/platform_utils.py

@@ -0,0 +1,36 @@
+"""Cross-platform utility helpers for claude-tracker."""
+import os
+import sys
+import subprocess
+
+def get_transcripts_dir():
+    """Return the Claude transcripts directory for the current platform."""
+    if sys.platform == 'win32':
+        appdata = os.environ.get('APPDATA', '')
+        return os.path.join(appdata, 'Claude', 'claude_code', 'transcripts')
+    elif sys.platform == 'darwin':
+        home = os.path.expanduser('~')
+        return os.path.join(home, 'Library', 'Application Support', 'Claude', 'claude_code', 'transcripts')
+    else:
+        home = os.path.expanduser('~')
+        return os.path.join(home, '.config', 'Claude', 'claude_code', 'transcripts')
+
+def slugify_path(path):
+    """Convert an absolute path to a slug suitable for use as a directory name.
+    Handles Windows drive letters and backslashes."""
+    # Normalize separators
+    slug = path.replace('\\', '/').replace('/', '-')
+    # Remove drive letter colon on Windows (e.g. C: -> C)
+    slug = slug.replace(':', '')
+    # Strip leading/trailing dashes
+    slug = slug.strip('-')
+    return slug
+
+def open_file(path):
+    """Open a file with the default system application."""
+    if sys.platform == 'win32':
+        os.startfile(path)
+    elif sys.platform == 'darwin':
+        subprocess.run(['open', path])
+    else:
+        subprocess.run(['xdg-open', path])

package/src/stop-hook.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+'use strict';
+const { execFileSync, spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const scriptDir = path.dirname(path.resolve(__filename));
+const bashScript = path.join(scriptDir, 'stop-hook.sh');
+
+// On Windows, run via bash (Git Bash / WSL); on Unix, run directly
+const input = fs.readFileSync(process.stdin.fd, 'utf8');
+
+if (process.platform === 'win32') {
+  const result = spawnSync('bash', [bashScript], {
+    input,
+    stdio: ['pipe', 'inherit', 'inherit'],
+    shell: false,
+  });
+  process.exit(result.status || 0);
+} else {
+  const result = spawnSync('bash', [bashScript], {
+    input,
+    stdio: ['pipe', 'inherit', 'inherit'],
+  });
+  process.exit(result.status || 0);
+}

package/src/stop-hook.sh

@@ -50,161 +50,33 @@ if [[ ! -d "$TRACKING_DIR" ]]; then
   python3 "$SCRIPT_DIR/backfill.py" "$PROJECT_ROOT" 2>/dev/null || true
 fi
 
-# Parse token usage from JSONL — emit one entry per turn, upsert into tokens.json
-python3 - "$TRANSCRIPT" "$TRACKING_DIR/tokens.json" "$SESSION_ID" "$(basename "$PROJECT_ROOT")" <<'PYEOF'
-import sys, json, os
-from datetime import datetime, date
-
-transcript_path = sys.argv[1]
-tokens_file = sys.argv[2]
-session_id = sys.argv[3]
-project_name = sys.argv[4]
-
-msgs = []       # (role, timestamp)
-usages = []     # usage dicts from assistant messages, in order
-model = "unknown"
-
-with open(transcript_path) as f:
-    for line in f:
-        try:
-            obj = json.loads(line)
-            t = obj.get('type')
-            ts = obj.get('timestamp')
-            if t == 'user' and not obj.get('isSidechain') and ts:
-                msgs.append(('user', ts))
-            elif t == 'assistant' and ts:
-                msgs.append(('assistant', ts))
-            msg = obj.get('message', {})
-            if isinstance(msg, dict) and msg.get('role') == 'assistant':
-                usage = msg.get('usage', {})
-                if usage:
-                    usages.append(usage)
-                m = msg.get('model', '')
-                if m:
-                    model = m
-        except:
-            pass
-
-# Build per-turn entries
-turn_entries = []
-turn_index = 0
-usage_index = 0
-i = 0
-while i < len(msgs):
-    if msgs[i][0] == 'user':
-        user_ts = msgs[i][1]
-        j = i + 1
-        while j < len(msgs) and msgs[j][0] != 'assistant':
-            j += 1
-        if j < len(msgs):
-            asst_ts = msgs[j][1]
-            usage = {}
-            if usage_index < len(usages):
-                usage = usages[usage_index]
-                usage_index += 1
-
-            inp = usage.get('input_tokens', 0)
-            out = usage.get('output_tokens', 0)
-            cache_create = usage.get('cache_creation_input_tokens', 0)
-            cache_read = usage.get('cache_read_input_tokens', 0)
-            total = inp + cache_create + cache_read + out
-
-            if total > 0:
-                duration = 0
-                try:
-                    t0 = datetime.fromisoformat(user_ts.replace('Z', '+00:00'))
-                    t1 = datetime.fromisoformat(asst_ts.replace('Z', '+00:00'))
-                    duration = max(0, int((t1 - t0).total_seconds()))
-                except:
-                    pass
-
-                if 'opus' in model:
-                    cost = inp * 15 / 1e6 + cache_create * 18.75 / 1e6 + cache_read * 1.50 / 1e6 + out * 75 / 1e6
-                else:
-                    cost = inp * 3 / 1e6 + cache_create * 3.75 / 1e6 + cache_read * 0.30 / 1e6 + out * 15 / 1e6
-
-                try:
-                    turn_ts = datetime.fromisoformat(user_ts.replace('Z', '+00:00')).strftime('%Y-%m-%dT%H:%M:%SZ')
-                    turn_date = datetime.fromisoformat(user_ts.replace('Z', '+00:00')).strftime('%Y-%m-%d')
-                except:
-                    turn_ts = user_ts
-                    turn_date = date.today().isoformat()
-
-                turn_entries.append({
-                    'date': turn_date,
-                    'project': project_name,
-                    'session_id': session_id,
-                    'turn_index': turn_index,
-                    'turn_timestamp': turn_ts,
-                    'input_tokens': inp,
-                    'cache_creation_tokens': cache_create,
-                    'cache_read_tokens': cache_read,
-                    'output_tokens': out,
-                    'total_tokens': total,
-                    'estimated_cost_usd': round(cost, 4),
-                    'model': model,
-                    'duration_seconds': duration,
-                })
-            turn_index += 1
-            i = j + 1
-        else:
-            i += 1
-    else:
-        i += 1
-
-if not turn_entries:
-    sys.exit(0)
-
-# Load existing data
-data = []
-if os.path.exists(tokens_file):
-    try:
-        with open(tokens_file) as f:
-            data = json.load(f)
-    except:
-        data = []
-
-# Build index of existing (session_id, turn_index) -> position
-existing_idx = {}
-for pos, e in enumerate(data):
-    key = (e.get('session_id'), e.get('turn_index'))
-    existing_idx[key] = pos
-
-# Check if anything actually changed
-changed = False
-for entry in turn_entries:
-    key = (entry['session_id'], entry['turn_index'])
-    if key not in existing_idx:
-        changed = True
-        break
-    existing = data[existing_idx[key]]
-    if (existing.get('total_tokens') != entry['total_tokens'] or
-        existing.get('output_tokens') != entry['output_tokens']):
-        changed = True
-        break
-
-if not changed:
-    sys.exit(0)
-
-# Upsert: update existing entries or append new ones
-for entry in turn_entries:
-    key = (entry['session_id'], entry['turn_index'])
-    if key in existing_idx:
-        data[existing_idx[key]] = entry
-    else:
-        data.append(entry)
-        existing_idx[key] = len(data) - 1
-
-# Sort by (date, session_id, turn_index)
-data.sort(key=lambda x: (x.get('date', ''), x.get('session_id', ''), x.get('turn_index', 0)))
-
-with open(tokens_file, 'w') as f:
-    json.dump(data, f, indent=2)
-    f.write('\n')
-PYEOF
+# Parse token usage from JSONL and write to SQLite
+python3 "$SCRIPT_DIR/write-turns.py" "$TRANSCRIPT" "$TRACKING_DIR" "$SESSION_ID" "$(basename "$PROJECT_ROOT")"
+
+# Parse friction events from JSONL
+python3 "$SCRIPT_DIR/parse_friction.py" "$TRANSCRIPT" "$TRACKING_DIR" \
+  "$SESSION_ID" "$(basename "$PROJECT_ROOT")" "main" 2>/dev/null || true
+
+# Parse skill invocations from JSONL
+python3 "$SCRIPT_DIR/parse_skills.py" "$TRANSCRIPT" "$TRACKING_DIR" \
+  "$SESSION_ID" "$(basename "$PROJECT_ROOT")" 2>/dev/null || true
+
+# Parse context compaction events from JSONL
+python3 "$SCRIPT_DIR/parse_compactions.py" "$TRANSCRIPT" "$TRACKING_DIR" \
+  "$SESSION_ID" "$(basename "$PROJECT_ROOT")" 2>/dev/null || true
 
 # Regenerate charts
-python3 "$SCRIPT_DIR/generate-charts.py" "$TRACKING_DIR/tokens.json" "$TRACKING_DIR/charts.html" 2>/dev/null || true
+python3 "$SCRIPT_DIR/generate-charts.py" "$TRACKING_DIR" "$TRACKING_DIR/charts.html" 2>/dev/null || true
+
+# Regenerate key-prompts index + shadow to OpenMemory
+OM_DB="$HOME/.claude/.claude/openmemory.sqlite"
+LEARNINGS="$HOME/.claude/tool-learnings.md"
+OM_ARGS=""
+if [[ -f "$OM_DB" ]]; then
+  OM_ARGS="--om-db $OM_DB"
+  if [[ -f "$LEARNINGS" ]]; then
+    OM_ARGS="$OM_ARGS --learnings $LEARNINGS"
+  fi
+fi
+python3 "$SCRIPT_DIR/update-prompts-index.py" "$TRACKING_DIR" $OM_ARGS 2>/dev/null || true
 
-# Regenerate key-prompts index
-python3 "$SCRIPT_DIR/update-prompts-index.py" "$TRACKING_DIR" 2>/dev/null || true