Self Improving Agent

#!/usr/bin/env python3
"""Feedback Analyzer - Analyze feedback logs to extract patterns and improvement opportunities.

Reads feedback log files (JSON or JSONL format) containing agent session outcomes,
and produces analysis of success rates, failure patterns, and actionable improvement
recommendations based on the Self-Improving Agent feedback loop model.

Expected log entry format:
{
    "session_id": "abc123",
    "timestamp": "2026-03-15T10:30:00",
    "task_type": "code-review",
    "outcome": "SUCCESS|PARTIAL|FAILURE|REJECTION|TIMEOUT|ERROR",
    "corrections": 0,
    "turns": 5,
    "tools_used": ["Read", "Edit", "Bash"],
    "tool_errors": 0,
    "notes": "optional description"
}

Usage:
    python feedback_analyzer.py analyze --input feedback.jsonl
    python feedback_analyzer.py patterns --input feedback.jsonl --min-count 3
    python feedback_analyzer.py trends --input feedback.jsonl --window 7
    python feedback_analyzer.py opportunities --input feedback.jsonl
"""

import argparse
import json
import os
import sys
from collections import Counter, defaultdict
from datetime import datetime, timedelta
from pathlib import Path

VALID_OUTCOMES = ["SUCCESS", "PARTIAL", "FAILURE", "REJECTION", "TIMEOUT", "ERROR"]

THRESHOLDS = {
    "first_attempt_success": 0.70,
    "corrections_per_task": 2.0,
    "tool_error_rate": 0.05,
    "completion_turns": 10,
}


def load_feedback(path: str) -> list:
    """Load feedback entries from JSON or JSONL file."""
    entries = []
    with open(path, "r") as f:
        content = f.read().strip()
        if content.startswith("["):
            entries = json.loads(content)
        else:
            for line in content.splitlines():
                line = line.strip()
                if line:
                    entries.append(json.loads(line))
    for e in entries:
        if "timestamp" in e:
            e["_dt"] = datetime.fromisoformat(e["timestamp"])
    return entries


def cmd_analyze(args, entries: list) -> dict:
    """Produce summary statistics from feedback entries."""
    if not entries:
        return {"action": "analyze", "error": "No entries found"}

    total = len(entries)
    outcome_counts = Counter(e.get("outcome", "UNKNOWN") for e in entries)
    task_type_counts = Counter(e.get("task_type", "unknown") for e in entries)

    successes = outcome_counts.get("SUCCESS", 0)
    first_attempt = sum(1 for e in entries if e.get("outcome") == "SUCCESS" and e.get("corrections", 0) == 0)
    corrections = [e.get("corrections", 0) for e in entries]
    avg_corrections = sum(corrections) / total if total else 0
    turns = [e.get("turns", 0) for e in entries]
    avg_turns = sum(turns) / total if total else 0

    total_tool_calls = sum(len(e.get("tools_used", [])) for e in entries)
    total_tool_errors = sum(e.get("tool_errors", 0) for e in entries)
    tool_error_rate = total_tool_errors / total_tool_calls if total_tool_calls else 0

    # Per-task-type breakdown
    task_breakdown = {}
    for task_type in task_type_counts:
        task_entries = [e for e in entries if e.get("task_type") == task_type]
        t_total = len(task_entries)
        t_success = sum(1 for e in task_entries if e.get("outcome") == "SUCCESS")
        t_first = sum(1 for e in task_entries if e.get("outcome") == "SUCCESS" and e.get("corrections", 0) == 0)
        task_breakdown[task_type] = {
            "total": t_total,
            "success_rate": round(t_success / t_total, 3) if t_total else 0,
            "first_attempt_rate": round(t_first / t_total, 3) if t_total else 0,
            "avg_corrections": round(sum(e.get("corrections", 0) for e in task_entries) / t_total, 2),
        }

    # Health assessment
    health_flags = []
    fa_rate = first_attempt / total if total else 0
    if fa_rate < THRESHOLDS["first_attempt_success"]:
        health_flags.append(f"First-attempt success rate {fa_rate:.1%} below {THRESHOLDS['first_attempt_success']:.0%} threshold")
    if avg_corrections > THRESHOLDS["corrections_per_task"]:
        health_flags.append(f"Avg corrections {avg_corrections:.1f} exceeds {THRESHOLDS['corrections_per_task']} threshold")
    if tool_error_rate > THRESHOLDS["tool_error_rate"]:
        health_flags.append(f"Tool error rate {tool_error_rate:.1%} exceeds {THRESHOLDS['tool_error_rate']:.0%} threshold")

    return {
        "action": "analyze",
        "total_entries": total,
        "outcome_distribution": dict(outcome_counts),
        "success_rate": round(successes / total, 3),
        "first_attempt_success_rate": round(fa_rate, 3),
        "avg_corrections": round(avg_corrections, 2),
        "avg_turns": round(avg_turns, 2),
        "tool_error_rate": round(tool_error_rate, 4),
        "task_breakdown": task_breakdown,
        "health_flags": health_flags,
    }


def cmd_patterns(args, entries: list) -> dict:
    """Extract recurring patterns from feedback data."""
    min_count = args.min_count

    # Failure patterns by task type
    failure_patterns = defaultdict(list)
    for e in entries:
        if e.get("outcome") in ("FAILURE", "REJECTION", "ERROR"):
            failure_patterns[e.get("task_type", "unknown")].append({
                "outcome": e["outcome"],
                "notes": e.get("notes", ""),
                "corrections": e.get("corrections", 0),
                "session_id": e.get("session_id", ""),
            })

    recurring_failures = {
        k: v for k, v in failure_patterns.items() if len(v) >= min_count
    }

    # Correction patterns -- what task types need most corrections
    correction_patterns = defaultdict(list)
    for e in entries:
        if e.get("corrections", 0) > 0:
            correction_patterns[e.get("task_type", "unknown")].append(e.get("corrections", 0))

    high_correction_tasks = {}
    for task_type, corr_list in correction_patterns.items():
        if len(corr_list) >= min_count:
            high_correction_tasks[task_type] = {
                "occurrences": len(corr_list),
                "avg_corrections": round(sum(corr_list) / len(corr_list), 2),
                "max_corrections": max(corr_list),
            }

    # Tool error patterns
    tool_error_patterns = defaultdict(int)
    for e in entries:
        if e.get("tool_errors", 0) > 0:
            for tool in e.get("tools_used", []):
                tool_error_patterns[tool] += 1

    # Success patterns -- what works well
    success_patterns = defaultdict(int)
    for e in entries:
        if e.get("outcome") == "SUCCESS" and e.get("corrections", 0) == 0:
            success_patterns[e.get("task_type", "unknown")] += 1

    return {
        "action": "patterns",
        "min_count_threshold": min_count,
        "recurring_failures": recurring_failures,
        "high_correction_tasks": high_correction_tasks,
        "tool_error_frequency": dict(tool_error_patterns),
        "strong_success_areas": dict(success_patterns),
    }


