@trac3r/oh-my-god 2.2.11

package/tools/dashboard_generator.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""
+HTML Dashboard Generator for OMG
+
+Generates a single self-contained HTML dashboard with Chart.js (CDN)
+from tool-ledger.jsonl and cost-ledger.jsonl data.
+
+Feature flag: SESSION_ANALYTICS (default: False)
+Pure stdlib — no external dependencies.
+"""
+
+import json
+import logging
+import os
+import sys
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+# Lazy import for feature flag helper
+_get_feature_flag = None
+
+logger = logging.getLogger(__name__)
+
+
+def _ensure_imports():
+    """Lazy import feature flag helper."""
+    global _get_feature_flag
+    if _get_feature_flag is None:
+        sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        try:
+            from hooks._common import get_feature_flag as _gff
+            _get_feature_flag = _gff
+        except ImportError:
+            # Fallback: always return default
+            _get_feature_flag = None
+
+
+def _read_jsonl(path: str) -> List[Dict[str, Any]]:
+    """Read JSONL file and return list of parsed entries.
+
+    Skips malformed lines gracefully. Returns empty list if file missing.
+    """
+    if not os.path.exists(path):
+        return []
+
+    entries: List[Dict[str, Any]] = []
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                    if isinstance(entry, dict):
+                        entries.append(entry)
+                except (json.JSONDecodeError, ValueError):
+                    continue
+    except Exception:
+        pass  # Crash isolation: return what we have
+
+    return entries
+
+
+def _aggregate_tool_usage(tool_entries: List[Dict[str, Any]]) -> Dict[str, int]:
+    """Count tool invocations by tool name."""
+    counts: Dict[str, int] = Counter()
+    for entry in tool_entries:
+        tool = entry.get("tool", "unknown")
+        if isinstance(tool, str) and tool:
+            counts[tool] += 1
+    return dict(counts)
+
+
+def _aggregate_cost_over_time(cost_entries: List[Dict[str, Any]]) -> List[Tuple[str, float]]:
+    """Aggregate cost by date (YYYY-MM-DD)."""
+    by_date: Dict[str, float] = defaultdict(float)
+    for entry in cost_entries:
+        ts = entry.get("ts", "")
+        cost = entry.get("cost_usd", 0.0)
+        if not isinstance(ts, str) or not ts:
+            continue
+        try:
+            cost_val = float(cost)
+        except (TypeError, ValueError):
+            cost_val = 0.0
+        # Extract date portion
+        date_str = ts[:10]  # YYYY-MM-DD
+        if len(date_str) == 10:
+            by_date[date_str] += cost_val
+
+    return sorted(by_date.items())
+
+
+def _build_session_summary(
+    tool_entries: List[Dict[str, Any]],
+    cost_entries: List[Dict[str, Any]],
+) -> Dict[str, Any]:
+    """Build session summary stats."""
+    total_tools = len(tool_entries)
+    total_cost = sum(
+        float(e.get("cost_usd", 0.0))
+        for e in cost_entries
+        if isinstance(e.get("cost_usd"), (int, float))
+    )
+    total_tokens = sum(
+        int(e.get("tokens_in", 0)) + int(e.get("tokens_out", 0))
+        for e in cost_entries
+        if isinstance(e.get("tokens_in"), (int, float))
+        and isinstance(e.get("tokens_out"), (int, float))
+    )
+
+    return {
+        "total_tool_calls": total_tools,
+        "total_cost_usd": round(total_cost, 6),
+        "total_tokens": total_tokens,
+        "cost_entries": len(cost_entries),
+    }
+
+
+def _render_html(
+    tool_usage: Dict[str, int],
+    cost_over_time: List[Tuple[str, float]],
+    session_summary: Dict[str, Any],
+    cost_entries: List[Dict[str, Any]],
+) -> str:
+    """Render a self-contained HTML dashboard with Chart.js CDN."""
+    # Prepare JSON data for charts
+    tool_labels = json.dumps(list(tool_usage.keys()))
+    tool_data = json.dumps(list(tool_usage.values()))
+
+    cost_labels = json.dumps([item[0] for item in cost_over_time])
+    cost_data = json.dumps([round(item[1], 6) for item in cost_over_time])
+
+    # Per-entry cost data for detailed chart
+    entry_costs = []
+    for entry in cost_entries:
+        ts = entry.get("ts", "")
+        cost = entry.get("cost_usd", 0.0)
+        try:
+            cost_val = round(float(cost), 6)
+        except (TypeError, ValueError):
+            cost_val = 0.0
+        entry_costs.append({"ts": ts, "cost": cost_val})
+    entry_costs_json = json.dumps(entry_costs)
+
+    summary_html = (
+        f"<li>Total Tool Calls: <strong>{session_summary['total_tool_calls']}</strong></li>"
+        f"<li>Total Cost: <strong>${session_summary['total_cost_usd']}</strong></li>"
+        f"<li>Total Tokens: <strong>{session_summary['total_tokens']}</strong></li>"
+        f"<li>Cost Entries: <strong>{session_summary['cost_entries']}</strong></li>"
+    )
+
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>OMG Session Dashboard</title>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+        body {{ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0f172a; color: #e2e8f0; padding: 24px; }}
+        h1 {{ text-align: center; margin-bottom: 24px; color: #38bdf8; }}
+        .grid {{ display: grid; grid-template-columns: 1fr 1fr; gap: 24px; max-width: 1200px; margin: 0 auto; }}
+        .card {{ background: #1e293b; border-radius: 12px; padding: 20px; box-shadow: 0 4px 6px rgba(0,0,0,0.3); }}
+        .card h2 {{ margin-bottom: 16px; color: #94a3b8; font-size: 14px; text-transform: uppercase; letter-spacing: 1px; }}
+        .card.full {{ grid-column: 1 / -1; }}
+        canvas {{ max-height: 300px; }}
+        ul {{ list-style: none; }}
+        ul li {{ padding: 8px 0; border-bottom: 1px solid #334155; font-size: 15px; }}
+        ul li strong {{ color: #38bdf8; }}
+        .timestamp {{ text-align: center; color: #64748b; margin-top: 24px; font-size: 12px; }}
+    </style>
+</head>
+<body>
+    <h1>OMG Session Dashboard</h1>
+    <div class="grid">
+        <div class="card">
+            <h2>Tool Usage</h2>
+            <canvas id="toolChart"></canvas>
+        </div>
+        <div class="card">
+            <h2>Cost Over Time</h2>
+            <canvas id="costChart"></canvas>
+        </div>
+        <div class="card full">
+            <h2>Session Summary</h2>
+            <ul>
+                {summary_html}
+            </ul>
+        </div>
+    </div>
+    <div class="timestamp">Generated: {datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")}</div>
+    <script>
+        const toolLabels = {tool_labels};
+        const toolData = {tool_data};
+        const costLabels = {cost_labels};
+        const costData = {cost_data};
+
+        new Chart(document.getElementById('toolChart'), {{
+            type: 'bar',
+            data: {{
+                labels: toolLabels,
+                datasets: [{{
+                    label: 'Tool Calls',
+                    data: toolData,
+                    backgroundColor: 'rgba(56, 189, 248, 0.7)',
+                    borderColor: 'rgba(56, 189, 248, 1)',
+                    borderWidth: 1
+                }}]
+            }},
+            options: {{
+                responsive: true,
+                plugins: {{ legend: {{ display: false }} }},
+                scales: {{
+                    y: {{ beginAtZero: true, ticks: {{ color: '#94a3b8' }}, grid: {{ color: '#334155' }} }},
+                    x: {{ ticks: {{ color: '#94a3b8' }}, grid: {{ color: '#334155' }} }}
+                }}
+            }}
+        }});
+
+        new Chart(document.getElementById('costChart'), {{
+            type: 'line',
+            data: {{
+                labels: costLabels,
+                datasets: [{{
+                    label: 'Cost (USD)',
+                    data: costData,
+                    borderColor: 'rgba(34, 197, 94, 1)',
+                    backgroundColor: 'rgba(34, 197, 94, 0.1)',
+                    fill: true,
+                    tension: 0.3
+                }}]
+            }},
+            options: {{
+                responsive: true,
+                plugins: {{ legend: {{ display: false }} }},
+                scales: {{
+                    y: {{ beginAtZero: true, ticks: {{ color: '#94a3b8' }}, grid: {{ color: '#334155' }} }},
+                    x: {{ ticks: {{ color: '#94a3b8' }}, grid: {{ color: '#334155' }} }}
+                }}
+            }}
+        }});
+    </script>
+</body>
+</html>"""
+
+
+def generate_dashboard(
+    project_dir: str,
+    output_path: Optional[str] = None,
+) -> str:
+    """Generate an HTML dashboard from OMG ledger data.
+
+    Reads tool usage stats from {project_dir}/.omg/state/ledger/tool-ledger.jsonl
+    and cost data from {project_dir}/.omg/state/ledger/cost-ledger.jsonl.
+    Generates a single self-contained HTML file with Chart.js loaded from CDN.
+
+    Args:
+        project_dir: Project root directory.
+        output_path: Path for the HTML file. Defaults to
+                     {project_dir}/.omg/state/dashboard.html.
+
+    Returns:
+        The output_path string on success.
+    """
+    _ensure_imports()
+
+    # Check feature flag — return empty string if disabled
+    if _get_feature_flag is not None:
+        if not _get_feature_flag("SESSION_ANALYTICS", default=False):
+            return ""
+
+    # Resolve default output path
+    if output_path is None:
+        output_path = os.path.join(project_dir, ".omg", "state", "dashboard.html")
+
+    # Read ledger data
+    tool_ledger_path = os.path.join(project_dir, ".omg", "state", "ledger", "tool-ledger.jsonl")
+    cost_ledger_path = os.path.join(project_dir, ".omg", "state", "ledger", "cost-ledger.jsonl")
+
+    tool_entries = _read_jsonl(tool_ledger_path)
+    cost_entries = _read_jsonl(cost_ledger_path)
+
+    # Aggregate data
+    tool_usage = _aggregate_tool_usage(tool_entries)
+    cost_over_time = _aggregate_cost_over_time(cost_entries)
+    session_summary = _build_session_summary(tool_entries, cost_entries)
+
+    # Render HTML
+    html = _render_html(tool_usage, cost_over_time, session_summary, cost_entries)
+
+    # Write file
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(html)
+
+    return output_path

