@polymorphism-tech/morph-spec 4.5.0 → 4.7.0

package/framework/hooks/claude-code/statusline.py

@@ -8,7 +8,10 @@ import json
 import os
 import subprocess
 import time
+import re
+import hashlib
 from pathlib import Path
+from datetime import datetime, timezone
 
 # Ensure UTF-8 output on Windows (stdout defaults to CP1252 otherwise)
 if hasattr(sys.stdout, 'reconfigure'):
@@ -27,10 +30,52 @@ GRAY = '\033[90m'
 WHITE = '\033[97m'
 
 
+# ── MORPH framework constants (derived from phases.json / trust-manager.js) ──
+
+# Ordered core phases for pipeline mini-map (5 positions, optional phases mapped)
+# uiux maps to position 2 (same slot as design — they're mutually exclusive in practice)
+PHASE_POSITIONS = {
+    'proposal': 1, 'setup': 1,
+    'uiux': 2, 'design': 2,
+    'clarify': 3,
+    'tasks': 4,
+    'implement': 5, 'sync': 5,
+}
+PHASE_ABBREV = {
+    'proposal': 'prop', 'setup': 'setup',
+    'uiux': 'ui', 'design': 'design',
+    'clarify': 'clarify', 'tasks': 'tasks',
+    'implement': 'impl', 'sync': 'sync',
+}
+PIPELINE_TOTAL = 5
+
+# Approval gates per phase (from phases.json pausePoints)
+PHASE_GATES = {
+    'proposal': 'proposal',
+    'uiux':     'uiux',
+    'design':   'design',
+    'tasks':    'tasks',
+}
+
+# Trust level thresholds and badges (from trust-manager.js)
+# passRate >= threshold → level
+TRUST_LEVELS = [
+    (0.95, 'maximum', GREEN + BOLD, '◆◆◆◆'),
+    (0.90, 'high',    GREEN,        '◆◆◆○'),
+    (0.80, 'medium',  YELLOW,       '◆◆○○'),
+    (0.00, 'low',     RED,          '◆○○○'),
+]
+
+CHECKPOINT_FREQUENCY = 3  # matches llm-interaction.json default
+
+
+# ── General helpers ──────────────────────────────────────────────────────────
+
 def ctx_color(pct):
-    if pct < 70:
+    """Color based on context usage. 80% = Claude's auto-compact threshold."""
+    if pct < 60:
         return GREEN
-    if pct < 90:
+    if pct < 80:
         return YELLOW
     return RED
 
@@ -42,13 +87,113 @@ def progress_bar(pct, width=8):
 
 
 def format_tokens(n):
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f}m"
     if n >= 1000:
         return f"{n // 1000}k"
     return str(n)
 
 
