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

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_compactions.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Parse context compaction events from Claude Code JSONL transcripts.
+
+Usage:
+  python3 parse_compactions.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_compactions(transcript_path, session_id, project):
+    """Parse JSONL transcript for compact_boundary system events.
+
+    Derives turn_index by counting user/assistant pairs before each event.
+    Returns list of dicts ready for storage.replace_session_compactions().
+    """
+    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
+
+    # Build turn boundaries for turn_index calculation
+    msg_list = []
+    for obj in lines:
+        ts = obj.get('timestamp', '')
+        t = obj.get('type')
+        if t == 'user' and not obj.get('isSidechain') and ts:
+            msg_list.append(('user', ts))
+        elif t == 'assistant' and ts:
+            msg_list.append(('assistant', ts))
+
+    # Pair user->assistant for turn boundaries
+    turn_boundaries = []
+    idx = 0
+    while idx < len(msg_list):
+        if msg_list[idx][0] == 'user':
+            j = idx + 1
+            while j < len(msg_list) and msg_list[j][0] != 'assistant':
+                j += 1
+            if j < len(msg_list):
+                turn_boundaries.append((msg_list[idx][1], msg_list[j][1]))
+                idx = j + 1
+            else:
+                idx += 1
+        else:
+            idx += 1
+
+    def get_turn_index(timestamp):
+        if not timestamp:
+            return 0
+        for ti, (user_ts, asst_ts) in enumerate(turn_boundaries):
+            if timestamp <= asst_ts:
+                return ti
+            if ti + 1 < len(turn_boundaries):
+                next_user_ts = turn_boundaries[ti + 1][0]
+                if asst_ts < timestamp < next_user_ts:
+                    return ti
+        return max(0, len(turn_boundaries) - 1)
+
+    entries = []
+    for obj in lines:
+        if obj.get('type') != 'system':
+            continue
+        if obj.get('subtype') != 'compact_boundary':
+            continue
+
+        ts = obj.get('timestamp', '')
+        meta = obj.get('compactMetadata', {})
+        if not isinstance(meta, dict):
+            meta = {}
+
+        entries.append({
+            'session_id': session_id,
+            'date': make_date(ts),
+            'project': project,
+            'timestamp': ts,
+            'trigger': meta.get('trigger', 'auto'),
+            'pre_tokens': meta.get('preTokens', 0),
+            'turn_index': get_turn_index(ts),
+        })
+
+    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_compactions(transcript_path, session_id, project)
+    storage.replace_session_compactions(tracking_dir, session_id, entries)

package/src/parse_friction.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+Parse friction events from Claude Code JSONL transcripts.
+
+Usage:
+  python3 parse_friction.py <transcript_path> <tracking_dir> <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
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+import storage
+
+
+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(tracking_dir, session_id, new_events):
+    """Write friction events to SQLite via storage module.
+
+    For backward compatibility, also accepts a friction.json path --
+    if tracking_dir ends with '.json', derive the tracking dir from it.
+    """
+    if tracking_dir.endswith('.json'):
+        tracking_dir = os.path.dirname(os.path.abspath(tracking_dir))
+
+    storage.replace_session_friction(tracking_dir, session_id, new_events)
+    return new_events
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Parse friction events from JSONL transcript')
+    parser.add_argument('transcript_path')
+    parser.add_argument('tracking_dir')
+    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)
+
+    upsert_friction(args.tracking_dir, args.session_id, events)
+    if events:
+        print(f"{len(events)} friction event(s) recorded.")
+
+
+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)