Org Health Diagnostic

#!/usr/bin/env python3
"""Engagement Benchmarker - Benchmark engagement metrics against industry standards.

Compares eNPS, attrition, time-to-fill, promotion rate, and other people metrics
against industry benchmarks. Flags gaps and provides improvement recommendations.

Usage:
    python engagement_benchmarker.py --enps 15 --attrition 18 --time-to-fill 60 --promotion-rate 20 --industry saas
    python engagement_benchmarker.py --enps -5 --attrition 28 --time-to-fill 90 --promotion-rate 10 --industry saas --json
"""

import argparse
import json
import sys
from datetime import datetime

BENCHMARKS = {
    "saas": {
        "industry_name": "SaaS / Technology",
        "metrics": {
            "enps": {"benchmark": 20, "green": 30, "yellow": 0, "unit": "score", "direction": "higher_is_better"},
            "attrition": {"benchmark": 15, "green": 10, "yellow": 20, "unit": "% annual", "direction": "lower_is_better"},
            "time_to_fill": {"benchmark": 45, "green": 35, "yellow": 75, "unit": "days", "direction": "lower_is_better"},
            "promotion_rate": {"benchmark": 25, "green": 30, "yellow": 15, "unit": "% internal", "direction": "higher_is_better"},
            "manager_ratio": {"benchmark": 7, "green_range": [5, 8], "unit": "ICs per manager"},
        }
    },
    "fintech": {
        "industry_name": "Fintech",
        "metrics": {
            "enps": {"benchmark": 18, "green": 25, "yellow": -5, "unit": "score", "direction": "higher_is_better"},
            "attrition": {"benchmark": 18, "green": 12, "yellow": 25, "unit": "% annual", "direction": "lower_is_better"},
            "time_to_fill": {"benchmark": 55, "green": 40, "yellow": 85, "unit": "days", "direction": "lower_is_better"},
            "promotion_rate": {"benchmark": 22, "green": 28, "yellow": 12, "unit": "% internal", "direction": "higher_is_better"},
            "manager_ratio": {"benchmark": 7, "green_range": [5, 8], "unit": "ICs per manager"},
        }
    },
    "enterprise": {
        "industry_name": "Enterprise Software",
        "metrics": {
            "enps": {"benchmark": 15, "green": 25, "yellow": -5, "unit": "score", "direction": "higher_is_better"},
            "attrition": {"benchmark": 12, "green": 8, "yellow": 18, "unit": "% annual", "direction": "lower_is_better"},
            "time_to_fill": {"benchmark": 50, "green": 40, "yellow": 80, "unit": "days", "direction": "lower_is_better"},
            "promotion_rate": {"benchmark": 20, "green": 28, "yellow": 12, "unit": "% internal", "direction": "higher_is_better"},
            "manager_ratio": {"benchmark": 6, "green_range": [5, 8], "unit": "ICs per manager"},
        }
    },
    "startup": {
        "industry_name": "Startup (Early Stage)",
        "metrics": {
            "enps": {"benchmark": 25, "green": 35, "yellow": 5, "unit": "score", "direction": "higher_is_better"},
            "attrition": {"benchmark": 20, "green": 12, "yellow": 30, "unit": "% annual", "direction": "lower_is_better"},
            "time_to_fill": {"benchmark": 40, "green": 30, "yellow": 70, "unit": "days", "direction": "lower_is_better"},
            "promotion_rate": {"benchmark": 20, "green": 30, "yellow": 10, "unit": "% internal", "direction": "higher_is_better"},
            "manager_ratio": {"benchmark": 7, "green_range": [5, 9], "unit": "ICs per manager"},
        }
    }
}

