feat: add session_metadata.py — structured session metadata extractor (#6)

scripts/gitea_issue_parser.py

@@ -1,162 +0,0 @@
-#!/usr/bin/env python3
-"""
-Gitea Issue Body Parser
-
-Extracts structured data from Gitea issue markdown bodies:
-- Title
-- Context section
-- Acceptance criteria (checkboxes)
-- Labels
-- Epic/parent references
-
-Usage:
-  python3 scripts/gitea_issue_parser.py <issue_body.txt
-  python3 scripts/gitea_issue_parser.py --url https://forge.../api/v1/repos/.../issues/123
-  echo "issue body" | python3 scripts/gitea_issue_parser.py --stdin
-
-Output: JSON with {title, context, criteria[], labels[], epic_ref}
-"""
-
-import argparse
-import json
-import re
-import sys
-from typing import Optional
-
-
-def parse_issue_body(body: str, title: str = "", labels: list = None) -> dict:
-    """Parse a Gitea issue body into structured JSON."""
-    result = {
-        "title": title,
-        "context": "",
-        "criteria": [],
-        "labels": labels or [],
-        "epic_ref": None,
-        "sections": {},
-    }
-
-    if not body:
-        return result
-
-    # Extract epic/parent reference from title or body
-    epic_pattern = r"#(\d+)"
-    title_refs = re.findall(epic_pattern, title)
-    body_refs = re.findall(epic_pattern, body[:200])  # Check early body refs
-
-    # Look for "Closes #N" or "Part of #N" or "Epic: #N"
-    close_match = re.search(r"(?:Closes?|Fixes?|Resolves?)\s+#(\d+)", body, re.IGNORECASE)
-    part_match = re.search(r"(?:Part of|Epic|Parent|Blocks?)\s+#(\d+)", body, re.IGNORECASE)
-
-    if close_match:
-        result["epic_ref"] = f"#{close_match.group(1)}"
-    elif part_match:
-        result["epic_ref"] = f"#{part_match.group(1)}"
-    elif title_refs:
-        result["epic_ref"] = f"#{title_refs[0]}"
-    elif body_refs:
-        result["epic_ref"] = f"#{body_refs[0]}"
-
-    # Split into sections by ## headers
-    section_pattern = r"^##\s+(.+)$"
-    lines = body.split("\n")
-    current_section = None
-    current_content = []
-
-    for line in lines:
-        header_match = re.match(section_pattern, line)
-        if header_match:
-            # Save previous section
-            if current_section:
-                result["sections"][current_section] = "\n".join(current_content).strip()
-            current_section = header_match.group(1).strip().lower()
-            current_content = []
-        else:
-            current_content.append(line)
-
-    # Save last section
-    if current_section:
-        result["sections"][current_section] = "\n".join(current_content).strip()
-
-    # Extract context
-    for key in ["context", "background", "description", "problem"]:
-        if key in result["sections"]:
-            result["context"] = result["sections"][key]
-            break
-
-    # Extract acceptance criteria (checkboxes)
-    criteria_section = None
-    for key in ["acceptance criteria", "acceptance_criteria", "criteria", "requirements", "definition of done"]:
-        if key in result["sections"]:
-            criteria_section = result["sections"][key]
-            break
-
-    if criteria_section:
-        checkbox_pattern = r"-\s*\[[ xX]?\]\s*(.+)"
-        for match in re.finditer(checkbox_pattern, criteria_section):
-            result["criteria"].append(match.group(1).strip())
-
-        # Also try plain numbered/bulleted lists if no checkboxes found
-        if not result["criteria"]:
-            list_pattern = r"^\s*(?:\d+\.|-|\*)\s+(.+)"
-            for match in re.finditer(list_pattern, criteria_section, re.MULTILINE):
-                result["criteria"].append(match.group(1).strip())
-
-    # If no sectioned criteria found, scan whole body for checkboxes
-    if not result["criteria"]:
-        for match in re.finditer(r"-\s*\[[ xX]?\]\s*(.+)", body):
-            result["criteria"].append(match.group(1).strip())
-
-    return result
-
-
-def parse_from_url(api_url: str, token: str = None) -> dict:
-    """Parse an issue from a Gitea API URL."""
-    import urllib.request
-
-    headers = {}
-    if token:
-        headers["Authorization"] = f"token {token}"
-
-    req = urllib.request.Request(api_url, headers=headers)
-    resp = json.loads(urllib.request.urlopen(req, timeout=30).read())
-
-    title = resp.get("title", "")
-    body = resp.get("body", "")
-    labels = [l["name"] for l in resp.get("labels", [])]
-
-    return parse_issue_body(body, title, labels)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Parse Gitea issue body into structured JSON")
-    parser.add_argument("input", nargs="?", help="Issue body file (or - for stdin)")
-    parser.add_argument("--url", help="Gitea API URL for the issue")
-    parser.add_argument("--stdin", action="store_true", help="Read from stdin")
-    parser.add_argument("--token", help="Gitea API token (or set GITEA_TOKEN env var)")
-    parser.add_argument("--title", default="", help="Issue title (for epic ref extraction)")
-    parser.add_argument("--labels", nargs="*", default=[], help="Issue labels")
-    parser.add_argument("--pretty", action="store_true", help="Pretty-print JSON output")
-    args = parser.parse_args()
-
-    import os
-    token = args.token or os.environ.get("GITEA_TOKEN")
-
-    if args.url:
-        result = parse_from_url(args.url, token)
-    elif args.stdin or (args.input and args.input == "-"):
-        body = sys.stdin.read()
-        result = parse_issue_body(body, args.title, args.labels)
-    elif args.input:
-        with open(args.input) as f:
-            body = f.read()
-        result = parse_issue_body(body, args.title, args.labels)
-    else:
-        parser.print_help()
-        sys.exit(1)
-
-    indent = 2 if args.pretty else None
-    print(json.dumps(result, indent=indent))
-
-
-if __name__ == "__main__":
-    main()

scripts/session_metadata.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""
+session_metadata.py - Extract structured metadata from Hermes session transcripts.
+Works alongside session_reader.py to provide higher-level session analysis.
+"""
+
+import json
+import re
+import sys
+from dataclasses import dataclass, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+# Import from session_reader (the canonical reader)
+from session_reader import read_session
+
+
+@dataclass
+class SessionSummary:
+    """Structured summary of a Hermes session transcript."""
+    session_id: str
+    model: str
+    repo: str
+    outcome: str
+    message_count: int
+    tool_calls: int
+    duration_estimate: str
+    key_actions: List[str]
+    errors_encountered: List[str]
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    total_tokens_estimate: int = 0
+    user_messages: int = 0
+    assistant_messages: int = 0
+    tool_outputs: int = 0
+
+
+def extract_session_metadata(file_path: str) -> SessionSummary:
+    """
+    Extract structured metadata from a Hermes session JSONL transcript.
+    Uses session_reader.read_session() for file reading.
+    """
+    session_id = Path(file_path).stem
+    messages = []
+    model = "unknown"
+    repo = "unknown"
+    tool_calls_count = 0
+    key_actions = []
+    errors = []
+    start_time = None
+    end_time = None
+    total_tokens = 0
+    
+    # Common repo patterns to look for
+    repo_patterns = [
+        r"(?:the-nexus|compounding-intelligence|timmy-config|hermes-agent)",
+        r"(?:forge\.alexanderwhitestone\.com/([^/]+/[^/\\s]+))",
+        r"(?:github\.com/([^/]+/[^/\\s]+))",
+        r"(?:Timmy_Foundation/([^/\\s]+))",
+    ]
+    
+    try:
+        # Use the canonical reader from session_reader.py
+        messages = read_session(file_path)
+    except FileNotFoundError:
+        return SessionSummary(
+            session_id=session_id,
+            model="unknown",
+            repo="unknown",
+            outcome="failure",
+            message_count=0,
+            tool_calls=0,
+            duration_estimate="0m",
+            key_actions=[],
+            errors_encountered=[f"File not found: {file_path}"]
+        )
+    
+    # Process messages for metadata
+    for entry in messages:
+        # Extract model from assistant messages
+        if entry.get("role") == "assistant" and entry.get("model"):
+            model = entry["model"]
+        
+        # Extract timestamps
+        if entry.get("timestamp"):
+            ts = entry["timestamp"]
+            if start_time is None:
+                start_time = ts
+            end_time = ts
+        
+        # Count tool calls
+        if entry.get("tool_calls"):
+            tool_calls_count += len(entry["tool_calls"])
+            for tc in entry["tool_calls"]:
+                if tc.get("function", {}).get("name"):
+                    action = f"{tc['function']['name']}"
+                    if action not in key_actions:
+                        key_actions.append(action)
+        
+        # Estimate tokens from content length
+        content = entry.get("content", "")
+        if isinstance(content, str):
+            total_tokens += len(content.split())
+        elif isinstance(content, list):
+            for item in content:
+                if isinstance(item, dict) and "text" in item:
+                    total_tokens += len(item["text"].split())
+        
+        # Look for repo mentions in content
+        if entry.get("content"):
+            content_str = str(entry["content"])
+            for pattern in repo_patterns:
+                match = re.search(pattern, content_str, re.IGNORECASE)
+                if match:
+                    if match.groups():
+                        repo = match.group(1)
+                    else:
+                        repo = match.group(0)
+                    break
+        
+        # Look for error messages
+        if entry.get("role") == "tool" and entry.get("is_error"):
+            error_msg = entry.get("content", "Unknown error")
+            if isinstance(error_msg, str) and len(error_msg) < 200:
+                errors.append(error_msg[:200])
+    
+    # Count message types
+    user_messages = sum(1 for m in messages if m.get("role") == "user")
+    assistant_messages = sum(1 for m in messages if m.get("role") == "assistant")
+    tool_outputs = sum(1 for m in messages if m.get("role") == "tool")
+    
+    # Calculate duration estimate
+    duration_estimate = "unknown"
+    if start_time and end_time:
+        try:
+            # Try to parse timestamps
+            start_dt = None
+            end_dt = None
+            
+            # Handle various timestamp formats
+            for fmt in ["%Y-%m-%dT%H:%M:%S.%fZ", "%Y-%m-%dT%H:%M:%SZ", "%Y-%m-%d %H:%M:%S"]:
+                try:
+                    if start_dt is None:
+                        start_dt = datetime.strptime(start_time, fmt)
+                    if end_dt is None:
+                        end_dt = datetime.strptime(end_time, fmt)
+                except ValueError:
+                    continue
+            
+            if start_dt and end_dt:
+                duration = end_dt - start_dt
+                minutes = duration.total_seconds() / 60
+                duration_estimate = f"{minutes:.0f}m"
+        except Exception:
+            pass
+    
+    # Classify outcome
+    outcome = "unknown"
+    if errors:
+        # Check if any errors are fatal
+        fatal_errors = any("405" in e or "permission" in e.lower() or "authentication" in e.lower() 
+                          for e in errors)
+        if fatal_errors:
+            outcome = "failure"
+        else:
+            outcome = "partial"
+    elif messages:
+        # Check last message for success indicators
+        last_msg = messages[-1]
+        if last_msg.get("role") == "assistant":
+            content = last_msg.get("content", "")
+            if isinstance(content, str):
+                success_indicators = ["done", "completed", "success", "merged", "pushed"]
+                if any(indicator in content.lower() for indicator in success_indicators):
+                    outcome = "success"
+                else:
+                    outcome = "unknown"
+    
+    # Deduplicate key actions (keep unique, limit to 10)
+    unique_actions = []
+    for action in key_actions:
+        if action not in unique_actions:
+            unique_actions.append(action)
+        if len(unique_actions) >= 10:
+            break
+    
+    # Deduplicate errors (keep unique, limit to 5)
+    unique_errors = []
+    for error in errors:
+        if error not in unique_errors:
+            unique_errors.append(error)
+        if len(unique_errors) >= 5:
+            break
+    
+    return SessionSummary(
+        session_id=session_id,
+        model=model,
+        repo=repo,
+        outcome=outcome,
+        message_count=len(messages),
+        tool_calls=tool_calls_count,
+        duration_estimate=duration_estimate,
+        key_actions=unique_actions,
+        errors_encountered=unique_errors,
+        start_time=start_time,
+        end_time=end_time,
+        total_tokens_estimate=total_tokens,
+        user_messages=user_messages,
+        assistant_messages=assistant_messages,
+        tool_outputs=tool_outputs
+    )
+
+
+def process_session_directory(directory_path: str, output_file: Optional[str] = None) -> List[SessionSummary]:
+    """
+    Process all JSONL files in a directory.
+    """
+    directory = Path(directory_path)
+    if not directory.exists():
+        print(f"Error: Directory {directory_path} does not exist", file=sys.stderr)
+        return []
+    
+    jsonl_files = list(directory.glob("*.jsonl"))
+    if not jsonl_files:
+        print(f"Warning: No JSONL files found in {directory_path}", file=sys.stderr)
+        return []
+    
+    summaries = []
+    for jsonl_file in sorted(jsonl_files):
+        print(f"Processing {jsonl_file.name}...", file=sys.stderr)
+        summary = extract_session_metadata(str(jsonl_file))
+        summaries.append(summary)
+    
+    if output_file:
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump([asdict(s) for s in summaries], f, indent=2)
+        print(f"Wrote {len(summaries)} summaries to {output_file}", file=sys.stderr)
+    
+    return summaries
+
+
+def main():
+    """CLI entry point."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Extract metadata from Hermes session JSONL transcripts")
+    parser.add_argument("path", help="Path to JSONL file or directory of session files")
+    parser.add_argument("-o", "--output", help="Output JSON file (default: stdout)")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+    
+    args = parser.parse_args()
+    
+    path = Path(args.path)
+    
+    if path.is_file():
+        summary = extract_session_metadata(str(path))
+        if args.output:
+            with open(args.output, 'w') as f:
+                json.dump(asdict(summary), f, indent=2)
+            print(f"Wrote summary to {args.output}", file=sys.stderr)
+        else:
+            print(json.dumps(asdict(summary), indent=2))
+    
+    elif path.is_dir():
+        summaries = process_session_directory(str(path), args.output)
+        if not args.output:
+            print(json.dumps([asdict(s) for s in summaries], indent=2))
+    
+    else:
+        print(f"Error: {args.path} is not a file or directory", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

scripts/test_gitea_issue_parser.py

@@ -1,111 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for gitea_issue_parser."""
-
-import json
-import sys
-import os
-
-sys.path.insert(0, os.path.dirname(__file__))
-from gitea_issue_parser import parse_issue_body
-
-
-def test_basic_structure():
-    body = """## Context
-This is the background.
-
-## Acceptance Criteria
-- [ ] First criterion
-- [x] Second criterion (already done)
-- [ ] Third criterion
-
-## Labels
-`pipeline`, `extraction`
-"""
-    result = parse_issue_body(body, "Test Issue", ["pipeline", "extraction"])
-    assert result["title"] == "Test Issue"
-    assert "background" in result["context"].lower()
-    assert len(result["criteria"]) == 3
-    assert "First criterion" in result["criteria"]
-    assert result["labels"] == ["pipeline", "extraction"]
-    print("PASS: test_basic_structure")
-
-
-def test_epic_ref():
-    body = "Closes #645\n\nSome description."
-    result = parse_issue_body(body, "feat: thing (#688)")
-    assert result["epic_ref"] == "#645"
-    print("PASS: test_epic_ref")
-
-
-def test_epic_ref_from_title():
-    body = "Some description without close ref."
-    result = parse_issue_body(body, "feat: scene descriptions (#645)")
-    assert result["epic_ref"] == "#645"
-    print("PASS: test_epic_ref_from_title")
-
-
-def test_no_checkboxes():
-    body = """## Requirements
-1. First thing
-2. Second thing
-3. Third thing
-"""
-    result = parse_issue_body(body)
-    assert len(result["criteria"]) == 3
-    print("PASS: test_no_checkboxes")
-
-
-def test_empty_body():
-    result = parse_issue_body("", "Empty Issue")
-    assert result["title"] == "Empty Issue"
-    assert result["criteria"] == []
-    assert result["context"] == ""
-    print("PASS: test_empty_body")
-
-
-def test_real_issue_format():
-    body = """Closes #681
-
-## Changes
-
-Add `#!/usr/bin/env python3` shebang to 6 Python scripts.
-
-## Verification
-
-All 6 files confirmed missing shebangs before fix.
-
-## Impact
-
-Scripts can now be executed directly.
-"""
-    result = parse_issue_body(body, "fix: add python3 shebangs (#685)")
-    assert result["epic_ref"] == "#681"
-    assert "shebang" in result["context"].lower()
-    print("PASS: test_real_issue_format")
-
-
-def test_all_sections_captured():
-    body = """## Context
-Background info.
-
-## Acceptance Criteria
-- [ ] Do thing
-
-## Labels
-`test`
-"""
-    result = parse_issue_body(body)
-    assert "context" in result["sections"]
-    assert "acceptance criteria" in result["sections"]
-    print("PASS: test_all_sections_captured")
-
-
-if __name__ == "__main__":
-    test_basic_structure()
-    test_epic_ref()
-    test_epic_ref_from_title()
-    test_no_checkboxes()
-    test_empty_body()
-    test_real_issue_format()
-    test_all_sections_captured()
-    print("\nAll tests passed.")