Summarize Meeting

#!/usr/bin/env python3
"""Action Item Tracker - Track meeting action items across multiple meetings.

Aggregates action items from meeting summaries and tracks completion status,
overdue items, and per-person accountability.

Usage:
    python action_item_tracker.py --meetings meetings.json
    python action_item_tracker.py --meetings meetings.json --json
    python action_item_tracker.py --example
"""

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


def load_data(path: str) -> dict:
    with open(path, "r") as f:
        return json.load(f)


def parse_date(s: str) -> datetime:
    for fmt in ("%Y-%m-%d", "%Y-%m-%dT%H:%M:%S"):
        try:
            return datetime.strptime(s, fmt)
        except ValueError:
            continue
    return None


def analyze_actions(data: dict) -> dict:
    meetings = data.get("meetings", [])
    today = datetime.now()

    all_actions = []
    for meeting in meetings:
        meeting_date = meeting.get("date", "Unknown")
        meeting_topic = meeting.get("topic", "Unknown")
        for action in meeting.get("action_items", []):
            action["meeting_date"] = meeting_date
            action["meeting_topic"] = meeting_topic
            all_actions.append(action)

    # Classify actions
    completed = []
    overdue = []
    upcoming = []
    no_date = []

    person_stats = defaultdict(lambda: {"total": 0, "completed": 0, "overdue": 0})

    for action in all_actions:
        owner = action.get("owner", "Unassigned")
        status = action.get("status", "open").lower()
        due_str = action.get("due_date", "")
        due_dt = parse_date(due_str) if due_str else None

        person_stats[owner]["total"] += 1

        if status in ("done", "complete", "completed"):
            completed.append(action)
            person_stats[owner]["completed"] += 1
        elif due_dt and due_dt < today:
            overdue.append(action)
            person_stats[owner]["overdue"] += 1
        elif due_dt:
            upcoming.append(action)
        else:
            no_date.append(action)

    # Sort overdue by most overdue first
    for a in overdue:
        due_dt = parse_date(a.get("due_date", ""))
        a["days_overdue"] = (today - due_dt).days if due_dt else 0
    overdue.sort(key=lambda x: x.get("days_overdue", 0), reverse=True)

    # Person accountability
    person_results = []
    for person, stats in sorted(person_stats.items()):
        completion_rate = round(stats["completed"] / stats["total"] * 100) if stats["total"] > 0 else 0
        person_results.append({
            "person": person,
            "total": stats["total"],
            "completed": stats["completed"],
            "overdue": stats["overdue"],
            "completion_rate_pct": completion_rate,
        })
    person_results.sort(key=lambda x: x["completion_rate_pct"])

    total = len(all_actions)
    completion_rate = round(len(completed) / total * 100, 1) if total > 0 else 0

    recs = []
    if overdue:
        top_overdue_owners = list(set(a.get("owner", "Unknown") for a in overdue[:5]))
        recs.append(f"{len(overdue)} overdue action item(s). Top owners: {', '.join(top_overdue_owners)}")
    if no_date:
        recs.append(f"{len(no_date)} action item(s) without due dates. Add specific dates for accountability.")
    if completion_rate < 70:
        recs.append(f"Completion rate is {completion_rate:.0f}% (target: 80%+). Review blockers in next meeting.")

    return {
        "analysis_date": today.strftime("%Y-%m-%d"),
        "total_meetings": len(meetings),
        "total_actions": total,
        "completed": len(completed),
        "overdue": len(overdue),
        "upcoming": len(upcoming),
        "no_due_date": len(no_date),
        "completion_rate_pct": completion_rate,
        "overdue_items": [
            {"action": a.get("action"), "owner": a.get("owner"), "due_date": a.get("due_date"), "days_overdue": a.get("days_overdue", 0), "meeting": a.get("meeting_topic")}
            for a in overdue[:10]
        ],
        "person_accountability": person_results,
        "recommendations": recs,
    }