METRIC_RECOMMENDATIONS = {
    "enps": {
        "low": [
            "Conduct stay interviews with top performers to understand concerns",
            "Review and address top 3 themes from last engagement survey",
            "Increase leadership visibility and communication frequency",
            "Implement manager coaching program focused on team support"
        ],
        "critical": [
            "URGENT: Negative eNPS indicates fundamental engagement crisis",
            "Conduct skip-level conversations within 2 weeks",
            "CEO to address concerns directly at all-hands",
            "Consider bringing in external engagement consultant"
        ]
    },
    "attrition": {
        "low": [
            "Review compensation against market data for at-risk roles",
            "Implement retention bonuses for critical personnel",
            "Improve career development and growth opportunities",
            "Address exit interview themes systematically"
        ],
        "critical": [
            "URGENT: Attrition above 25% threatens operational continuity",
            "Immediate retention package for top 10 at-risk employees",
            "CEO conversation with each departing senior team member",
            "Conduct emergency engagement pulse survey"
        ]
    },
    "time_to_fill": {
        "low": [
            "Review and streamline interview process (aim for < 3 weeks end-to-end)",
            "Improve job descriptions and employer branding",
            "Expand sourcing channels beyond current methods",
            "Consider adding recruiter headcount"
        ],
        "critical": [
            "Hiring bottleneck affecting growth -- immediate process review",
            "Consider temporary agency support for critical roles",
            "Reduce interview stages to maximum 4",
            "Implement hiring manager accountability metrics"
        ]
    },
    "promotion_rate": {
        "low": [
            "Review career ladder clarity -- are paths well-defined?",
            "Implement quarterly development conversations",
            "Create stretch assignments for high-potential employees",
            "Audit promotion criteria for transparency and fairness"
        ],
        "critical": [
            "Low promotion rate signals development stagnation",
            "Implement individual development plans for all ICs",
            "Review if managers have development as part of their goals",
            "Consider internal mobility program"
        ]
    }
}


def benchmark(enps, attrition, time_to_fill, promotion_rate, industry):
    industry_key = industry.lower()
    if industry_key not in BENCHMARKS:
        industry_key = "saas"  # Default

    bench = BENCHMARKS[industry_key]
    results = []

    metrics_input = {
        "enps": enps,
        "attrition": attrition,
        "time_to_fill": time_to_fill,
        "promotion_rate": promotion_rate
    }

    for metric_key, value in metrics_input.items():
        b = bench["metrics"][metric_key]
        direction = b["direction"]

        if direction == "higher_is_better":
            if value >= b["green"]:
                status = "GREEN"
            elif value >= b["yellow"]:
                status = "YELLOW"
            else:
                status = "RED"
            vs_benchmark = round(value - b["benchmark"], 1)
            vs_label = f"{'+' if vs_benchmark > 0 else ''}{vs_benchmark} vs benchmark"
        else:  # lower_is_better
            if value <= b["green"]:
                status = "GREEN"
            elif value <= b["yellow"]:
                status = "YELLOW"
            else:
                status = "RED"
            vs_benchmark = round(value - b["benchmark"], 1)
            vs_label = f"{'+' if vs_benchmark > 0 else ''}{vs_benchmark} vs benchmark"

        recs = []
        if status in ("RED", "YELLOW"):
            rec_key = "critical" if status == "RED" else "low"
            recs = METRIC_RECOMMENDATIONS.get(metric_key, {}).get(rec_key, [])

        results.append({
            "metric": metric_key,
            "value": value,
            "unit": b["unit"],
            "benchmark": b["benchmark"],
            "vs_benchmark": vs_label,
            "status": status,
            "recommendations": recs
        })

    # Overall engagement health
    red_count = sum(1 for r in results if r["status"] == "RED")
    yellow_count = sum(1 for r in results if r["status"] == "YELLOW")
    green_count = sum(1 for r in results if r["status"] == "GREEN")

    if red_count >= 2:
        overall = "CRITICAL"
    elif red_count >= 1:
        overall = "AT RISK"
    elif yellow_count >= 2:
        overall = "NEEDS ATTENTION"
    else:
        overall = "HEALTHY"

    return {
        "benchmark_date": datetime.now().strftime("%Y-%m-%d"),
        "industry": bench["industry_name"],
        "overall_status": overall,
        "metrics": results,
        "summary": {"green": green_count, "yellow": yellow_count, "red": red_count},
        "priority_actions": [r["recommendations"][0] for r in results if r["status"] == "RED" and r["recommendations"]]
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"ENGAGEMENT BENCHMARKER - {result['industry']}")
    print(f"Date: {result['benchmark_date']}")
    print(f"Overall: {result['overall_status']}")
    print(f"{'='*70}\n")

    print("METRICS vs BENCHMARK:")
    print("-" * 65)
    for m in result["metrics"]:
        status_icon = {"GREEN": "+", "YELLOW": "~", "RED": "!"}[m["status"]]
        print(f"  [{status_icon}] {m['metric']:<18s} {m['value']:>6}  {m['unit']:<12s}  (benchmark: {m['benchmark']})  {m['vs_benchmark']}")

    for m in result["metrics"]:
        if m["recommendations"]:
            print(f"\n  {m['metric'].upper()} [{m['status']}] Recommendations:")
            for r in m["recommendations"]:
                print(f"    -> {r}")

    if result["priority_actions"]:
        print(f"\nPRIORITY ACTIONS:")
        for a in result["priority_actions"]:
            print(f"  [!] {a}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Benchmark engagement metrics against industry standards")
    parser.add_argument("--enps", type=float, required=True, help="Employee NPS score")
    parser.add_argument("--attrition", type=float, required=True, help="Annual attrition rate (%)")
    parser.add_argument("--time-to-fill", type=float, required=True, help="Average days to fill a position")
    parser.add_argument("--promotion-rate", type=float, required=True, help="Internal promotion rate (%)")
    parser.add_argument("--industry", default="saas", choices=list(BENCHMARKS.keys()), help="Industry for benchmarking")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    result = benchmark(args.enps, args.attrition, args.time_to_fill, args.promotion_rate, args.industry)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Org Health Scorer - Score 8 dimensions with traffic lights and stage-adjusted weighting.