+# ── MORPH feature helpers ────────────────────────────────────────────────────
+
+def calculate_trust(checkpoints):
+    """Return (level_str, color, badge, pass_rate) from checkpoint array."""
+    if not checkpoints:
+        return 'low', RED, '○○○○', 0.0
+    total = len(checkpoints)
+    passed = sum(1 for c in checkpoints if c.get('passed'))
+    rate = passed / total
+    for threshold, level, color, badge in TRUST_LEVELS:
+        if rate >= threshold:
+            return level, color, badge, rate
+    return 'low', RED, '○○○○', rate
+
+
+def get_phase_minimap(phase):
+    """Return colored dot strip + phase abbrev, e.g. '●►○○○ design'."""
+    pos = PHASE_POSITIONS.get(phase)
+    if pos is None:
+        return None
+    dots = ''
+    for i in range(1, PIPELINE_TOTAL + 1):
+        if i < pos:
+            dots += f"{GREEN}●{R}"
+        elif i == pos:
+            dots += f"{CYAN}►{R}"
+        else:
+            dots += f"{GRAY}○{R}"
+    abbrev = PHASE_ABBREV.get(phase, phase)
+    return f"{dots} {CYAN}{abbrev}{R}"
+
+
+def get_checkpoint_countdown(tasks_done):
+    """Tasks remaining until next checkpoint fires (frequency=3)."""
+    if tasks_done <= 0:
+        return None
+    remaining = CHECKPOINT_FREQUENCY - (tasks_done % CHECKPOINT_FREQUENCY)
+    return 0 if remaining == CHECKPOINT_FREQUENCY else remaining
+
+
+def get_next_gate(phase, approval_gates):
+    """Return the upcoming gate for this phase if not yet triggered in state."""
+    gate_id = PHASE_GATES.get(phase)
+    if not gate_id:
+        return None
+    # If the gate already appears in approvalGates (approved or pending),
+    # it's either done or already shown as pending — don't duplicate.
+    if gate_id in (approval_gates or {}):
+        return None
+    return gate_id
+
+
+def get_all_active_features(cwd):
+    """Return list of all in_progress features with enriched MORPH metadata."""
+    state_path = Path(cwd) / '.morph' / 'state.json'
+    if not state_path.exists():
+        return []
+    try:
+        state = json.loads(state_path.read_text())
+        features = state.get('features', {})
+        result = []
+        for name, feat in features.items():
+            if feat.get('status') != 'in_progress':
+                continue
+            phase      = feat.get('phase', '?')
+            tasks      = feat.get('tasks', {})
+            done       = tasks.get('completed', 0)
+            total      = tasks.get('total', 0)
+            gates      = feat.get('approvalGates', {})
+            checkpts   = feat.get('checkpoints', [])
+
+            pending    = [g for g, v in gates.items() if not v.get('approved')]
+            trust_lvl, trust_color, trust_badge, trust_rate = calculate_trust(checkpts)
+            countdown  = get_checkpoint_countdown(done)
+            next_gate  = get_next_gate(phase, gates)
+            minimap    = get_phase_minimap(phase)
+
+            result.append({
+                'name':         name,
+                'phase':        phase,
+                'tasks_done':   done,
+                'tasks_total':  total,
+                'pending':      pending[0] if pending else None,
+                'trust_level':  trust_lvl,
+                'trust_color':  trust_color,
+                'trust_badge':  trust_badge,
+                'trust_rate':   trust_rate,
+                'countdown':    countdown,
+                'next_gate':    next_gate,
+                'minimap':      minimap,
+            })
+        return result
+    except Exception:
+        return []
+
+
+# ── Git helpers ───────────────────────────────────────────────────────────────
+
 def get_git_info(cwd):
-    """Get git branch and file stats. Uses a 5s file cache to avoid lag."""
+    """Get git branch and diff stats. Uses a 5s file cache to avoid lag."""
     try:
         cache_file = Path(cwd) / '.morph' / '.git-cache'
         try:
@@ -64,31 +209,32 @@ def get_git_info(cwd):
             cwd=cwd, stderr=subprocess.DEVNULL, timeout=2
         ).decode().strip()
 
-        status_out = subprocess.check_output(
-            ['git', 'status', '--porcelain'],
-            cwd=cwd, stderr=subprocess.DEVNULL, timeout=2
-        ).decode()
-
-        staged = sum(1 for l in status_out.splitlines() if l and l[0] in 'MADRC')
-        modified = sum(1 for l in status_out.splitlines() if l and l[1] in 'MD')
-        untracked = sum(1 for l in status_out.splitlines() if l.startswith('??'))
+        # Diff stats: insertions/deletions from staged + unstaged changes
+        ins, dels = 0, 0
+        for cmd in [['diff', '--shortstat'], ['diff', '--cached', '--shortstat']]:
+            try:
+                out = subprocess.check_output(
+                    ['git'] + cmd, cwd=cwd, stderr=subprocess.DEVNULL, timeout=2
+                ).decode()
+                m = re.search(r'(\d+) insertion', out)
+                if m:
+                    ins += int(m.group(1))
+                m = re.search(r'(\d+) deletion', out)
+                if m:
+                    dels += int(m.group(1))
+            except Exception:
+                pass
 
         parts = [f"{BLUE} {branch}{R}"]
-        if staged:
-            parts.append(f"{GREEN}+{staged}{R}")
-        if modified:
-            parts.append(f"{YELLOW}~{modified}{R}")
-        if untracked:
-            parts.append(f"{GRAY}?{untracked}{R}")
+        if ins or dels:
+            parts.append(f"{GREEN}+{ins}{R}{GRAY},{R}{RED}-{dels}{R}")
 
         result = ' '.join(parts)