def print_report(result: dict) -> None:
    print(f"\nAction Item Tracker")
    print(f"Date: {result['analysis_date']}  |  Meetings: {result['total_meetings']}")
    print("=" * 65)
    print(f"Total: {result['total_actions']}  |  Done: {result['completed']}  |  Overdue: {result['overdue']}  |  Upcoming: {result['upcoming']}")
    print(f"Completion Rate: {result['completion_rate_pct']:.0f}%")

    if result["overdue_items"]:
        print(f"\nOverdue Items:")
        for item in result["overdue_items"]:
            print(f"  [{item['days_overdue']}d overdue] {item['owner']}: {item['action'][:50]} (due: {item['due_date']})")

    print(f"\nPerson Accountability:")
    print(f"  {'Person':<20} {'Total':>6} {'Done':>6} {'Overdue':>8} {'Rate':>6}")
    print(f"  {'-'*20} {'-'*6} {'-'*6} {'-'*8} {'-'*6}")
    for p in result["person_accountability"]:
        print(f"  {p['person']:<20} {p['total']:>6} {p['completed']:>6} {p['overdue']:>8} {p['completion_rate_pct']:>5}%")

    if result["recommendations"]:
        print(f"\nRecommendations:")
        for i, r in enumerate(result["recommendations"], 1):
            print(f"  {i}. {r}")
    print()


def print_example() -> None:
    example = {
        "meetings": [
            {
                "date": "2026-03-14",
                "topic": "Sprint Planning",
                "action_items": [
                    {"action": "Draft API spec for new endpoint", "owner": "Alice", "due_date": "2026-03-18", "status": "complete"},
                    {"action": "Set up staging environment", "owner": "Bob", "due_date": "2026-03-16", "status": "open"},
                ],
            },
            {
                "date": "2026-03-07",
                "topic": "Stakeholder Review",
                "action_items": [
                    {"action": "Prepare Q1 metrics report", "owner": "Carol", "due_date": "2026-03-10", "status": "open"},
                    {"action": "Schedule design review", "owner": "Alice", "due_date": "2026-03-12", "status": "complete"},
                ],
            },
        ],
    }
    print(json.dumps(example, indent=2))


def main():
    parser = argparse.ArgumentParser(description="Track meeting action items.")
    parser.add_argument("--meetings", type=str, help="Path to meetings JSON file")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    parser.add_argument("--example", action="store_true", help="Print example and exit")
    args = parser.parse_args()

    if args.example:
        print_example()
        return
    if not args.meetings:
        parser.error("--meetings is required")

    data = load_data(args.meetings)
    result = analyze_actions(data)
    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_report(result)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Decision Log Builder - Build and query a decision log from meeting data.

Aggregates decisions across meetings and provides search, timeline,
and decision audit capabilities.

Usage:
    python decision_log_builder.py --meetings meetings.json
    python decision_log_builder.py --meetings meetings.json --search "launch"
    python decision_log_builder.py --meetings meetings.json --json
    python decision_log_builder.py --example