Calculates overall organizational health from 8 dimension scores with stage-appropriate
weighting. Produces traffic light dashboard, cascade risk analysis, and priorities.

Usage:
    python org_health_scorer.py --stage series-a --financial 7.5 --revenue 5.8 --product 7.2 --engineering 5.0 --people 3.5 --operations 6.0 --security 7.8 --market 5.5
    python org_health_scorer.py --stage seed --financial 6 --revenue 4 --product 8 --engineering 7 --people 6 --operations 5 --security 4 --market 6 --json
"""

import argparse
import json
import sys
from datetime import datetime

DIMENSIONS = {
    "financial": {"name": "Financial Health", "owner": "CFO", "cascade_to": ["people", "engineering", "product"]},
    "revenue": {"name": "Revenue Health", "owner": "CRO", "cascade_to": ["financial", "people", "market"]},
    "product": {"name": "Product Health", "owner": "CPO", "cascade_to": ["revenue", "market", "people"]},
    "engineering": {"name": "Engineering Health", "owner": "CTO", "cascade_to": ["product", "revenue"]},
    "people": {"name": "People Health", "owner": "CHRO", "cascade_to": ["engineering", "product", "revenue"]},
    "operations": {"name": "Operational Health", "owner": "COO", "cascade_to": ["all"]},
    "security": {"name": "Security Health", "owner": "CISO", "cascade_to": ["revenue", "financial"]},
    "market": {"name": "Market Health", "owner": "CMO", "cascade_to": ["revenue", "financial"]}
}

STAGE_WEIGHTS = {
    "seed": {"financial": 0.20, "revenue": 0.10, "product": 0.25, "engineering": 0.15, "people": 0.10, "operations": 0.05, "security": 0.05, "market": 0.10},
    "series-a": {"financial": 0.15, "revenue": 0.20, "product": 0.20, "engineering": 0.15, "people": 0.10, "operations": 0.10, "security": 0.05, "market": 0.05},
    "series-b": {"financial": 0.15, "revenue": 0.20, "product": 0.15, "engineering": 0.15, "people": 0.15, "operations": 0.10, "security": 0.05, "market": 0.05},
    "series-c": {"financial": 0.15, "revenue": 0.20, "product": 0.10, "engineering": 0.10, "people": 0.15, "operations": 0.15, "security": 0.10, "market": 0.05},
    "growth": {"financial": 0.15, "revenue": 0.20, "product": 0.10, "engineering": 0.10, "people": 0.15, "operations": 0.15, "security": 0.10, "market": 0.05}
}


def get_traffic_light(score):
    if score >= 7:
        return "GREEN"
    elif score >= 4:
        return "YELLOW"
    return "RED"


def score_health(stage, scores):
    weights = STAGE_WEIGHTS.get(stage, STAGE_WEIGHTS["series-a"])

    dimension_results = []
    weighted_total = 0.0

    for dim_key, dim_info in DIMENSIONS.items():
        score = scores.get(dim_key, 5.0)
        weight = weights.get(dim_key, 0.1)
        weighted_score = score * weight
        weighted_total += weighted_score
        traffic = get_traffic_light(score)

        dimension_results.append({
            "dimension": dim_info["name"],
            "key": dim_key,
            "owner": dim_info["owner"],
            "score": score,
            "weight": weight,
            "weighted_score": round(weighted_score, 2),
            "traffic_light": traffic
        })

    overall = round(weighted_total, 1)
    overall_traffic = get_traffic_light(overall)

    # Cascade analysis
    red_dimensions = [d for d in dimension_results if d["traffic_light"] == "RED"]
    yellow_dimensions = [d for d in dimension_results if d["traffic_light"] == "YELLOW"]

    cascade_warnings = []
    for red in red_dimensions:
        cascades = DIMENSIONS[red["key"]]["cascade_to"]
        at_risk = []
        for cascade_key in cascades:
            if cascade_key == "all":
                at_risk = [d["dimension"] for d in dimension_results if d["key"] != red["key"]]
                break
            matching = [d for d in dimension_results if d["key"] == cascade_key and d["traffic_light"] in ("YELLOW", "RED")]
            at_risk.extend([m["dimension"] for m in matching])
        if at_risk:
            cascade_warnings.append({
                "source": red["dimension"],
                "source_score": red["score"],
                "at_risk_dimensions": at_risk,
                "type": "SYSTEMIC" if len(at_risk) >= 2 else "ISOLATED",
                "recommendation": f"Address {red['dimension']} ({red['owner']}) first -- cascading to {', '.join(at_risk)}"
            })

    # Priorities
    priorities = sorted(dimension_results, key=lambda d: d["score"])
    top_priorities = []
    for p in priorities[:3]:
        if p["traffic_light"] in ("RED", "YELLOW"):
            top_priorities.append({
                "dimension": p["dimension"],
                "score": p["score"],
                "traffic_light": p["traffic_light"],
                "owner": p["owner"],
                "urgency": "Immediate (30 days)" if p["traffic_light"] == "RED" else "This quarter"
            })

    # Data gaps (dimensions at exactly 5.0 might be defaults)
    data_gaps = [d["dimension"] for d in dimension_results if d["score"] == 5.0]

    return {
        "diagnostic_date": datetime.now().strftime("%Y-%m-%d"),
        "company_stage": stage,
        "overall_score": overall,
        "overall_traffic_light": overall_traffic,
        "trend": "Requires baseline for trend analysis",
        "dimensions": dimension_results,
        "cascade_warnings": cascade_warnings,
        "top_priorities": top_priorities,
        "data_gaps": data_gaps,
        "red_count": len(red_dimensions),
        "yellow_count": len(yellow_dimensions),
        "green_count": len([d for d in dimension_results if d["traffic_light"] == "GREEN"])
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"ORG HEALTH DIAGNOSTIC -- {result['diagnostic_date']}")
    print(f"Stage: {result['company_stage']}   Overall: {result['overall_score']}/10   [{result['overall_traffic_light']}]")
    print(f"{'='*70}\n")

    print("DIMENSION SCORES")
    print("-" * 60)
    for d in sorted(result["dimensions"], key=lambda x: -x["score"]):
        light = {"GREEN": "G", "YELLOW": "Y", "RED": "R"}[d["traffic_light"]]
        bar = "#" * int(d["score"]) + "." * (10 - int(d["score"]))
        print(f"  [{light}] {d['dimension']:<25s} {d['score']:>4.1f}  {bar}  ({d['owner']}, weight: {d['weight']})")

    print(f"\n  Summary: {result['green_count']} Green, {result['yellow_count']} Yellow, {result['red_count']} Red")

    if result["top_priorities"]:
        print(f"\nTOP PRIORITIES (address in order)")
        print("-" * 60)
        for i, p in enumerate(result["top_priorities"], 1):
            print(f"  [{p['traffic_light'][0]}] {i}. {p['dimension']}: {p['score']}/10")
            print(f"       Owner: {p['owner']}  |  Timeline: {p['urgency']}")

    if result["cascade_warnings"]:
        print(f"\nCASCADE WARNINGS")
        print("-" * 60)
        for cw in result["cascade_warnings"]:
            print(f"  [{cw['type']}] {cw['source']} ({cw['source_score']}/10) -> {', '.join(cw['at_risk_dimensions'])}")
            print(f"    {cw['recommendation']}")

    if result["data_gaps"]:
        print(f"\nDATA GAPS (scores at default 5.0 -- may need verification)")
        for dg in result["data_gaps"]:
            print(f"  [?] {dg}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Score organizational health across 8 dimensions")
    parser.add_argument("--stage", required=True, choices=list(STAGE_WEIGHTS.keys()))
    parser.add_argument("--financial", type=float, required=True, help="Financial health (1-10)")
    parser.add_argument("--revenue", type=float, required=True, help="Revenue health (1-10)")
    parser.add_argument("--product", type=float, required=True, help="Product health (1-10)")
    parser.add_argument("--engineering", type=float, required=True, help="Engineering health (1-10)")
    parser.add_argument("--people", type=float, required=True, help="People health (1-10)")
    parser.add_argument("--operations", type=float, required=True, help="Operational health (1-10)")
    parser.add_argument("--security", type=float, required=True, help="Security health (1-10)")
    parser.add_argument("--market", type=float, required=True, help="Market health (1-10)")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    scores = {
        "financial": args.financial, "revenue": args.revenue, "product": args.product,
        "engineering": args.engineering, "people": args.people, "operations": args.operations,
        "security": args.security, "market": args.market
    }

    for key, val in scores.items():
        if val < 1 or val > 10:
            print(f"Error: {key} must be between 1 and 10", file=sys.stderr)
            sys.exit(1)

    result = score_health(args.stage, scores)
    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_human(result)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Span of Control Analyzer - Analyze manager-to-IC ratios across the organization.

Reads an organization structure (CSV or inline) and calculates span of control
metrics, flagging unhealthy ratios. Healthy range: 1:5 to 1:8 for most roles.

Usage:
    python span_of_control_analyzer.py --org-file org_structure.csv
    python span_of_control_analyzer.py --managers "CEO:5,VP Eng:8,VP Sales:12,Eng Manager:3,Sales Manager:15" --json
"""