package/tools/git_inspector.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""
+Git Inspection Tools for OMG
+
+Read-only git inspection: status, log, and hunk-level diffs.
+Feature flag: OMG_GIT_TOOLS_ENABLED (default: False)
+"""
+
+import json
+import os
+import re
+import subprocess
+import sys
+from typing import Any, Dict, List, Optional
+
+# Import feature flag helper
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from hooks._common import get_feature_flag
+
+
+def git_status(cwd: str = ".") -> Dict[str, Any]:
+    """
+    Get git status: staged, unstaged, untracked files and current branch.
+    
+    Args:
+        cwd: Working directory (default: current directory)
+    
+    Returns:
+        {
+            "skipped": True  # if feature flag disabled
+        }
+        or
+        {
+            "staged": ["file1.py", "file2.py"],
+            "unstaged": ["file3.py"],
+            "untracked": ["file4.py"],
+            "branch": "main",
+            "error": None
+        }
+        or
+        {
+            "error": "git not found"
+        }
+    """
+    # Check feature flag
+    if not get_feature_flag("git_tools", default=False):
+        return {"skipped": True}
+    
+    try:
+        # Get status with porcelain format
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            return {"error": "git command failed"}
+        
+        staged = []
+        unstaged = []
+        untracked = []
+        
+        for line in result.stdout.split("\n"):
+            if not line:
+                continue
+            
+            status_code = line[:2]
+            file_path = line[3:]
+            
+            # First char: index (staged)
+            # Second char: working tree (unstaged)
+            if status_code[0] != " ":
+                staged.append(file_path)
+            if status_code[1] != " ":
+                unstaged.append(file_path)
+            if status_code == "??":
+                untracked.append(file_path)
+        
+        # Get current branch
+        branch_result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        branch = branch_result.stdout.strip() if branch_result.returncode == 0 else "unknown"
+        
+        return {
+            "staged": staged,
+            "unstaged": unstaged,
+            "untracked": untracked,
+            "branch": branch,
+            "error": None
+        }
+    
+    except FileNotFoundError:
+        return {"error": "git not found"}
+    except subprocess.TimeoutExpired:
+        return {"error": "git command timeout"}
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def git_log(cwd: str = ".", n: int = 10) -> List[Dict[str, Any]]:
+    """
+    Get recent N commits with hash, subject, author, and date.
+    
+    Args:
+        cwd: Working directory (default: current directory)
+        n: Number of commits to retrieve (default: 10)
+    
+    Returns:
+        List of {hash, subject, author, date} dicts
+        Empty list if git not available or feature flag disabled
+    """
+    # Check feature flag
+    if not get_feature_flag("git_tools", default=False):
+        return []
+    
+    try:
+        result = subprocess.run(
+            ["git", "log", f"--oneline", f"-n", str(n), 
+             "--format=%H|%s|%an|%ai"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            return []
+        
+        commits = []
+        for line in result.stdout.strip().split("\n"):
+            if not line:
+                continue
+            
+            parts = line.split("|", 3)
+            if len(parts) == 4:
+                commits.append({
+                    "hash": parts[0],
+                    "subject": parts[1],
+                    "author": parts[2],
+                    "date": parts[3]
+                })
+        
+        return commits
+    
+    except FileNotFoundError:
+        return []
+    except subprocess.TimeoutExpired:
+        return []
+    except Exception:
+        return []
+
+
+def git_hunk(cwd: str = ".", file_path: Optional[str] = None) -> List[Dict[str, Any]]:
+    """
+    Get hunk-level diff for a file or all files.
+    
+    Args:
+        cwd: Working directory (default: current directory)
+        file_path: Specific file to diff (None for all files)
+    
+    Returns:
+        List of {file, old_start, old_count, new_start, new_count, context, lines} dicts
+        Empty list if no diff or git not available or feature flag disabled
+    """
+    # Check feature flag
+    if not get_feature_flag("git_tools", default=False):
+        return []
+    
+    try:
+        cmd = ["git", "diff", "--unified=3"]
+        if file_path:
+            cmd.append(file_path)
+        
+        result = subprocess.run(
+            cmd,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode != 0:
+            return []
+        
+        hunks = []
+        current_file = None
+        current_hunk = None
+        hunk_lines = []
+        
+        # Regex to match hunk header: @@ -a,b +c,d @@ context
+        hunk_header_re = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@\s*(.*)")
+        
+        for line in result.stdout.split("\n"):
+            # File header
+            if line.startswith("diff --git"):
+                # Save previous hunk if exists
+                if current_hunk and hunk_lines:
+                    current_hunk["lines"] = hunk_lines
+                    hunks.append(current_hunk)
+                    hunk_lines = []
+                    current_hunk = None
+                
+                # Extract filename from "diff --git a/file b/file"
+                parts = line.split()
+                if len(parts) >= 4:
+                    current_file = parts[3][2:]  # Remove "b/" prefix
+            
+            # Hunk header
+            elif line.startswith("@@"):
+                # Save previous hunk if exists
+                if current_hunk and hunk_lines:
+                    current_hunk["lines"] = hunk_lines
+                    hunks.append(current_hunk)
+                    hunk_lines = []
+                
+                match = hunk_header_re.match(line)
+                if match:
+                    old_start = int(match.group(1))
+                    old_count = int(match.group(2)) if match.group(2) else 1
+                    new_start = int(match.group(3))
+                    new_count = int(match.group(4)) if match.group(4) else 1
+                    context = match.group(5).strip()
+                    
+                    current_hunk = {
+                        "file": current_file,
+                        "old_start": old_start,
+                        "old_count": old_count,
+                        "new_start": new_start,
+                        "new_count": new_count,
+                        "context": context,
+                        "lines": []
+                    }
+            
+            # Hunk content
+            elif current_hunk is not None:
+                if line.startswith("+") or line.startswith("-") or line.startswith(" "):
+                    hunk_lines.append(line)
+        
+        # Save last hunk
+        if current_hunk and hunk_lines:
+            current_hunk["lines"] = hunk_lines
+            hunks.append(current_hunk)
+        
+        return hunks
+    
+    except FileNotFoundError:
+        return []
+    except subprocess.TimeoutExpired:
+        return []
+    except Exception:
+        return []
+
+
+def main():
+    """CLI entry point."""
+    if len(sys.argv) < 2:
+        print("Usage:", file=sys.stderr)
+        print("  python3 git_inspector.py --overview", file=sys.stderr)
+        print("  python3 git_inspector.py --hunk [--file <path>]", file=sys.stderr)
+        sys.exit(1)
+    
+    cwd = os.getcwd()
+    
+    if sys.argv[1] == "--overview":
+        # Return status + log
+        status = git_status(cwd)
+        log = git_log(cwd)
+        result = {
+            "status": status,
+            "log": log
+        }
+        print(json.dumps(result, indent=2))
+    
+    elif sys.argv[1] == "--hunk":
+        # Return hunk diff
+        file_path = None
+        if len(sys.argv) >= 4 and sys.argv[2] == "--file":
+            file_path = sys.argv[3]
+        
+        hunks = git_hunk(cwd, file_path)
+        result = {"hunks": hunks}
+        print(json.dumps(result, indent=2))
+    
+    else:
+        print(f"Unknown command: {sys.argv[1]}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()