"""

import argparse
import json
import re
import sys
from datetime import datetime


def load_data(path: str) -> dict:
    with open(path, "r") as f:
        return json.load(f)


def build_log(data: dict, search: str = None) -> dict:
    meetings = data.get("meetings", [])

    decisions = []
    for meeting in meetings:
        date = meeting.get("date", "Unknown")
        topic = meeting.get("topic", "Unknown")
        participants = meeting.get("participants", [])

        for dec in meeting.get("decisions", []):
            decision = {
                "id": f"DEC-{date.replace('-', '')}-{len(decisions)+1:03d}",
                "date": date,
                "meeting_topic": topic,
                "decision": dec.get("decision", ""),
                "rationale": dec.get("rationale", ""),
                "decided_by": dec.get("decided_by", "Unknown"),
                "participants": participants,
                "category": dec.get("category", "General"),
                "impact": dec.get("impact", "Medium"),
                "reversible": dec.get("reversible", True),
            }
            decisions.append(decision)

    # Sort by date (most recent first)
    decisions.sort(key=lambda x: x["date"], reverse=True)

    # Apply search filter
    if search:
        pattern = re.compile(search, re.IGNORECASE)
        decisions = [d for d in decisions if pattern.search(d["decision"]) or pattern.search(d.get("rationale", ""))]

    # Category distribution
    categories = {}
    for d in decisions:
        cat = d["category"]
        categories[cat] = categories.get(cat, 0) + 1

    # Impact distribution
    impact_counts = {"High": 0, "Medium": 0, "Low": 0}
    for d in decisions:
        impact_counts[d["impact"]] = impact_counts.get(d["impact"], 0) + 1

    # Quality checks
    missing_rationale = [d for d in decisions if not d.get("rationale")]
    high_impact_reversible = [d for d in decisions if d["impact"] == "High" and d.get("reversible", True)]

    recs = []
    if missing_rationale:
        recs.append(f"{len(missing_rationale)} decision(s) without documented rationale. Future teams need to understand 'why'.")
    if high_impact_reversible:
        recs.append(f"{len(high_impact_reversible)} high-impact decision(s) marked as reversible. Verify this is correct and document rollback plans.")

    return {
        "total_decisions": len(decisions),
        "search_query": search,
        "categories": categories,
        "impact_distribution": impact_counts,
        "decisions": decisions,
        "quality": {
            "missing_rationale": len(missing_rationale),
            "decisions_with_rationale_pct": round((len(decisions) - len(missing_rationale)) / len(decisions) * 100, 1) if decisions else 0,
        },
        "recommendations": recs,
    }


def print_report(result: dict) -> None:
    print(f"\nDecision Log")
    if result["search_query"]:
        print(f"Search: '{result['search_query']}'")
    print(f"Total Decisions: {result['total_decisions']}")
    print("=" * 65)

    imp = result["impact_distribution"]
    print(f"Impact: High={imp.get('High',0)} | Medium={imp.get('Medium',0)} | Low={imp.get('Low',0)}")
    print(f"Rationale Coverage: {result['quality']['decisions_with_rationale_pct']:.0f}%")

    print(f"\nDecisions:")
    for d in result["decisions"]:
        rev = " [reversible]" if d.get("reversible") else " [irreversible]"
        print(f"\n  {d['id']} ({d['date']})")
        print(f"    Decision: {d['decision']}")
        if d["rationale"]:
            print(f"    Rationale: {d['rationale'][:80]}")
        print(f"    Decided by: {d['decided_by']}  |  Impact: {d['impact']}{rev}")

    if result["recommendations"]:
        print(f"\nRecommendations:")
        for i, r in enumerate(result["recommendations"], 1):
            print(f"  {i}. {r}")
    print()


def print_example() -> None:
    example = {
        "meetings": [
            {
                "date": "2026-03-14",
                "topic": "Architecture Review",
                "participants": ["Alice", "Bob", "Carol"],
                "decisions": [
                    {"decision": "Use PostgreSQL for analytics service", "rationale": "80% relational queries based on pattern analysis", "decided_by": "Engineering leads", "category": "Technical", "impact": "High", "reversible": False},
                    {"decision": "Adopt trunk-based development", "rationale": "Reduce merge conflicts and improve CI speed", "decided_by": "Alice", "category": "Process", "impact": "Medium", "reversible": True},
                ],
            },
            {
                "date": "2026-03-07",
                "topic": "Sprint Planning",
                "participants": ["Alice", "Dave"],
                "decisions": [
                    {"decision": "Launch date set for April 15", "rationale": "Allows 2 full sprints for QA after feature freeze", "decided_by": "Steering committee", "category": "Schedule", "impact": "High", "reversible": True},
                ],
            },
        ],
    }
    print(json.dumps(example, indent=2))


def main():
    parser = argparse.ArgumentParser(description="Build and query a decision log.")
    parser.add_argument("--meetings", type=str, help="Path to meetings JSON file")
    parser.add_argument("--search", type=str, help="Search decisions by keyword")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    parser.add_argument("--example", action="store_true", help="Print example and exit")
    args = parser.parse_args()

    if args.example:
        print_example()
        return
    if not args.meetings:
        parser.error("--meetings is required")

    data = load_data(args.meetings)
    result = build_log(data, args.search)
    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_report(result)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Meeting Effectiveness Scorer - Score meeting effectiveness from summary data.

Analyzes meeting summaries to score effectiveness based on decisions made,
action items generated, time efficiency, and follow-through.

Usage:
    python meeting_effectiveness_scorer.py --meetings meetings.json
    python meeting_effectiveness_scorer.py --meetings meetings.json --json
    python meeting_effectiveness_scorer.py --example
"""