import argparse
import csv
import json
import os
import sys
from datetime import datetime

HEALTHY_RANGE = {"min": 5, "max": 8}
ROLE_ADJUSTMENTS = {
    "engineering": {"min": 5, "max": 9, "notes": "Engineering managers can handle slightly larger spans with senior ICs"},
    "sales": {"min": 6, "max": 10, "notes": "Sales managers can manage larger teams with clear metrics"},
    "support": {"min": 8, "max": 15, "notes": "Support teams can have larger spans with process-driven work"},
    "executive": {"min": 4, "max": 7, "notes": "Executives need smaller spans for strategic leadership"},
    "default": {"min": 5, "max": 8, "notes": "Standard management span"}
}


def classify_span(direct_reports, role_type="default"):
    adj = ROLE_ADJUSTMENTS.get(role_type, ROLE_ADJUSTMENTS["default"])
    if direct_reports < adj["min"]:
        return {"status": "TOO_NARROW", "color": "YELLOW", "issue": f"Span too narrow ({direct_reports}); healthy range: {adj['min']}-{adj['max']}. Risk: management overhead, micromanagement"}
    elif direct_reports > adj["max"]:
        return {"status": "TOO_WIDE", "color": "RED" if direct_reports > adj["max"] * 1.5 else "YELLOW", "issue": f"Span too wide ({direct_reports}); healthy range: {adj['min']}-{adj['max']}. Risk: insufficient coaching, burnout"}
    return {"status": "HEALTHY", "color": "GREEN", "issue": None}