def cmd_trends(args, entries: list) -> dict:
    """Analyze trends over time using a sliding window."""
    window_days = args.window
    if not entries or "_dt" not in entries[0]:
        return {"action": "trends", "error": "No timestamped entries found"}

    sorted_entries = sorted(entries, key=lambda e: e["_dt"])
    start = sorted_entries[0]["_dt"]
    end = sorted_entries[-1]["_dt"]

    windows = []
    current = start
    while current <= end:
        window_end = current + timedelta(days=window_days)
        window_entries = [e for e in sorted_entries if current <= e["_dt"] < window_end]
        if window_entries:
            total = len(window_entries)
            successes = sum(1 for e in window_entries if e.get("outcome") == "SUCCESS")
            first_att = sum(1 for e in window_entries if e.get("outcome") == "SUCCESS" and e.get("corrections", 0) == 0)
            avg_corr = sum(e.get("corrections", 0) for e in window_entries) / total
            avg_turns = sum(e.get("turns", 0) for e in window_entries) / total
            windows.append({
                "period_start": current.isoformat(),
                "period_end": window_end.isoformat(),
                "entries": total,
                "success_rate": round(successes / total, 3),
                "first_attempt_rate": round(first_att / total, 3),
                "avg_corrections": round(avg_corr, 2),
                "avg_turns": round(avg_turns, 2),
            })
        current = window_end

    # Compute trend direction
    trend_signals = []
    if len(windows) >= 2:
        first_half = windows[: len(windows) // 2]
        second_half = windows[len(windows) // 2 :]
        fa_first = sum(w["first_attempt_rate"] for w in first_half) / len(first_half)
        fa_second = sum(w["first_attempt_rate"] for w in second_half) / len(second_half)
        delta = fa_second - fa_first
        if delta > 0.05:
            trend_signals.append(f"IMPROVING: First-attempt success up {delta:+.1%}")
        elif delta < -0.05:
            trend_signals.append(f"DEGRADING: First-attempt success down {delta:+.1%}")
        else:
            trend_signals.append("STABLE: First-attempt success rate unchanged")

        corr_first = sum(w["avg_corrections"] for w in first_half) / len(first_half)
        corr_second = sum(w["avg_corrections"] for w in second_half) / len(second_half)
        corr_delta = corr_second - corr_first
        if corr_delta > 0.3:
            trend_signals.append(f"WARNING: Avg corrections increasing ({corr_delta:+.2f})")
        elif corr_delta < -0.3:
            trend_signals.append(f"IMPROVING: Avg corrections decreasing ({corr_delta:+.2f})")

    return {
        "action": "trends",
        "window_days": window_days,
        "total_periods": len(windows),
        "windows": windows,
        "trend_signals": trend_signals,
    }


def cmd_opportunities(args, entries: list) -> dict:
    """Identify concrete improvement opportunities from feedback data."""
    opportunities = []

    # Opportunity 1: Task types with low success rates
    task_outcomes = defaultdict(lambda: {"total": 0, "success": 0, "failures": []})
    for e in entries:
        tt = e.get("task_type", "unknown")
        task_outcomes[tt]["total"] += 1
        if e.get("outcome") == "SUCCESS":
            task_outcomes[tt]["success"] += 1
        elif e.get("outcome") in ("FAILURE", "REJECTION"):
            task_outcomes[tt]["failures"].append(e.get("notes", ""))

    for tt, data in task_outcomes.items():
        rate = data["success"] / data["total"] if data["total"] else 0
        if rate < 0.6 and data["total"] >= 3:
            opportunities.append({
                "type": "low_success_task",
                "priority": "high",
                "task_type": tt,
                "success_rate": round(rate, 3),
                "sample_count": data["total"],
                "recommendation": f"Add dedicated rules for '{tt}' tasks -- success rate is {rate:.0%}",
                "failure_notes": [n for n in data["failures"] if n][:3],
            })

    # Opportunity 2: High correction tasks that could benefit from rules
    for e in entries:
        tt = e.get("task_type", "unknown")
    corr_by_type = defaultdict(list)
    for e in entries:
        corr_by_type[e.get("task_type", "unknown")].append(e.get("corrections", 0))
    for tt, corrs in corr_by_type.items():
        avg = sum(corrs) / len(corrs)
        if avg > 1.5 and len(corrs) >= 3:
            opportunities.append({
                "type": "high_correction_task",
                "priority": "medium",
                "task_type": tt,
                "avg_corrections": round(avg, 2),
                "recommendation": f"Capture correction patterns for '{tt}' and promote to rules",
            })

    # Opportunity 3: Tool reliability issues
    tool_stats = defaultdict(lambda: {"uses": 0, "errors": 0})
    for e in entries:
        for tool in e.get("tools_used", []):
            tool_stats[tool]["uses"] += 1
        if e.get("tool_errors", 0) > 0:
            for tool in e.get("tools_used", []):
                tool_stats[tool]["errors"] += 1

    for tool, stats in tool_stats.items():
        err_rate = stats["errors"] / stats["uses"] if stats["uses"] else 0
        if err_rate > 0.1 and stats["uses"] >= 5:
            opportunities.append({
                "type": "tool_reliability",
                "priority": "medium",
                "tool": tool,
                "error_rate": round(err_rate, 3),
                "uses": stats["uses"],
                "recommendation": f"Investigate '{tool}' reliability -- {err_rate:.0%} error rate",
            })

    # Opportunity 4: Timeout tasks suggesting scope issues
    timeout_count = sum(1 for e in entries if e.get("outcome") == "TIMEOUT")
    if timeout_count >= 2:
        opportunities.append({
            "type": "timeout_pattern",
            "priority": "high",
            "count": timeout_count,
            "recommendation": "Review task scoping -- multiple timeouts suggest tasks are too large or under-specified",
        })

    opportunities.sort(key=lambda o: {"high": 0, "medium": 1, "low": 2}.get(o["priority"], 3))
    return {"action": "opportunities", "count": len(opportunities), "opportunities": opportunities}


def format_human(result: dict) -> str:
    """Format result for human-readable output."""
    action = result.get("action", "unknown")
    lines = []

    if "error" in result:
        return f"Error: {result['error']}"

    if action == "analyze":
        lines.append(f"Feedback Analysis ({result['total_entries']} entries)")
        lines.append("=" * 50)
        lines.append(f"  Success rate:           {result['success_rate']:.1%}")
        lines.append(f"  First-attempt success:  {result['first_attempt_success_rate']:.1%}")
        lines.append(f"  Avg corrections/task:   {result['avg_corrections']:.2f}")
        lines.append(f"  Avg turns/task:         {result['avg_turns']:.1f}")
        lines.append(f"  Tool error rate:        {result['tool_error_rate']:.2%}")
        lines.append("")
        lines.append("Outcome Distribution:")
        for outcome, count in sorted(result["outcome_distribution"].items()):
            bar = "#" * min(count, 40)
            lines.append(f"  {outcome:<12} {count:>4}  {bar}")
        lines.append("")
        lines.append("Per-Task Breakdown:")
        for tt, stats in sorted(result["task_breakdown"].items()):
            lines.append(f"  {tt}: {stats['total']} tasks, {stats['success_rate']:.0%} success, {stats['avg_corrections']:.1f} avg corrections")
        if result["health_flags"]:
            lines.append("")
            lines.append("Health Warnings:")
            for flag in result["health_flags"]:
                lines.append(f"  [!] {flag}")

    elif action == "patterns":
        lines.append("Feedback Patterns")
        lines.append("=" * 50)
        if result["recurring_failures"]:
            lines.append("Recurring Failures:")
            for tt, failures in result["recurring_failures"].items():
                lines.append(f"  {tt}: {len(failures)} occurrences")
        if result["high_correction_tasks"]:
            lines.append("High-Correction Tasks:")
            for tt, stats in result["high_correction_tasks"].items():
                lines.append(f"  {tt}: avg {stats['avg_corrections']} corrections ({stats['occurrences']} occurrences)")
        if result["strong_success_areas"]:
            lines.append("Strong Areas (first-attempt success):")
            for tt, count in sorted(result["strong_success_areas"].items(), key=lambda x: -x[1]):
                lines.append(f"  {tt}: {count} first-attempt successes")

    elif action == "trends":
        lines.append(f"Trend Analysis ({result['window_days']}-day windows)")
        lines.append("=" * 50)
        for w in result["windows"]:
            lines.append(f"  {w['period_start'][:10]} - {w['period_end'][:10]}: "
                         f"{w['entries']} entries, {w['success_rate']:.0%} success, "
                         f"{w['avg_corrections']:.1f} avg corrections")
        if result["trend_signals"]:
            lines.append("")
            for signal in result["trend_signals"]:
                lines.append(f"  >> {signal}")

    elif action == "opportunities":
        lines.append(f"Improvement Opportunities ({result['count']} found)")
        lines.append("=" * 50)
        for i, opp in enumerate(result["opportunities"], 1):
            lines.append(f"\n  {i}. [{opp['priority'].upper()}] {opp['type']}")
            lines.append(f"     {opp['recommendation']}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(
        description="Feedback Analyzer - Extract patterns and opportunities from agent feedback logs",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output in JSON format")

    sub = parser.add_subparsers(dest="command", help="Available commands")

    p_analyze = sub.add_parser("analyze", help="Summary statistics of feedback data")
    p_analyze.add_argument("--input", required=True, help="Path to feedback log file (JSON or JSONL)")

    p_patterns = sub.add_parser("patterns", help="Extract recurring patterns")
    p_patterns.add_argument("--input", required=True, help="Path to feedback log file")
    p_patterns.add_argument("--min-count", type=int, default=3, help="Minimum occurrences to flag a pattern")

    p_trends = sub.add_parser("trends", help="Analyze trends over time")
    p_trends.add_argument("--input", required=True, help="Path to feedback log file")
    p_trends.add_argument("--window", type=int, default=7, help="Window size in days")

    p_opp = sub.add_parser("opportunities", help="Identify improvement opportunities")
    p_opp.add_argument("--input", required=True, help="Path to feedback log file")

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        sys.exit(1)

    if not os.path.exists(args.input):
        print(f"Error: Input file '{args.input}' not found", file=sys.stderr)
        sys.exit(1)

    entries = load_feedback(args.input)

    commands = {
        "analyze": cmd_analyze,
        "patterns": cmd_patterns,
        "trends": cmd_trends,
        "opportunities": cmd_opportunities,
    }

    result = commands[args.command](args, entries)

    # Remove internal fields before output
    if "rules" in result or "windows" in result or "opportunities" in result:
        pass  # keep structured data
    for entry_list_key in ["recurring_failures"]:
        if entry_list_key in result:
            for key, val_list in result[entry_list_key].items():
                for v in val_list:
                    v.pop("_dt", None)

    if args.json_output:
        print(json.dumps(result, indent=2, default=str))
    else:
        print(format_human(result))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Check memory system health: line counts, stale entries, contradictions.

Scans MEMORY.md and related files for health issues including line limit
violations, stale references, duplicate entries, and promotion candidates.
Produces an actionable health report.

Usage:
    python memory_health_checker.py --memory ./MEMORY.md
    python memory_health_checker.py --memory ./MEMORY.md --rules ./.claude/rules/
    python memory_health_checker.py --memory ./MEMORY.md --json
"""

import argparse
import json
import os
import re
import sys
from collections import defaultdict
from datetime import datetime, timedelta
from pathlib import Path


MEMORY_LINE_LIMIT = 200
TOPIC_FILE_LINE_LIMIT = 100
STALE_AGE_DAYS = 90
PROMOTION_THRESHOLD = 3


def load_memory_file(path):
    """Load and parse a memory file into structured entries."""
    if not os.path.exists(path):
        return {"path": path, "exists": False, "lines": 0, "entries": []}

    content = Path(path).read_text(encoding="utf-8")
    lines = content.split("\n")
    entries = []
    current_entry = None

    for i, line in enumerate(lines, 1):
        # Detect entry headers (## Learning: or ## heading)
        if line.startswith("## "):
            if current_entry:
                current_entry["end_line"] = i - 1
                entries.append(current_entry)
            current_entry = {
                "title": line.lstrip("# ").strip(),
                "start_line": i,
                "end_line": None,
                "content_lines": [],
                "metadata": {},
            }
        elif current_entry:
            current_entry["content_lines"].append(line)
            # Extract metadata from key-value lines
            kv_match = re.match(r"\*\*(\w[\w\s]*)\*\*:\s*(.+)", line)
            if kv_match:
                key = kv_match.group(1).strip().lower()
                value = kv_match.group(2).strip()
                current_entry["metadata"][key] = value

    if current_entry:
        current_entry["end_line"] = len(lines)
        entries.append(current_entry)

    return {
        "path": str(path),
        "exists": True,
        "lines": len(lines),
        "entries": entries,
    }


def load_rules(rules_dir):
    """Load existing promoted rules for comparison."""
    rules = []
    rules_path = Path(rules_dir)
    if not rules_path.exists():
        return rules

    for rule_file in rules_path.glob("*.md"):
        content = rule_file.read_text(encoding="utf-8")
        rules.append({
            "file": str(rule_file),
            "content": content,
            "tokens": set(re.findall(r"[a-zA-Z_]{3,}", content.lower())),
        })

    return rules


def classify_entry(entry, existing_rules, all_entries):
    """Classify a memory entry into PROMOTE, CONSOLIDATE, STALE, KEEP, or EXTRACT."""
    title = entry["title"].lower()
    metadata = entry["metadata"]
    content_text = " ".join(entry["content_lines"]).lower()
    entry_tokens = set(re.findall(r"[a-zA-Z_]{3,}", content_text))

    issues = []
    classification = "KEEP"

    # Check recurrence for promotion
    recurrence_str = metadata.get("recurrence", "")
    recurrence_count = 0
    match = re.search(r"(\d+)", recurrence_str)
    if match:
        recurrence_count = int(match.group(1))

    if recurrence_count >= PROMOTION_THRESHOLD:
        classification = "PROMOTE"
        issues.append(f"Recurrence {recurrence_count} meets promotion threshold ({PROMOTION_THRESHOLD})")

    # Check for explicit action metadata
    action = metadata.get("action", "").upper()
    if action == "PROMOTE":
        classification = "PROMOTE"
    elif action == "EXTRACT":
        classification = "EXTRACT"

    # Check for stale entries (references to deleted files, old dates)
    confidence = metadata.get("confidence", "").lower()
    if confidence == "low":
        issues.append("Low confidence entry")
        if classification == "KEEP":
            classification = "STALE"

    # Check for duplicates / consolidation candidates
    for other in all_entries:
        if other is entry:
            continue
        other_tokens = set(re.findall(r"[a-zA-Z_]{3,}", " ".join(other["content_lines"]).lower()))
        if entry_tokens and other_tokens:
            overlap = len(entry_tokens & other_tokens) / max(len(entry_tokens | other_tokens), 1)
            if overlap > 0.6:
                if classification in ("KEEP", "STALE"):
                    classification = "CONSOLIDATE"
                issues.append(f"Similar to entry: {other['title'][:40]}")
                break

    # Check if already promoted (redundant in memory)
    for rule in existing_rules:
        overlap = len(entry_tokens & rule["tokens"]) / max(len(entry_tokens | rule["tokens"]), 1)
        if overlap > 0.5:
            classification = "STALE"
            issues.append(f"Already promoted to: {rule['file']}")
            break

    return {
        "title": entry["title"],
        "start_line": entry["start_line"],
        "classification": classification,
        "recurrence": recurrence_count,
        "issues": issues,
    }


def check_constraints(memory_data, topic_files):
    """Check system-wide constraints."""
    violations = []

    if memory_data["lines"] > MEMORY_LINE_LIMIT:
        violations.append({
            "type": "line_limit",
            "file": memory_data["path"],
            "current": memory_data["lines"],
            "limit": MEMORY_LINE_LIMIT,
            "severity": "high",
        })

    for tf in topic_files:
        if tf["lines"] > TOPIC_FILE_LINE_LIMIT:
            violations.append({
                "type": "line_limit",
                "file": tf["path"],
                "current": tf["lines"],
                "limit": TOPIC_FILE_LINE_LIMIT,
                "severity": "medium",
            })

    return violations


def run_health_check(memory_path, rules_dir, topic_dir):
    """Run complete health check."""
    memory_data = load_memory_file(memory_path)
    if not memory_data["exists"]:
        return {
            "status": "NO_MEMORY",
            "message": f"No memory file found at {memory_path}",
            "maturity_level": 0,
        }

    # Load topic files
    topic_files = []
    if topic_dir and os.path.isdir(topic_dir):
        for tf in Path(topic_dir).glob("*.md"):
            topic_files.append(load_memory_file(tf))

    # Load rules
    existing_rules = load_rules(rules_dir) if rules_dir else []

    # Classify entries
    classifications = []
    for entry in memory_data["entries"]:
        cls = classify_entry(entry, existing_rules, memory_data["entries"])
        classifications.append(cls)

    # Count by classification
    counts = defaultdict(int)
    for c in classifications:
        counts[c["classification"]] += 1

    # Check constraints
    violations = check_constraints(memory_data, topic_files)

    # Determine health status
    if violations and any(v["severity"] == "high" for v in violations):
        health_status = "CRITICAL"
    elif counts["STALE"] > 5 or counts["CONSOLIDATE"] > 5:
        health_status = "NEEDS_ATTENTION"
    elif counts["PROMOTE"] > 0:
        health_status = "GOOD_WITH_ACTIONS"
    else:
        health_status = "HEALTHY"

    # Determine maturity level
    if not memory_data["entries"]:
        maturity = 1  # Recording (file exists but empty-ish)
    elif counts["PROMOTE"] > 0 or len(existing_rules) > 0:
        maturity = 3  # Promoting
    elif counts["CONSOLIDATE"] > 0 or counts["STALE"] > 0:
        maturity = 2  # Curating
    else:
        maturity = 1  # Recording

    return {
        "status": health_status,
        "maturity_level": maturity,
        "memory_file": {
            "path": memory_data["path"],
            "lines": memory_data["lines"],
            "line_limit": MEMORY_LINE_LIMIT,
            "entry_count": len(memory_data["entries"]),
        },
        "topic_files": [{"path": tf["path"], "lines": tf["lines"]} for tf in topic_files],
        "classifications": classifications,
        "counts": dict(counts),
        "constraint_violations": violations,
        "existing_rules": len(existing_rules),
    }


def format_human(result):
    """Format health check result for human output."""
    output = []
    output.append("=" * 60)
    output.append("MEMORY HEALTH CHECK")
    output.append("=" * 60)

    if result["status"] == "NO_MEMORY":
        output.append(f"  {result['message']}")
        output.append(f"  Maturity Level: 0 (Stateless)")
        return "\n".join(output)

    mf = result["memory_file"]
    maturity_names = {0: "Stateless", 1: "Recording", 2: "Curating", 3: "Promoting", 4: "Extracting", 5: "Meta-Learning"}
    output.append(f"  Status:         {result['status']}")
    output.append(f"  Maturity Level: {result['maturity_level']} ({maturity_names.get(result['maturity_level'], '?')})")
    output.append(f"  Memory file:    {mf['path']}")
    output.append(f"  Lines:          {mf['lines']}/{mf['line_limit']}")
    output.append(f"  Entries:        {mf['entry_count']}")
    output.append(f"  Existing rules: {result['existing_rules']}")
    output.append("")

    # Classification summary
    output.append("ENTRY CLASSIFICATIONS")
    output.append("-" * 60)
    counts = result["counts"]
    order = ["PROMOTE", "CONSOLIDATE", "STALE", "KEEP", "EXTRACT", "CONTRADICTION"]
    for cls in order:
        count = counts.get(cls, 0)
        if count > 0:
            marker = {"PROMOTE": ">>", "STALE": "xx", "CONSOLIDATE": "==", "EXTRACT": "->", "KEEP": "  "}.get(cls, "  ")
            output.append(f"  {marker} {cls:<15} {count}")
    output.append("")

    # Detailed classifications
    actionable = [c for c in result["classifications"] if c["classification"] != "KEEP"]
    if actionable:
        output.append("ACTIONABLE ENTRIES")
        output.append("-" * 60)
        for c in actionable:
            output.append(f"  [{c['classification']}] Line {c['start_line']}: {c['title'][:50]}")
            for issue in c["issues"]:
                output.append(f"    - {issue}")
        output.append("")

    # Constraint violations
    if result["constraint_violations"]:
        output.append("CONSTRAINT VIOLATIONS")
        output.append("-" * 60)
        for v in result["constraint_violations"]:
            output.append(f"  [{v['severity'].upper()}] {v['file']}: {v['current']} lines (limit: {v['limit']})")
        output.append("")

    return "\n".join(output)


def main():
    parser = argparse.ArgumentParser(
        description="Check memory system health: line counts, stale entries, contradictions.",
        epilog="Example: python memory_health_checker.py --memory ./MEMORY.md --rules ./.claude/rules/",
    )
    parser.add_argument("--memory", required=True, help="Path to MEMORY.md file")
    parser.add_argument("--rules", default=None, help="Path to rules directory (.claude/rules/)")
    parser.add_argument("--topics", default=None, help="Path to topic memory files directory")
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output as JSON")

    args = parser.parse_args()

    result = run_health_check(args.memory, args.rules, args.topics)

    if args.json_output:
        print(json.dumps(result, indent=2))
    else:
        print(format_human(result))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Extract reusable patterns from agent session logs.

Analyzes JSONL session logs to identify recurring approaches, error resolutions,
and workflow patterns. Scores each pattern by frequency, consistency, and impact
to recommend which patterns should be promoted to rules.

Expected log entry format (JSONL):
{"session_id": "s1", "task_type": "code-review", "outcome": "SUCCESS",
 "approach": "used page objects", "corrections": 0, "error_resolved": "",
 "tools_used": ["Read", "Edit"], "notes": ""}

Usage:
    python pattern_extractor.py --input sessions.jsonl --min-occurrences 2
    python pattern_extractor.py --input sessions.jsonl --min-occurrences 3 --json
    python pattern_extractor.py --input sessions.jsonl --days 30
"""

import argparse
import json
import re
import sys
from collections import Counter, defaultdict
from datetime import datetime, timedelta
from pathlib import Path


def load_sessions(path, max_days=None):
    """Load session log entries from JSONL file."""
    entries = []
    with open(path, "r") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            try:
                entry = json.loads(line)
                if "timestamp" in entry:
                    entry["_dt"] = datetime.fromisoformat(entry["timestamp"])
                entries.append(entry)
            except json.JSONDecodeError:
                continue

    if max_days and entries:
        cutoff = datetime.now() - timedelta(days=max_days)
        entries = [e for e in entries if e.get("_dt", datetime.max) >= cutoff]

    return entries


def tokenize(text):
    """Extract meaningful tokens from text for similarity matching."""
    if not text:
        return set()
    words = re.findall(r"[a-zA-Z_][a-zA-Z0-9_]{2,}", text.lower())
    stop_words = {"the", "and", "for", "with", "from", "that", "this", "was", "used", "using"}
    return set(words) - stop_words


def compute_similarity(tokens_a, tokens_b):
    """Jaccard similarity between two token sets."""
    if not tokens_a or not tokens_b:
        return 0.0
    intersection = tokens_a & tokens_b
    union = tokens_a | tokens_b
    return len(intersection) / len(union)


def cluster_approaches(entries, similarity_threshold=0.4):
    """Cluster similar approaches into pattern groups."""
    # Extract approach descriptions
    approaches = []
    for e in entries:
        approach_text = e.get("approach", "") or e.get("notes", "")
        if approach_text:
            approaches.append({
                "text": approach_text,
                "tokens": tokenize(approach_text),
                "entry": e,
            })

    if not approaches:
        return []

    # Simple greedy clustering
    clusters = []
    assigned = set()

    for i, a in enumerate(approaches):
        if i in assigned:
            continue
        cluster = [a]
        assigned.add(i)

        for j, b in enumerate(approaches):
            if j in assigned:
                continue
            sim = compute_similarity(a["tokens"], b["tokens"])
            if sim >= similarity_threshold:
                cluster.append(b)
                assigned.add(j)

        if len(cluster) >= 1:
            clusters.append(cluster)

    return clusters


def extract_error_patterns(entries, min_count=2):
    """Extract recurring error resolution patterns."""
    error_resolutions = defaultdict(list)

    for e in entries:
        error = e.get("error_resolved", "")
        if error:
            error_tokens = frozenset(tokenize(error))
            if error_tokens:
                error_resolutions[error_tokens].append({
                    "error": error,
                    "task_type": e.get("task_type", "unknown"),
                    "outcome": e.get("outcome", "unknown"),
                    "session_id": e.get("session_id", ""),
                })

    # Filter by minimum count
    recurring = {}
    for tokens, resolutions in error_resolutions.items():
        if len(resolutions) >= min_count:
            # Use the first error text as representative
            recurring[resolutions[0]["error"]] = {
                "count": len(resolutions),
                "task_types": list(set(r["task_type"] for r in resolutions)),
                "success_rate": sum(1 for r in resolutions if r["outcome"] == "SUCCESS") / len(resolutions),
            }

    return recurring


def extract_tool_patterns(entries, min_count=2):
    """Extract recurring tool usage sequences."""
    tool_sequences = Counter()

    for e in entries:
        tools = e.get("tools_used", [])
        if len(tools) >= 2:
            # Use ordered pairs as a simple sequence fingerprint
            for i in range(len(tools) - 1):
                pair = f"{tools[i]} -> {tools[i + 1]}"
                tool_sequences[pair] += 1

    return {seq: count for seq, count in tool_sequences.items() if count >= min_count}


def score_pattern(cluster):
    """Score a pattern cluster on frequency, consistency, and impact."""
    entries = [item["entry"] for item in cluster]
    count = len(entries)

    # Frequency score (0-1)
    if count >= 7:
        frequency = 1.0
    elif count >= 4:
        frequency = 0.7
    elif count >= 2:
        frequency = 0.4
    else:
        frequency = 0.1

    # Consistency score: what fraction had the same outcome
    outcomes = [e.get("outcome", "unknown") for e in entries]
    most_common_outcome = Counter(outcomes).most_common(1)[0]
    consistency = most_common_outcome[1] / len(outcomes) if outcomes else 0

    # Impact score: based on outcome quality
    successes = sum(1 for e in entries if e.get("outcome") == "SUCCESS")
    zero_corrections = sum(1 for e in entries if e.get("corrections", 0) == 0 and e.get("outcome") == "SUCCESS")
    impact = zero_corrections / count if count > 0 else 0

    composite = round(frequency * 0.3 + consistency * 0.4 + impact * 0.3, 3)

    return {
        "frequency": round(frequency, 3),
        "consistency": round(consistency, 3),
        "impact": round(impact, 3),
        "composite": composite,
    }


def determine_recommendation(score, count):
    """Determine recommended action based on score."""
    if score["composite"] >= 0.7 and count >= 3:
        return "PROMOTE"
    elif score["composite"] >= 0.5 and count >= 5:
        return "PROMOTE"
    elif score["composite"] >= 0.4:
        return "KEEP"
    else:
        return "MONITOR"


def extract_patterns(entries, min_occurrences):
    """Main pattern extraction pipeline."""
    clusters = cluster_approaches(entries, similarity_threshold=0.35)
    error_patterns = extract_error_patterns(entries, min_occurrences)
    tool_patterns = extract_tool_patterns(entries, min_occurrences)

    # Score and rank approach patterns
    approach_patterns = []
    for cluster in clusters:
        if len(cluster) < min_occurrences:
            continue
        score = score_pattern(cluster)
        representative = cluster[0]["text"]
        recommendation = determine_recommendation(score, len(cluster))
        task_types = list(set(item["entry"].get("task_type", "unknown") for item in cluster))

        approach_patterns.append({
            "pattern": representative,
            "occurrences": len(cluster),
            "task_types": task_types,
            "scores": score,
            "recommendation": recommendation,
        })

    approach_patterns.sort(key=lambda p: -p["scores"]["composite"])

    return {
        "approach_patterns": approach_patterns,
        "error_patterns": error_patterns,
        "tool_patterns": tool_patterns,
    }


def format_human(results, total_entries):
    """Format results for human-readable output."""
    output = []
    output.append("=" * 60)
    output.append("PATTERN EXTRACTOR")
    output.append("=" * 60)
    output.append(f"  Sessions analyzed: {total_entries}")
    output.append(f"  Approach patterns: {len(results['approach_patterns'])}")
    output.append(f"  Error patterns:    {len(results['error_patterns'])}")
    output.append(f"  Tool patterns:     {len(results['tool_patterns'])}")
    output.append("")

    if results["approach_patterns"]:
        output.append("APPROACH PATTERNS (ranked by composite score)")
        output.append("-" * 60)
        for i, p in enumerate(results["approach_patterns"], 1):
            rec_marker = {"PROMOTE": ">>", "KEEP": "  ", "MONITOR": ".."}
            marker = rec_marker.get(p["recommendation"], "  ")
            output.append(f"  {marker} {i}. [{p['recommendation']}] (score={p['scores']['composite']:.2f}, n={p['occurrences']})")
            output.append(f"     {p['pattern'][:70]}")
            output.append(f"     Tasks: {', '.join(p['task_types'][:4])}")
            output.append("")

    if results["error_patterns"]:
        output.append("ERROR RESOLUTION PATTERNS")
        output.append("-" * 60)
        for error, data in sorted(results["error_patterns"].items(), key=lambda x: -x[1]["count"]):
            output.append(f"  [{data['count']}x] {error[:60]}")
            output.append(f"    Success rate: {data['success_rate']:.0%} | Tasks: {', '.join(data['task_types'][:3])}")
        output.append("")

    if results["tool_patterns"]:
        output.append("TOOL SEQUENCE PATTERNS")
        output.append("-" * 60)
        for seq, count in sorted(results["tool_patterns"].items(), key=lambda x: -x[1]):
            output.append(f"  [{count}x] {seq}")
        output.append("")

    promote_count = sum(1 for p in results["approach_patterns"] if p["recommendation"] == "PROMOTE")
    if promote_count:
        output.append(f"ACTION: {promote_count} patterns ready for promotion review")
    else:
        output.append("ACTION: No patterns ready for promotion yet -- continue monitoring")

    return "\n".join(output)


def main():
    parser = argparse.ArgumentParser(
        description="Extract reusable patterns from agent session logs.",
        epilog="Example: python pattern_extractor.py --input sessions.jsonl --min-occurrences 3",
    )
    parser.add_argument("--input", required=True, help="Path to JSONL session log file")
    parser.add_argument("--min-occurrences", type=int, default=2, help="Minimum pattern frequency (default: 2)")
    parser.add_argument("--days", type=int, default=None, help="Only analyze sessions within N days")
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output as JSON")

    args = parser.parse_args()

    if not Path(args.input).exists():
        print(f"Error: Input file '{args.input}' not found.", file=sys.stderr)
        sys.exit(1)

    entries = load_sessions(args.input, max_days=args.days)
    if not entries:
        print("No session entries found.", file=sys.stderr)
        sys.exit(1)

    results = extract_patterns(entries, args.min_occurrences)

    if args.json_output:
        print(json.dumps(results, indent=2, default=str))
    else:
        print(format_human(results, len(entries)))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Regression Detector - Compare before/after performance metrics to detect regressions.

Compares two sets of performance data (baseline vs current) to identify
regressions caused by rule changes, memory updates, or other modifications
to the self-improving agent's knowledge base.

Input format (JSON file with baseline and current periods):
{
    "baseline": {
        "period": "2026-02-01 to 2026-02-15",
        "sessions": [
            {
                "session_id": "s1",
                "task_type": "code-review",
                "outcome": "SUCCESS",
                "corrections": 0,
                "turns": 4,
                "tool_calls": 12,
                "tool_errors": 0,
                "context_items_retrieved": 5,
                "context_items_used": 4
            }
        ]
    },
    "current": {
        "period": "2026-03-01 to 2026-03-15",
        "sessions": [ ... ]
    },
    "changes": [
        {"type": "rule_added", "description": "Added style guide enforcement rule"},
        {"type": "rule_promoted", "description": "Promoted pnpm preference to CLAUDE.md"}
    ]
}

Usage:
    python regression_detector.py compare --input metrics.json
    python regression_detector.py diagnose --input metrics.json --metric first_attempt_rate
    python regression_detector.py report --input metrics.json
"""

import argparse
import json
import os
import sys
from collections import defaultdict
from datetime import datetime

# Thresholds from the SKILL.md regression detection framework
REGRESSION_THRESHOLDS = {
    "first_attempt_rate": {"direction": "higher_is_better", "warning": -0.05, "critical": -0.10},
    "success_rate": {"direction": "higher_is_better", "warning": -0.05, "critical": -0.10},
    "avg_corrections": {"direction": "lower_is_better", "warning": 0.5, "critical": 1.0},
    "tool_error_rate": {"direction": "lower_is_better", "warning": 0.02, "critical": 0.05},
    "avg_turns": {"direction": "lower_is_better", "warning": 2.0, "critical": 4.0},
    "context_relevance": {"direction": "higher_is_better", "warning": -0.10, "critical": -0.20},
}


def load_data(path: str) -> dict:
    """Load comparison data from JSON file."""
    with open(path, "r") as f:
        return json.load(f)


def compute_metrics(sessions: list) -> dict:
    """Compute aggregate metrics from a list of sessions."""
    if not sessions:
        return {}

    total = len(sessions)
    successes = sum(1 for s in sessions if s.get("outcome") == "SUCCESS")
    first_attempt = sum(
        1 for s in sessions
        if s.get("outcome") == "SUCCESS" and s.get("corrections", 0) == 0
    )
    corrections = [s.get("corrections", 0) for s in sessions]
    turns = [s.get("turns", 0) for s in sessions]
    tool_calls = sum(s.get("tool_calls", 0) for s in sessions)
    tool_errors = sum(s.get("tool_errors", 0) for s in sessions)
    ctx_retrieved = sum(s.get("context_items_retrieved", 0) for s in sessions)
    ctx_used = sum(s.get("context_items_used", 0) for s in sessions)

    return {
        "total_sessions": total,
        "success_rate": round(successes / total, 4) if total else 0,
        "first_attempt_rate": round(first_attempt / total, 4) if total else 0,
        "avg_corrections": round(sum(corrections) / total, 3) if total else 0,
        "avg_turns": round(sum(turns) / total, 2) if total else 0,
        "tool_error_rate": round(tool_errors / tool_calls, 4) if tool_calls else 0,
        "context_relevance": round(ctx_used / ctx_retrieved, 4) if ctx_retrieved else 0,
        "outcome_distribution": {
            outcome: sum(1 for s in sessions if s.get("outcome") == outcome)
            for outcome in ["SUCCESS", "PARTIAL", "FAILURE", "REJECTION", "TIMEOUT", "ERROR"]
            if any(s.get("outcome") == outcome for s in sessions)
        },
    }


def compute_per_task_metrics(sessions: list) -> dict:
    """Compute metrics broken down by task type."""
    by_type = defaultdict(list)
    for s in sessions:
        by_type[s.get("task_type", "unknown")].append(s)
    return {tt: compute_metrics(ss) for tt, ss in by_type.items()}


def classify_delta(metric_name: str, delta: float) -> str:
    """Classify a metric delta as ok, warning, or critical."""
    threshold = REGRESSION_THRESHOLDS.get(metric_name)
    if not threshold:
        return "unknown"

    direction = threshold["direction"]
    if direction == "higher_is_better":
        effective_delta = delta  # negative = regression
    else:
        effective_delta = -delta  # positive = regression for lower-is-better

    if effective_delta <= threshold["critical"]:
        return "critical"
    elif effective_delta <= threshold["warning"]:
        return "warning"
    return "ok"


def cmd_compare(args, data: dict) -> dict:
    """Compare baseline vs current metrics and flag regressions."""
    baseline_metrics = compute_metrics(data["baseline"]["sessions"])
    current_metrics = compute_metrics(data["current"]["sessions"])

    comparisons = []
    regressions = []

    for metric in REGRESSION_THRESHOLDS:
        b_val = baseline_metrics.get(metric, 0)
        c_val = current_metrics.get(metric, 0)
        delta = c_val - b_val
        severity = classify_delta(metric, delta)

        entry = {
            "metric": metric,
            "baseline": b_val,
            "current": c_val,
            "delta": round(delta, 4),
            "severity": severity,
        }
        comparisons.append(entry)
        if severity in ("warning", "critical"):
            regressions.append(entry)

    # Per-task-type comparison
    baseline_by_task = compute_per_task_metrics(data["baseline"]["sessions"])
    current_by_task = compute_per_task_metrics(data["current"]["sessions"])
    all_tasks = set(list(baseline_by_task.keys()) + list(current_by_task.keys()))

    task_regressions = []
    for tt in sorted(all_tasks):
        b = baseline_by_task.get(tt, {})
        c = current_by_task.get(tt, {})
        b_rate = b.get("success_rate", 0)
        c_rate = c.get("success_rate", 0)
        delta = c_rate - b_rate
        if delta < -0.1:
            task_regressions.append({
                "task_type": tt,
                "baseline_success": b_rate,
                "current_success": c_rate,
                "delta": round(delta, 4),
            })

    return {
        "action": "compare",
        "baseline_period": data["baseline"].get("period", "unknown"),
        "current_period": data["current"].get("period", "unknown"),
        "baseline_sessions": baseline_metrics["total_sessions"],
        "current_sessions": current_metrics["total_sessions"],
        "comparisons": comparisons,
        "regressions": regressions,
        "task_regressions": task_regressions,
        "regression_detected": len(regressions) > 0,
        "changes_applied": data.get("changes", []),
    }


def cmd_diagnose(args, data: dict) -> dict:
    """Diagnose a specific metric regression by analyzing contributing factors."""
    metric = args.metric
    if metric not in REGRESSION_THRESHOLDS:
        return {"action": "diagnose", "error": f"Unknown metric: {metric}. Valid: {list(REGRESSION_THRESHOLDS.keys())}"}

    baseline_sessions = data["baseline"]["sessions"]
    current_sessions = data["current"]["sessions"]
    baseline_metrics = compute_metrics(baseline_sessions)
    current_metrics = compute_metrics(current_sessions)

    b_val = baseline_metrics.get(metric, 0)
    c_val = current_metrics.get(metric, 0)
    delta = c_val - b_val
    severity = classify_delta(metric, delta)

    # Identify which task types contributed most to the regression
    baseline_by_task = compute_per_task_metrics(baseline_sessions)
    current_by_task = compute_per_task_metrics(current_sessions)

    contributing_tasks = []
    for tt in set(list(baseline_by_task.keys()) + list(current_by_task.keys())):
        b = baseline_by_task.get(tt, {}).get(metric, 0)
        c = current_by_task.get(tt, {}).get(metric, 0)
        task_delta = c - b
        task_severity = classify_delta(metric, task_delta)
        if task_severity != "ok":
            contributing_tasks.append({
                "task_type": tt,
                "baseline": b,
                "current": c,
                "delta": round(task_delta, 4),
                "severity": task_severity,
            })

    contributing_tasks.sort(key=lambda x: abs(x["delta"]), reverse=True)

    # Generate recommendations
    recommendations = []
    changes = data.get("changes", [])

    if severity == "critical":
        recommendations.append("ROLLBACK: Consider reverting recent rule changes immediately")
    if contributing_tasks:
        top = contributing_tasks[0]
        recommendations.append(f"INVESTIGATE: '{top['task_type']}' tasks show largest regression ({top['delta']:+.2%})")
    if changes:
        recommendations.append(f"REVIEW: {len(changes)} changes applied between periods -- test each in isolation")
    recommendations.append(f"MONITOR: Track '{metric}' for next 3 sessions after any fix")

    return {
        "action": "diagnose",
        "metric": metric,
        "baseline_value": b_val,
        "current_value": c_val,
        "delta": round(delta, 4),
        "severity": severity,
        "contributing_tasks": contributing_tasks,
        "changes_between_periods": changes,
        "recommendations": recommendations,
    }


def cmd_report(args, data: dict) -> dict:
    """Generate a full regression report combining comparison and diagnosis."""
    compare_result = cmd_compare(args, data)

    diagnosed = []
    for reg in compare_result["regressions"]:
        diag_args = argparse.Namespace(metric=reg["metric"], input=args.input)
        diagnosis = cmd_diagnose(diag_args, data)
        diagnosed.append(diagnosis)

    overall_status = "PASS"
    if any(r["severity"] == "critical" for r in compare_result["regressions"]):
        overall_status = "CRITICAL"
    elif compare_result["regressions"]:
        overall_status = "WARNING"

    return {
        "action": "report",
        "overall_status": overall_status,
        "baseline_period": compare_result["baseline_period"],
        "current_period": compare_result["current_period"],
        "summary": {
            "total_metrics_checked": len(compare_result["comparisons"]),
            "regressions_found": len(compare_result["regressions"]),
            "critical_regressions": sum(1 for r in compare_result["regressions"] if r["severity"] == "critical"),
            "warning_regressions": sum(1 for r in compare_result["regressions"] if r["severity"] == "warning"),
            "task_type_regressions": len(compare_result["task_regressions"]),
        },
        "comparisons": compare_result["comparisons"],
        "diagnoses": diagnosed,
        "changes_applied": compare_result["changes_applied"],
        "generated_at": datetime.now().isoformat(),
    }


def format_human(result: dict) -> str:
    """Format result for human-readable output."""
    action = result.get("action", "unknown")
    lines = []

    if "error" in result:
        return f"Error: {result['error']}"

    if action == "compare":
        status = "REGRESSION DETECTED" if result["regression_detected"] else "NO REGRESSION"
        lines.append(f"Regression Comparison: {status}")
        lines.append(f"  Baseline: {result['baseline_period']} ({result['baseline_sessions']} sessions)")
        lines.append(f"  Current:  {result['current_period']} ({result['current_sessions']} sessions)")
        lines.append("")
        lines.append(f"{'Metric':<25} {'Baseline':>10} {'Current':>10} {'Delta':>10} {'Status':>10}")
        lines.append("-" * 70)
        for c in result["comparisons"]:
            indicator = {"ok": "  OK", "warning": " WARN", "critical": " CRIT"}.get(c["severity"], "  ?")
            lines.append(
                f"{c['metric']:<25} {c['baseline']:>10.4f} {c['current']:>10.4f} "
                f"{c['delta']:>+10.4f} {indicator:>10}"
            )
        if result["task_regressions"]:
            lines.append("")
            lines.append("Task-Level Regressions:")
            for tr in result["task_regressions"]:
                lines.append(f"  {tr['task_type']}: {tr['baseline_success']:.0%} -> {tr['current_success']:.0%} ({tr['delta']:+.1%})")
        if result["changes_applied"]:
            lines.append("")
            lines.append("Changes Applied Between Periods:")
            for ch in result["changes_applied"]:
                lines.append(f"  [{ch.get('type', '?')}] {ch.get('description', '')}")

    elif action == "diagnose":
        lines.append(f"Diagnosis: {result['metric']}")
        lines.append(f"  Severity: {result['severity'].upper()}")
        lines.append(f"  Baseline: {result['baseline_value']:.4f}")
        lines.append(f"  Current:  {result['current_value']:.4f}")
        lines.append(f"  Delta:    {result['delta']:+.4f}")
        if result["contributing_tasks"]:
            lines.append("")
            lines.append("Contributing Task Types:")
            for ct in result["contributing_tasks"]:
                lines.append(f"  {ct['task_type']}: {ct['baseline']:.4f} -> {ct['current']:.4f} ({ct['delta']:+.4f}) [{ct['severity']}]")
        if result["changes_between_periods"]:
            lines.append("")
            lines.append("Changes to Review:")
            for ch in result["changes_between_periods"]:
                lines.append(f"  [{ch.get('type', '?')}] {ch.get('description', '')}")
        lines.append("")
        lines.append("Recommendations:")
        for rec in result["recommendations"]:
            lines.append(f"  -> {rec}")

    elif action == "report":
        lines.append(f"{'=' * 60}")
        lines.append(f"  REGRESSION REPORT: {result['overall_status']}")
        lines.append(f"{'=' * 60}")
        lines.append(f"  Baseline: {result['baseline_period']}")
        lines.append(f"  Current:  {result['current_period']}")
        lines.append(f"  Generated: {result['generated_at'][:19]}")
        lines.append("")
        s = result["summary"]
        lines.append(f"  Metrics checked:          {s['total_metrics_checked']}")
        lines.append(f"  Regressions found:        {s['regressions_found']}")
        lines.append(f"    Critical:               {s['critical_regressions']}")
        lines.append(f"    Warning:                {s['warning_regressions']}")
        lines.append(f"  Task-type regressions:    {s['task_type_regressions']}")
        lines.append("")
        lines.append("Metric Details:")
        lines.append(f"  {'Metric':<25} {'Baseline':>10} {'Current':>10} {'Delta':>10} {'Status':>8}")
        lines.append("  " + "-" * 66)
        for c in result["comparisons"]:
            tag = {"ok": "OK", "warning": "WARN", "critical": "CRIT"}.get(c["severity"], "?")
            lines.append(
                f"  {c['metric']:<25} {c['baseline']:>10.4f} {c['current']:>10.4f} "
                f"{c['delta']:>+10.4f} {tag:>8}"
            )
        for diag in result.get("diagnoses", []):
            lines.append("")
            lines.append(f"  --- Diagnosis: {diag['metric']} [{diag['severity'].upper()}] ---")
            if diag.get("contributing_tasks"):
                for ct in diag["contributing_tasks"]:
                    lines.append(f"    {ct['task_type']}: {ct['delta']:+.4f} [{ct['severity']}]")
            for rec in diag.get("recommendations", []):
                lines.append(f"    -> {rec}")
        if result["changes_applied"]:
            lines.append("")
            lines.append("  Changes Applied:")
            for ch in result["changes_applied"]:
                lines.append(f"    [{ch.get('type', '?')}] {ch.get('description', '')}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(
        description="Regression Detector - Compare before/after performance metrics",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output in JSON format")

    sub = parser.add_subparsers(dest="command", help="Available commands")

    p_compare = sub.add_parser("compare", help="Compare baseline vs current metrics")
    p_compare.add_argument("--input", required=True, help="Path to metrics JSON file")

    p_diagnose = sub.add_parser("diagnose", help="Diagnose a specific metric regression")
    p_diagnose.add_argument("--input", required=True, help="Path to metrics JSON file")
    p_diagnose.add_argument("--metric", required=True, choices=list(REGRESSION_THRESHOLDS.keys()),
                            help="Metric to diagnose")

    p_report = sub.add_parser("report", help="Generate full regression report")
    p_report.add_argument("--input", required=True, help="Path to metrics JSON file")

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        sys.exit(1)

    if not os.path.exists(args.input):
        print(f"Error: Input file '{args.input}' not found", file=sys.stderr)
        sys.exit(1)

    data = load_data(args.input)
    commands = {
        "compare": cmd_compare,
        "diagnose": cmd_diagnose,
        "report": cmd_report,
    }

    result = commands[args.command](args, data)

    if args.json_output:
        print(json.dumps(result, indent=2, default=str))
    else:
        print(format_human(result))


if __name__ == "__main__":
    main()