import argparse
import json
import sys
from datetime import datetime


def load_data(path: str) -> dict:
    with open(path, "r") as f:
        return json.load(f)


def score_meeting(meeting: dict) -> dict:
    topic = meeting.get("topic", "Unknown")
    duration_min = meeting.get("duration_minutes", 60)
    participants = meeting.get("participants", [])
    decisions = meeting.get("decisions", [])
    action_items = meeting.get("action_items", [])
    agenda_items = meeting.get("agenda_items", 0)
    agenda_covered = meeting.get("agenda_items_covered", 0)

    score = 0
    max_score = 100
    checks = {}

    # Decisions made (25 points)
    if decisions:
        decision_score = min(25, len(decisions) * 8)
        checks["decisions"] = {"score": decision_score, "max": 25, "detail": f"{len(decisions)} decision(s) documented"}
    else:
        decision_score = 0
        checks["decisions"] = {"score": 0, "max": 25, "detail": "No decisions documented"}
    score += decision_score

    # Action items with owners and dates (25 points)
    owned_actions = sum(1 for a in action_items if a.get("owner"))
    dated_actions = sum(1 for a in action_items if a.get("due_date"))
    if action_items:
        ownership_pct = owned_actions / len(action_items)
        dated_pct = dated_actions / len(action_items)
        ai_score = int(min(25, len(action_items) * 5 * ((ownership_pct + dated_pct) / 2)))
        checks["action_items"] = {"score": ai_score, "max": 25, "detail": f"{len(action_items)} items ({owned_actions} owned, {dated_actions} dated)"}
    else:
        ai_score = 0
        checks["action_items"] = {"score": 0, "max": 25, "detail": "No action items"}
    score += ai_score

    # Time efficiency (20 points)
    if duration_min <= 30:
        time_score = 20
    elif duration_min <= 60:
        time_score = 15
    elif duration_min <= 90:
        time_score = 10
    else:
        time_score = 5
    # Bonus for output density
    outputs = len(decisions) + len(action_items)
    density = outputs / (duration_min / 30) if duration_min > 0 else 0
    if density >= 3:
        time_score = min(20, time_score + 5)
    checks["time_efficiency"] = {"score": time_score, "max": 20, "detail": f"{duration_min}min, {outputs} outputs, density: {density:.1f}/30min"}
    score += time_score

    # Agenda coverage (15 points)
    if agenda_items > 0:
        coverage = agenda_covered / agenda_items
        agenda_score = int(15 * coverage)
        checks["agenda_coverage"] = {"score": agenda_score, "max": 15, "detail": f"{agenda_covered}/{agenda_items} agenda items covered ({coverage*100:.0f}%)"}
    else:
        agenda_score = 8  # No agenda is a mild negative
        checks["agenda_coverage"] = {"score": agenda_score, "max": 15, "detail": "No agenda defined"}
    score += agenda_score

    # Participant efficiency (15 points)
    if len(participants) <= 5:
        part_score = 15
    elif len(participants) <= 8:
        part_score = 10
    elif len(participants) <= 12:
        part_score = 5
    else:
        part_score = 0
    checks["participants"] = {"score": part_score, "max": 15, "detail": f"{len(participants)} participants"}
    score += part_score

    if score >= 80:
        rating = "Highly Effective"
    elif score >= 60:
        rating = "Effective"
    elif score >= 40:
        rating = "Needs Improvement"
    else:
        rating = "Ineffective"

    return {
        "topic": topic,
        "date": meeting.get("date", "Unknown"),
        "score": score,
        "rating": rating,
        "duration_minutes": duration_min,
        "participant_count": len(participants),
        "decision_count": len(decisions),
        "action_item_count": len(action_items),
        "checks": checks,
    }