def analyze_from_managers(managers_data):
    """Analyze from a dictionary of manager: direct_reports."""
    results = []
    for manager, reports in managers_data.items():
        role_type = "default"
        lower = manager.lower()
        if any(k in lower for k in ["eng", "tech", "cto"]):
            role_type = "engineering"
        elif any(k in lower for k in ["sale", "cro", "revenue"]):
            role_type = "sales"
        elif any(k in lower for k in ["support", "cs ", "service"]):
            role_type = "support"
        elif any(k in lower for k in ["ceo", "coo", "cfo", "vp", "chief", "svp"]):
            role_type = "executive"

        classification = classify_span(reports, role_type)
        results.append({
            "manager": manager,
            "direct_reports": reports,
            "role_type": role_type,
            "status": classification["status"],
            "color": classification["color"],
            "issue": classification["issue"]
        })
    return results


def analyze_from_csv(filepath):
    """Read CSV with columns: employee_name, manager_name, role."""
    if not os.path.exists(filepath):
        print(f"Error: File not found: {filepath}", file=sys.stderr)
        sys.exit(1)

    manager_counts = {}
    manager_roles = {}
    with open(filepath, "r") as f:
        reader = csv.DictReader(f)
        for row in reader:
            mgr = row.get("manager_name", row.get("manager", "")).strip()
            if mgr:
                manager_counts[mgr] = manager_counts.get(mgr, 0) + 1
                if mgr not in manager_roles:
                    manager_roles[mgr] = row.get("manager_role", row.get("role", "default"))

    managers_data = {}
    for mgr, count in manager_counts.items():
        managers_data[mgr] = count
    return analyze_from_managers(managers_data)