-
         try:
             cache_file.parent.mkdir(parents=True, exist_ok=True)
             cache_file.write_text(result)
         except Exception:
             pass
-
         return result
     except Exception:
         return ""
@@ -97,71 +243,164 @@ def get_git_info(cwd):
 def get_worktree_info(cwd):
     """Detect if running in a git worktree (not the main worktree)."""
     try:
-        worktrees_out = subprocess.check_output(
+        out = subprocess.check_output(
             ['git', 'worktree', 'list', '--porcelain'],
             cwd=cwd, stderr=subprocess.DEVNULL, timeout=2
         ).decode()
-
-        entries = []
-        current = {}
-        for line in worktrees_out.splitlines():
+        entries, current = [], {}
+        for line in out.splitlines():
             if line.startswith('worktree '):
                 if current:
                     entries.append(current)
                 current = {'path': line.split(' ', 1)[1]}
             elif line.startswith('branch '):
                 current['branch'] = line.split(' ', 1)[1]
-
         if current:
             entries.append(current)
-
         if len(entries) > 1:
-            cwd_resolved = str(Path(cwd).resolve())
+            cwd_r = str(Path(cwd).resolve())
             for entry in entries[1:]:
-                entry_path = str(Path(entry.get('path', '')).resolve())
-                if cwd_resolved == entry_path:
-                    branch_ref = entry.get('branch', '')
-                    branch = branch_ref.replace('refs/heads/', '')
+                if str(Path(entry.get('path', '')).resolve()) == cwd_r:
+                    branch = entry.get('branch', '').replace('refs/heads/', '')
                     return f"{MAGENTA}worktree:{branch}{R}"
     except Exception:
         pass
     return ""
 
 
-def get_morph_info(cwd):
-    """Read active feature info from .morph/state.json."""
-    state_path = Path(cwd) / '.morph' / 'state.json'
-    if not state_path.exists():
+# ── Transcript / JSONL helpers ────────────────────────────────────────────────
+
+def read_transcript_jsonl(path):
+    """Read and parse JSONL transcript file. Returns list of parsed entries."""
+    entries = []
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entries.append(json.loads(line))
+                except Exception:
+                    pass
+    except Exception:
+        pass
+    return entries
+
+
+def get_token_metrics(entries):
+    """Sum token usage from all non-sidechain JSONL entries."""
+    total_input, total_output, total_cached = 0, 0, 0
+    for entry in entries:
+        if entry.get('isSidechain') or entry.get('isApiErrorMessage'):
+            continue
+        usage = (entry.get('message') or {}).get('usage') or {}
+        if not usage:
+            continue
+        total_input  += usage.get('input_tokens', 0)
+        total_output += usage.get('output_tokens', 0)
+        total_cached += (
+            usage.get('cache_creation_input_tokens', 0) +
+            usage.get('cache_read_input_tokens', 0)
+        )
+    return {'input': total_input, 'output': total_output, 'cached': total_cached}
+
+
+def parse_timestamp(ts):
+    """Parse ISO 8601 timestamp to Unix float. Returns None on error."""
+    try:
+        return datetime.fromisoformat(ts.replace('Z', '+00:00')).timestamp()
+    except Exception:
         return None
+
+
+def get_session_duration(entries):
+    """Elapsed time since first message. Returns 'Xhr Ym' or None."""
+    now = time.time()
+    for entry in entries:
+        ts = entry.get('timestamp')
+        if not ts:
+            continue
+        t = parse_timestamp(ts)
+        if t is None:
+            continue
+        elapsed_s = now - t
+        hours   = int(elapsed_s // 3600)
+        minutes = int((elapsed_s % 3600) // 60)
+        if hours == 0:
+            return f"{minutes}m"
+        elif minutes == 0:
+            return f"{hours}hr"
+        else:
+            return f"{hours}hr {minutes}m"
+    return None
+
+
+def get_session_name(entries):
+    """Find the most recent /rename title. Returns string or None."""
+    for entry in reversed(entries):
+        if entry.get('type') == 'custom-title' and entry.get('customTitle'):
+            return entry['customTitle']
+    return None
+
+
+def get_block_start(transcript_path, entries):
+    """Find start of current 5-hour billing block. Cached per transcript."""
+    h = hashlib.sha256(transcript_path.encode()).hexdigest()[:16]
+    cache_dir  = Path.home() / '.cache' / 'morph-spec'
+    cache_file = cache_dir / f'block-{h}.json'
+    now        = time.time()
+    block_s    = 5 * 3600
+
     try:
-        state = json.loads(state_path.read_text())
-        features = state.get('features', {})
-        active = [
-            (name, feat)
-            for name, feat in features.items()
-            if feat.get('status') == 'in_progress'
-        ]
-        if not active:
-            return None
-
-        name, feat = active[0]
-        phase = feat.get('phase', '?')
-        tasks = feat.get('tasks', {})
-        done = tasks.get('completed', 0)
-        total = tasks.get('total', 0)
-        gates = feat.get('approvalGates', {})
-        pending = [g for g, v in gates.items() if not v.get('approved')]
-
-        return {
-            'name': name,
-            'phase': phase,
-            'tasks_done': done,
-            'tasks_total': total,
-            'pending_approval': pending[0] if pending else None,
-        }
+        if cache_file.exists():
+            cached = json.loads(cache_file.read_text())
+            start  = cached.get('block_start')
+            if start and (now - start) < block_s:
+                return start
     except Exception:
+        pass
+
+    start = None
+    for entry in entries:
+        ts = entry.get('timestamp')
+        if not ts:
+            continue
+        t = parse_timestamp(ts)
+        if t is None:
+            continue
+        if (now - t) <= block_s:
+            start = t
+            break
+
+    if start is None:
         return None
 
+    try:
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        cache_file.write_text(json.dumps({'block_start': start}))
+    except Exception:
+        pass
+    return start
+
+
+def format_block_timer(block_start):
+    """Format block timer as 'bar Xhr Ym' relative to 5-hour window."""
+    now       = time.time()
+    elapsed_s = max(0.0, now - block_start)
+    pct       = min(elapsed_s / (5 * 3600) * 100, 100)
+    hours     = int(elapsed_s // 3600)
+    minutes   = int((elapsed_s % 3600) // 60)
+    if hours == 0:
+        time_str = f"{minutes}m"
+    elif minutes == 0:
+        time_str = f"{hours}hr"
+    else:
+        time_str = f"{hours}hr {minutes}m"
+    return f"{progress_bar(pct, 6)} {time_str}"
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
 
 def main():
     try:
@@ -172,43 +411,103 @@ def main():
     except Exception:
         sys.exit(0)
 
-    cwd = data.get('cwd', os.getcwd())
-
-    # === LINE 1: Morph status (only if morph project has active feature) ===
-    morph = get_morph_info(cwd)
-    if morph:
-        parts1 = [
-            f"{CYAN}{BOLD}{morph['name']}{R}",
-            f"{MAGENTA}phase:{morph['phase']}{R}",
-        ]
-        if morph['tasks_total'] > 0:
-            pct = morph['tasks_done'] / morph['tasks_total'] * 100
+    cwd             = data.get('cwd', os.getcwd())
+    transcript_path = data.get('transcript_path')
+
+    # Read JSONL transcript once — shared by session clock, block timer,
+    # token metrics, and session name.
+    entries = read_transcript_jsonl(transcript_path) if transcript_path else []
+
+    # ── MORPH feature lines (one line per active feature) ────────────────────
+    features = get_all_active_features(cwd)
+    for feat in features:
+        parts = [f"{CYAN}{BOLD}{feat['name']}{R}"]
+
+        # Phase pipeline mini-map: ●●►○○ design
+        if feat['minimap']:
+            parts.append(feat['minimap'])
+
+        # Task progress bar
+        if feat['tasks_total'] > 0:
+            pct = feat['tasks_done'] / feat['tasks_total'] * 100
             bar = progress_bar(pct, 6)
-            parts1.append(f"{GREEN}{bar} {morph['tasks_done']}/{morph['tasks_total']}{R}")
-        if morph['pending_approval']:
-            parts1.append(f"{YELLOW}⏳ {morph['pending_approval']} pending{R}")
-        print('  |  '.join(parts1))
+            parts.append(f"{GREEN}{bar} {feat['tasks_done']}/{feat['tasks_total']}{R}")
 
-    # === LINE 2: Session info (always shown) ===
+        # Checkpoint countdown: how many tasks until next validation fires
+        if feat['countdown'] is not None:
+            if feat['countdown'] == 0:
+                parts.append(f"{GREEN}ckpt!{R}")          # just hit checkpoint
+            elif feat['countdown'] == 1:
+                parts.append(f"{YELLOW}ckpt:1{R}")        # 1 task away — heads up
+            else:
+                parts.append(f"{GRAY}ckpt:{feat['countdown']}{R}")
+
+        # Trust level badge: ◆◆◆○ high
+        tc = feat['trust_color']
+        parts.append(f"{tc}{feat['trust_badge']}{R}")
+
+        # Pending approval gate (blocking — already triggered, not yet approved)
+        if feat['pending']:
+            parts.append(f"{YELLOW}⏳ {feat['pending']} pending{R}")
+
+        # Upcoming gate (not yet triggered — reminds what comes at end of phase)
+        if feat['next_gate']:
+            parts.append(f"{GRAY}→gate:{feat['next_gate']}{R}")
+
+        print('  |  '.join(parts))
+
+    # ── Session info line (always shown) ─────────────────────────────────────
     parts2 = []
 
+    # Session name (set via /rename)
+    if entries:
+        session_name = get_session_name(entries)
+        if session_name:
+            parts2.append(f"{CYAN}{BOLD}📌 {session_name}{R}")
+
     # Model
-    model = data.get('model', {})
+    model      = data.get('model', {})
     model_name = model.get('display_name', model.get('id', ''))
     if model_name:
         short = model_name.replace('Claude ', '').replace(' (claude.ai)', '')
         parts2.append(f"{WHITE}{BOLD}🤖 {short}{R}")
 
-    # Context window
+    # Session clock (elapsed time since first message)
+    if entries:
+        duration = get_session_duration(entries)
+        if duration:
+            parts2.append(f"{YELLOW}⏱ {duration}{R}")
+
+    # Block timer (progress through current 5-hour billing window)
+    if entries and transcript_path:
+        block_start = get_block_start(transcript_path, entries)
+        if block_start is not None:
+            parts2.append(f"{YELLOW}blk:{format_block_timer(block_start)}{R}")
+
+    # Context window (60% = yellow, 80% = red/auto-compact threshold)
     ctx = data.get('context_window', {})
     if ctx:
-        used_pct = ctx.get('used_percentage', 0)
-        cur = ctx.get('current_usage', 0)
+        used_pct  = ctx.get('used_percentage', 0)
+        cur       = ctx.get('current_usage', 0)
         total_ctx = ctx.get('context_window_size', 0)
-        color = ctx_color(used_pct)
-        bar = progress_bar(used_pct, 8)
-        toks = f"{format_tokens(cur)}/{format_tokens(total_ctx)}"
-        parts2.append(f"{color}{bar} {used_pct:.0f}% ({toks} tok){R}")
+        color     = ctx_color(used_pct)
+        bar       = progress_bar(used_pct, 8)
+        toks      = f"{format_tokens(cur)}/{format_tokens(total_ctx)}"
+        suffix    = f" {RED}~cmpct{R}" if used_pct >= 80 else ""
+        parts2.append(f"{color}{bar} {used_pct:.0f}%{R} ({toks}){suffix}")
+
+    # Token breakdown from JSONL (session totals: input / output / cached)
+    if entries:
+        tok = get_token_metrics(entries)
+        tok_parts = []
+        if tok['input']:
+            tok_parts.append(f"in:{format_tokens(tok['input'])}")
+        if tok['output']:
+            tok_parts.append(f"out:{format_tokens(tok['output'])}")
+        if tok['cached']:
+            tok_parts.append(f"↩{format_tokens(tok['cached'])}")
+        if tok_parts:
+            parts2.append(f"{GRAY}{' '.join(tok_parts)}{R}")
 
     # Cost
     cost = data.get('cost', {})
@@ -221,7 +520,7 @@ def main():
     if agent.get('name'):
         parts2.append(f"{BLUE}agent:{agent['name']}{R}")
 
-    # Git info (cached, non-blocking)
+    # Git info (branch + diff stats, 5s cached)
     git = get_git_info(cwd)
     if git:
         parts2.append(git)