def analyze_meetings(data: dict) -> dict:
    meetings = data.get("meetings", [])
    results = [score_meeting(m) for m in meetings]
    scores = [r["score"] for r in results]
    avg = round(sum(scores) / len(scores), 1) if scores else 0

    total_time = sum(r["duration_minutes"] for r in results)
    total_decisions = sum(r["decision_count"] for r in results)
    total_actions = sum(r["action_item_count"] for r in results)

    recs = []
    low_scoring = [r for r in results if r["score"] < 50]
    if low_scoring:
        recs.append(f"{len(low_scoring)} meeting(s) scored below 50. Review if these meetings are needed or need restructuring.")
    no_decisions = [r for r in results if r["decision_count"] == 0]
    if no_decisions:
        recs.append(f"{len(no_decisions)} meeting(s) produced no decisions. Consider if the meeting purpose was clear.")
    long_meetings = [r for r in results if r["duration_minutes"] > 60]
    if long_meetings:
        recs.append(f"{len(long_meetings)} meeting(s) exceeded 60 minutes. Review agenda focus and consider splitting.")

    return {
        "total_meetings": len(results),
        "average_score": avg,
        "total_time_minutes": total_time,
        "total_decisions": total_decisions,
        "total_action_items": total_actions,
        "meetings": results,
        "recommendations": recs,
    }


def print_report(result: dict) -> None:
    print(f"\nMeeting Effectiveness Report")
    print(f"Meetings: {result['total_meetings']}  |  Avg Score: {result['average_score']:.0f}/100")
    print("=" * 65)
    print(f"Total Time: {result['total_time_minutes']}min  |  Decisions: {result['total_decisions']}  |  Action Items: {result['total_action_items']}")

    print(f"\nPer-Meeting Scores:")
    print(f"  {'Date':<12} {'Topic':<25} {'Score':>6} {'Rating':<18} {'Dec':>4} {'AI':>4} {'Min':>4}")
    print(f"  {'-'*12} {'-'*25} {'-'*6} {'-'*18} {'-'*4} {'-'*4} {'-'*4}")
    for m in sorted(result["meetings"], key=lambda x: x["score"]):
        topic = m["topic"][:23] + ".." if len(m["topic"]) > 25 else m["topic"]
        print(f"  {m['date']:<12} {topic:<25} {m['score']:>5}% {m['rating']:<18} {m['decision_count']:>4} {m['action_item_count']:>4} {m['duration_minutes']:>4}")

    if result["recommendations"]:
        print(f"\nRecommendations:")
        for i, r in enumerate(result["recommendations"], 1):
            print(f"  {i}. {r}")
    print()


def print_example() -> None:
    example = {
        "meetings": [
            {
                "date": "2026-03-14",
                "topic": "Sprint Planning",
                "duration_minutes": 60,
                "participants": ["Alice", "Bob", "Carol", "Dave"],
                "agenda_items": 4,
                "agenda_items_covered": 4,
                "decisions": [
                    {"decision": "Focus on onboarding flow this sprint", "rationale": "Highest impact item"},
                ],
                "action_items": [
                    {"action": "Create Jira tickets for onboarding epics", "owner": "Alice", "due_date": "2026-03-15"},
                    {"action": "Draft design spec", "owner": "Bob", "due_date": "2026-03-17"},
                ],
            },
            {
                "date": "2026-03-12",
                "topic": "Status Sync",
                "duration_minutes": 45,
                "participants": ["Alice", "Bob", "Carol", "Dave", "Eve", "Frank", "Grace", "Henry"],
                "agenda_items": 0,
                "agenda_items_covered": 0,
                "decisions": [],
                "action_items": [{"action": "Look into the issue", "owner": "", "due_date": ""}],
            },
        ],
    }
    print(json.dumps(example, indent=2))


def main():
    parser = argparse.ArgumentParser(description="Score meeting effectiveness.")
    parser.add_argument("--meetings", type=str, help="Path to meetings JSON file")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    parser.add_argument("--example", action="store_true", help="Print example and exit")
    args = parser.parse_args()

    if args.example:
        print_example()
        return
    if not args.meetings:
        parser.error("--meetings is required")

    data = load_data(args.meetings)
    result = analyze_meetings(data)
    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_report(result)


if __name__ == "__main__":
    main()