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

package/src/init-templates.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""Cross-platform replacement for init-templates.sh."""
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import storage  # noqa: E402
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(f"Usage: {sys.argv[0]} <tracking_dir>", file=sys.stderr)
+        sys.exit(1)
+
+    tracking_dir = sys.argv[1]
+    os.makedirs(tracking_dir, exist_ok=True)
+
+    # Initialize SQLite database (replaces tokens.json / agents.json)
+    storage.init_db(tracking_dir)
+
+    # Create key-prompts directory
+    key_prompts_dir = os.path.join(tracking_dir, 'key-prompts')
+    os.makedirs(key_prompts_dir, exist_ok=True)
+
+if __name__ == '__main__':
+    main()

package/src/init-templates.sh

@@ -1,12 +1,12 @@
 #!/usr/bin/env bash
 set -euo pipefail
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 TRACKING_DIR="$1"
 mkdir -p "$TRACKING_DIR"
 mkdir -p "$TRACKING_DIR/key-prompts"
 
-cat > "$TRACKING_DIR/tokens.json" <<'EOF'
-[]
-EOF
+# Initialize SQLite database (replaces tokens.json / agents.json)
+python3 "$SCRIPT_DIR/storage.py" --init "$TRACKING_DIR"
 
 cat > "$TRACKING_DIR/key-prompts.md" <<'EOF'
 # Prompt Journal

package/src/parse_friction.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+"""
+Parse friction events from Claude Code JSONL transcripts.
+
+Usage:
+  python3 parse_friction.py <transcript_path> <friction_file> <session_id> <project> <source> \
+    [--agent-type TYPE] [--agent-id ID]
+
+Friction categories (priority order, first match wins):
+  permission_denied, hook_blocked, cascade_error, command_failed, tool_error, correction, retry
+"""
+import sys, json, os, argparse
+
+
+def parse_friction(transcript_path, session_id, project, source,
+                   agent_type=None, agent_id=None):
+    """Parse a JSONL transcript and return a list of friction event dicts."""
+    events = []
+    pending_tools = {}       # tool_use_id -> {name, turn_index, timestamp}
+    last_error_by_tool = {}  # tool_name -> tool_use_id of last errored call
+    skill_stack = []         # [(tool_use_id, skill_name)]
+
+    msgs = []  # (role, timestamp, is_sidechain, user_type)
+    lines = [] # raw parsed objects
+    model = "unknown"
+
+    with open(transcript_path, encoding='utf-8') as f:
+        for line in f:
+            try:
+                obj = json.loads(line)
+                lines.append(obj)
+                t = obj.get('type')
+                ts = obj.get('timestamp')
+                if t == 'user' and ts:
+                    msgs.append(('user', ts, obj.get('isSidechain', False),
+                                 obj.get('userType')))
+                elif t == 'assistant' and ts:
+                    msgs.append(('assistant', ts, False, None))
+                msg = obj.get('message', {})
+                if isinstance(msg, dict) and msg.get('role') == 'assistant':
+                    m = msg.get('model', '')
+                    if m:
+                        model = m
+            except Exception:
+                pass
+
+    # Build turn boundaries: user (non-sidechain) -> next assistant
+    turn_boundaries = []  # [(user_msg_idx, asst_msg_idx)]
+    i = 0
+    while i < len(msgs):
+        if msgs[i][0] == 'user' and not msgs[i][2]:
+            j = i + 1
+            while j < len(msgs) and msgs[j][0] != 'assistant':
+                j += 1
+            if j < len(msgs):
+                turn_boundaries.append((i, j))
+                i = j + 1
+            else:
+                i += 1
+        else:
+            i += 1
+
+    def get_turn_index(timestamp):
+        if not timestamp:
+            return 0
+        for idx, (ui, ai) in enumerate(turn_boundaries):
+            user_ts = msgs[ui][1]
+            asst_ts = msgs[ai][1]
+            if user_ts <= timestamp <= asst_ts:
+                return idx
+            if idx + 1 < len(turn_boundaries):
+                next_user_ts = msgs[turn_boundaries[idx + 1][0]][1]
+                if asst_ts <= timestamp < next_user_ts:
+                    return idx
+        return max(0, len(turn_boundaries) - 1)
+
+    def make_date(timestamp):
+        try:
+            from datetime import datetime
+            return datetime.fromisoformat(
+                timestamp.replace('Z', '+00:00')).strftime('%Y-%m-%d')
+        except Exception:
+            from datetime import date
+            return date.today().isoformat()
+
+    def current_skill():
+        return skill_stack[-1][1] if skill_stack else None
+
+    def make_event(timestamp, turn_index, category, tool_name, detail, resolved=None):
+        return {
+            'timestamp': timestamp or '',
+            'date': make_date(timestamp),
+            'session_id': session_id,
+            'turn_index': turn_index,
+            'source': source,
+            'agent_type': agent_type,
+            'agent_id': agent_id,
+            'project': project,
+            'category': category,
+            'tool_name': tool_name,
+            'skill': current_skill(),
+            'model': model,
+            'detail': (detail or '')[:500],
+            'resolved': resolved,
+        }
+
+    # Second pass: detect friction
+    for obj in lines:
+        ts = obj.get('timestamp', '')
+        turn_idx = get_turn_index(ts)
+        msg = obj.get('message', {})
+        if not isinstance(msg, dict):
+            continue
+        content_blocks = msg.get('content', [])
+
+        if isinstance(content_blocks, list):
+            for block in content_blocks:
+                if not isinstance(block, dict):
+                    continue
+                btype = block.get('type')
+
+                if btype == 'tool_use':
+                    tool_id = block.get('id', '')
+                    tool_name = block.get('name', '')
+                    pending_tools[tool_id] = {
+                        'name': tool_name,
+                        'turn_index': turn_idx,
+                        'timestamp': ts,
+                    }
+                    if tool_name == 'Skill':
+                        skill_name = block.get('input', {}).get('skill', '')
+                        if skill_name:
+                            skill_stack.append((tool_id, skill_name))
+
+                elif btype == 'tool_result':
+                    tool_id = block.get('tool_use_id', '')
+                    is_error = block.get('is_error', False)
+                    content = ''
+                    raw_content = block.get('content', '')
+                    if isinstance(raw_content, str):
+                        content = raw_content
+                    elif isinstance(raw_content, list):
+                        content = ' '.join(
+                            c.get('text', '') for c in raw_content
+                            if isinstance(c, dict) and c.get('type') == 'text')
+
+                    tool_info = pending_tools.get(tool_id, {})
+                    tool_name = tool_info.get('name', '')
+
+                    # Pop skill stack if this is a Skill tool result
+                    if skill_stack and skill_stack[-1][0] == tool_id:
+                        skill_stack.pop()
+
+                    content_lower = content.lower()
+
+                    # Check if this is a retry of a previously errored tool
+                    if tool_name and tool_name in last_error_by_tool:
+                        if not is_error:
+                            events.append(make_event(ts, turn_idx, 'retry',
+                                                     tool_name, 'Retry succeeded', True))
+                            del last_error_by_tool[tool_name]
+                            continue
+                        else:
+                            events.append(make_event(ts, turn_idx, 'retry',
+                                                     tool_name, 'Retry failed', False))
+                            continue
+
+                    if not is_error:
+                        continue
+
+                    # Priority 1: permission_denied
+                    if ("user doesn't want to proceed" in content_lower or
+                            "tool use was rejected" in content_lower):
+                        events.append(make_event(ts, turn_idx, 'permission_denied',
+                                                 tool_name, content))
+                        last_error_by_tool[tool_name] = tool_id
+                        continue
+
+                    # Priority 2: hook_blocked
+                    if 'pretooluse:' in content_lower and 'blocked' in content_lower:
+                        events.append(make_event(ts, turn_idx, 'hook_blocked',
+                                                 tool_name, content))
+                        last_error_by_tool[tool_name] = tool_id
+                        continue
+
+                    # Priority 3: cascade_error
+                    if 'sibling tool call errored' in content_lower:
+                        events.append(make_event(ts, turn_idx, 'cascade_error',
+                                                 tool_name, content))
+                        continue
+
+                    # Priority 4: command_failed
+                    if tool_name == 'Bash' and content.startswith('Exit code '):
+                        events.append(make_event(ts, turn_idx, 'command_failed',
+                                                 tool_name, content))
+                        last_error_by_tool[tool_name] = tool_id
+                        continue
+
+                    # Priority 5: tool_error (catch-all for is_error=true)
+                    events.append(make_event(ts, turn_idx, 'tool_error',
+                                             tool_name, content))
+                    last_error_by_tool[tool_name] = tool_id
+
+        # Check for corrections: user messages
+        obj_type = obj.get('type')
+        user_type = obj.get('userType')
+        is_sidechain = obj.get('isSidechain', False)
+        if obj_type == 'user' and user_type == 'human' and not is_sidechain:
+            text = ''
+            if isinstance(content_blocks, list):
+                texts = [c.get('text', '') for c in content_blocks
+                         if isinstance(c, dict) and c.get('type') == 'text']
+                text = ' '.join(texts).strip()
+            elif isinstance(msg.get('content'), str):
+                text = msg['content'].strip()
+
+            if text:
+                text_lower = text.lower()
+                first_100 = text_lower[:100]
+                is_correction = False
+
+                for prefix in ('no,', 'no ', 'wrong', 'stop', 'wait', 'actually,'):
+                    if text_lower.startswith(prefix):
+                        is_correction = True
+                        break
+
+                if not is_correction:
+                    for phrase in ("that's wrong", "not what i", "i said", "i meant"):
+                        if phrase in first_100:
+                            is_correction = True
+                            break
+
+                if is_correction:
+                    events.append(make_event(ts, turn_idx, 'correction',
+                                             None, text[:200]))
+
+    return events
+
+
+def upsert_friction(friction_file, session_id, new_events):
+    """Load existing friction.json, remove events for session_id, add new, sort, write."""
+    data = []
+    if os.path.exists(friction_file):
+        try:
+            with open(friction_file, encoding='utf-8') as f:
+                data = json.load(f)
+        except Exception:
+            data = []
+
+    data = [e for e in data if e.get('session_id') != session_id]
+    data.extend(new_events)
+
+    data.sort(key=lambda x: (x.get('date', ''), x.get('session_id', ''),
+                              x.get('turn_index', 0)))
+
+    os.makedirs(os.path.dirname(os.path.abspath(friction_file)), exist_ok=True)
+    with open(friction_file, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=2)
+        f.write('\n')
+
+    return data
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Parse friction events from JSONL transcript')
+    parser.add_argument('transcript_path')
+    parser.add_argument('friction_file')
+    parser.add_argument('session_id')
+    parser.add_argument('project')
+    parser.add_argument('source')
+    parser.add_argument('--agent-type', default=None)
+    parser.add_argument('--agent-id', default=None)
+    args = parser.parse_args()
+
+    events = parse_friction(args.transcript_path, args.session_id, args.project,
+                            args.source, args.agent_type, args.agent_id)
+
+    if events:
+        upsert_friction(args.friction_file, args.session_id, events)
+        print(f"{len(events)} friction event(s) recorded.")
+    else:
+        upsert_friction(args.friction_file, args.session_id, [])
+
+
+if __name__ == '__main__':
+    main()

package/src/parse_skills.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+Parse Skill tool invocations from Claude Code JSONL transcripts.
+
+Usage:
+  python3 parse_skills.py <transcript_path> <tracking_dir> <session_id> <project>
+"""
+import json
+import os
+import sys
+from datetime import date, datetime
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+import storage
+
+
+def make_date(timestamp):
+    try:
+        return datetime.fromisoformat(
+            timestamp.replace('Z', '+00:00')).strftime('%Y-%m-%d')
+    except Exception:
+        return date.today().isoformat()
+
+
+def parse_skills(transcript_path, session_id, project):
+    """Parse JSONL transcript for Skill tool_use blocks.
+    Returns list of dicts ready for storage.replace_session_skills()."""
+    lines = []
+    with open(transcript_path, encoding='utf-8') as f:
+        for raw in f:
+            try:
+                obj = json.loads(raw)
+                lines.append(obj)
+            except Exception:
+                pass
+
+    pending = {}  # tool_use_id -> {skill_name, args, tool_use_id, timestamp}
+    entries = []
+
+    for obj in lines:
+        ts = obj.get('timestamp', '')
+        msg = obj.get('message', {})
+        if not isinstance(msg, dict):
+            continue
+        content_blocks = msg.get('content', [])
+        if not isinstance(content_blocks, list):
+            continue
+
+        for block in content_blocks:
+            if not isinstance(block, dict):
+                continue
+            btype = block.get('type')
+
+            if btype == 'tool_use' and block.get('name') == 'Skill':
+                tool_use_id = block.get('id', '')
+                inp = block.get('input', {})
+                pending[tool_use_id] = {
+                    'skill_name': inp.get('skill', 'unknown'),
+                    'args': inp.get('args'),
+                    'tool_use_id': tool_use_id,
+                    'timestamp': ts,
+                }
+
+            elif btype == 'tool_result':
+                tool_use_id = block.get('tool_use_id', '')
+                if tool_use_id not in pending:
+                    continue
+
+                info = pending.pop(tool_use_id)
+                is_error = block.get('is_error', False)
+
+                error_content = None
+                if is_error:
+                    raw_content = block.get('content', '')
+                    if isinstance(raw_content, str):
+                        error_content = raw_content
+                    elif isinstance(raw_content, list):
+                        error_content = ' '.join(
+                            c.get('text', '') for c in raw_content
+                            if isinstance(c, dict) and c.get('type') == 'text')
+
+                duration = 0
+                if info['timestamp'] and ts:
+                    try:
+                        use_ts = datetime.fromisoformat(
+                            info['timestamp'].replace('Z', '+00:00'))
+                        result_ts = datetime.fromisoformat(
+                            ts.replace('Z', '+00:00'))
+                        duration = max(0, int((result_ts - use_ts).total_seconds()))
+                    except Exception:
+                        pass
+
+                entries.append({
+                    'session_id': session_id,
+                    'date': make_date(info['timestamp']),
+                    'project': project,
+                    'skill_name': info['skill_name'],
+                    'args': info['args'],
+                    'tool_use_id': info['tool_use_id'],
+                    'timestamp': info['timestamp'],
+                    'duration_seconds': duration,
+                    'success': 0 if is_error else 1,
+                    'error_message': error_content if is_error else None,
+                })
+
+    # Flush unmatched pending skills
+    for tool_use_id, info in pending.items():
+        entries.append({
+            'session_id': session_id,
+            'date': make_date(info['timestamp']),
+            'project': project,
+            'skill_name': info['skill_name'],
+            'args': info['args'],
+            'tool_use_id': info['tool_use_id'],
+            'timestamp': info['timestamp'],
+            'duration_seconds': 0,
+            'success': 1,
+            'error_message': None,
+        })
+
+    return entries
+
+
+if __name__ == '__main__':
+    if len(sys.argv) != 5:
+        print(f"Usage: {sys.argv[0]} <transcript_path> <tracking_dir> <session_id> <project>",
+              file=sys.stderr)
+        sys.exit(1)
+
+    transcript_path, tracking_dir, session_id, project = sys.argv[1:5]
+    entries = parse_skills(transcript_path, session_id, project)
+    storage.replace_session_skills(tracking_dir, session_id, entries)

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])