def generate_report(results):
    total_managers = len(results)
    healthy = [r for r in results if r["status"] == "HEALTHY"]
    too_narrow = [r for r in results if r["status"] == "TOO_NARROW"]
    too_wide = [r for r in results if r["status"] == "TOO_WIDE"]

    avg_span = round(sum(r["direct_reports"] for r in results) / total_managers, 1) if total_managers > 0 else 0
    median_span = sorted(r["direct_reports"] for r in results)[total_managers // 2] if total_managers > 0 else 0

    health_pct = round(len(healthy) / total_managers * 100) if total_managers > 0 else 0

    recommendations = []
    for r in too_wide:
        if r["direct_reports"] > 12:
            recommendations.append(f"URGENT: {r['manager']} has {r['direct_reports']} reports -- split team or add manager layer")
        else:
            recommendations.append(f"{r['manager']} has {r['direct_reports']} reports -- consider adding team lead")
    for r in too_narrow:
        if r["direct_reports"] < 3:
            recommendations.append(f"{r['manager']} has only {r['direct_reports']} reports -- consider merging teams or expanding scope")

    return {
        "analysis_date": datetime.now().strftime("%Y-%m-%d"),
        "total_managers": total_managers,
        "average_span": avg_span,
        "median_span": median_span,
        "healthy_percentage": health_pct,
        "summary": {
            "healthy": len(healthy),
            "too_narrow": len(too_narrow),
            "too_wide": len(too_wide)
        },
        "managers": sorted(results, key=lambda r: -r["direct_reports"]),
        "recommendations": recommendations
    }


def print_human(report):
    print(f"\n{'='*70}")
    print(f"SPAN OF CONTROL ANALYSIS")
    print(f"Date: {report['analysis_date']}")
    print(f"{'='*70}\n")

    print(f"Managers Analyzed: {report['total_managers']}")
    print(f"Average Span: {report['average_span']}")
    print(f"Median Span: {report['median_span']}")
    print(f"Healthy: {report['healthy_percentage']}%")
    print(f"  Green: {report['summary']['healthy']}  |  Narrow: {report['summary']['too_narrow']}  |  Wide: {report['summary']['too_wide']}\n")

    print("MANAGER DETAILS:")
    print("-" * 70)
    for m in report["managers"]:
        status_icon = {"GREEN": "+", "YELLOW": "~", "RED": "!"}[m["color"]]
        print(f"  [{status_icon}] {m['manager']:<30s} {m['direct_reports']:>3} reports  ({m['role_type']})  {m['status']}")

    if report["recommendations"]:
        print(f"\nRECOMMENDATIONS:")
        for r in report["recommendations"]:
            print(f"  -> {r}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Analyze manager-to-IC span of control ratios")
    parser.add_argument("--org-file", help="CSV file with employee_name, manager_name columns")
    parser.add_argument("--managers", help="Inline format: 'Manager1:reports,Manager2:reports'")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    if args.org_file:
        results = analyze_from_csv(args.org_file)
    elif args.managers:
        managers_data = {}
        for pair in args.managers.split(","):
            parts = pair.strip().rsplit(":", 1)
            if len(parts) == 2:
                managers_data[parts[0].strip()] = int(parts[1].strip())
        results = analyze_from_managers(managers_data)
    else:
        print("Error: Provide either --org-file or --managers", file=sys.stderr)
        sys.exit(1)

    report = generate_report(results)

    if args.json:
        print(json.dumps(report, indent=2))
    else:
        print_human(report)


if __name__ == "__main__":
    main()