Ma Playbook

#!/usr/bin/env python3
"""Due Diligence Tracker - Track DD items across 8 domains with priority and red flags.

Manage due diligence items for M&A transactions across financial, technical, legal,
people, market, customers, product, and security domains. Tracks status, priority,
and surfaces red flags.

Usage:
    python due_diligence_tracker.py add --domain financial --item "Revenue recognition audit" --priority 1
    python due_diligence_tracker.py list --domain technical
    python due_diligence_tracker.py report --json
"""

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

DEFAULT_STORE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "dd_data.json")

DOMAINS = {
    "financial": {"name": "Financial", "owner": "CFO", "key_questions": ["Revenue quality?", "Customer concentration?", "Burn rate?", "Deferred revenue?"], "red_flags": ["> 30% from 1 customer", "Declining margins", "Hidden liabilities", "Aggressive revenue recognition"]},
    "technical": {"name": "Technical", "owner": "CTO", "key_questions": ["Code quality?", "Tech debt?", "Architecture fit?", "Security posture?"], "red_flags": ["Monolith with no tests", "No CI/CD", "Critical security gaps", "Key person dependency"]},
    "legal": {"name": "Legal", "owner": "Legal Counsel", "key_questions": ["IP ownership?", "Pending litigation?", "Contract assignability?"], "red_flags": ["Key IP owned by individuals", "Active lawsuits", "Non-assignable contracts"]},
    "people": {"name": "People", "owner": "CHRO", "key_questions": ["Key person risk?", "Culture fit?", "Retention likelihood?"], "red_flags": ["Founders with no lockup", "Team wants to leave", "Culture mismatch"]},
    "market": {"name": "Market", "owner": "CEO/CPO", "key_questions": ["Market position?", "Competitive threats?", "Customer satisfaction?"], "red_flags": ["Declining market share", "Commoditizing market", "Low NPS"]},
    "customers": {"name": "Customers", "owner": "CRO/CPO", "key_questions": ["Churn rate?", "NPS?", "Contract terms?", "Expansion potential?"], "red_flags": ["High churn", "Short contracts", "Declining usage"]},
    "product": {"name": "Product", "owner": "CPO", "key_questions": ["PMF evidence?", "Roadmap alignment?", "Technical overlap?"], "red_flags": ["No retention data", "Divergent roadmap", "Redundant technology"]},
    "security": {"name": "Security", "owner": "CISO", "key_questions": ["Compliance status?", "Incident history?", "Data practices?"], "red_flags": ["No SOC 2", "History of breaches", "Poor data handling"]}
}

PRIORITIES = {1: "Deal-breaker (Week 1-2)", 2: "Valuation impact (Week 2-4)", 3: "Integration planning (Week 3-6)", 4: "Post-close optimization (Week 4-8)"}
STATUSES = ["not-started", "in-progress", "complete", "red-flag", "clear"]


def load_data(store_path):
    if os.path.exists(store_path):
        with open(store_path, "r") as f:
            return json.load(f)
    return {"items": [], "next_id": 1, "deal_name": "", "created": datetime.now().strftime("%Y-%m-%d")}


def save_data(data, store_path):
    with open(store_path, "w") as f:
        json.dump(data, f, indent=2)


def add_item(data, domain, item, priority, assignee="", notes=""):
    dd_item = {
        "id": data["next_id"],
        "domain": domain,
        "item": item,
        "priority": priority,
        "priority_label": PRIORITIES.get(priority, "Unknown"),
        "status": "not-started",
        "assignee": assignee or DOMAINS[domain]["owner"],
        "notes": notes,
        "red_flag": False,
        "created": datetime.now().strftime("%Y-%m-%d"),
        "updated": datetime.now().strftime("%Y-%m-%d")
    }
    data["items"].append(dd_item)
    data["next_id"] += 1
    return dd_item


def update_item(data, item_id, status=None, red_flag=None, notes=None):
    for item in data["items"]:
        if item["id"] == item_id:
            if status:
                item["status"] = status
            if red_flag is not None:
                item["red_flag"] = red_flag
                if red_flag:
                    item["status"] = "red-flag"
            if notes:
                item["notes"] = notes
            item["updated"] = datetime.now().strftime("%Y-%m-%d")
            return item
    return None


def generate_report(data):
    items = data["items"]
    total = len(items)

    by_domain = {}
    for d_key, d_info in DOMAINS.items():
        domain_items = [i for i in items if i["domain"] == d_key]
        completed = len([i for i in domain_items if i["status"] in ("complete", "clear")])
        red_flags = [i for i in domain_items if i["red_flag"]]
        by_domain[d_key] = {
            "name": d_info["name"],
            "total": len(domain_items),
            "completed": completed,
            "completion_pct": round(completed / len(domain_items) * 100) if domain_items else 0,
            "red_flags": len(red_flags),
            "red_flag_items": [{"id": r["id"], "item": r["item"]} for r in red_flags]
        }

    by_priority = {}
    for p, label in PRIORITIES.items():
        p_items = [i for i in items if i["priority"] == p]
        completed = len([i for i in p_items if i["status"] in ("complete", "clear")])
        by_priority[p] = {"label": label, "total": len(p_items), "completed": completed}

    all_red_flags = [i for i in items if i["red_flag"]]
    overall_completion = round(len([i for i in items if i["status"] in ("complete", "clear")]) / total * 100) if total else 0

    deal_status = "ON TRACK"
    if len(all_red_flags) > 0:
        p1_flags = [f for f in all_red_flags if f["priority"] == 1]
        if p1_flags:
            deal_status = "AT RISK - Deal-breaker red flags identified"
        else:
            deal_status = "CAUTION - Red flags identified (non-deal-breaker)"

    return {
        "report_date": datetime.now().strftime("%Y-%m-%d"),
        "deal_name": data.get("deal_name", ""),
        "overall_completion": overall_completion,
        "deal_status": deal_status,
        "total_items": total,
        "red_flags_count": len(all_red_flags),
        "by_domain": by_domain,
        "by_priority": by_priority,
        "red_flags": [{"id": f["id"], "domain": f["domain"], "item": f["item"], "priority": f["priority"], "notes": f["notes"]} for f in all_red_flags],
        "items": items
    }


def print_report_human(report):
    print(f"\n{'='*70}")
    print(f"DUE DILIGENCE REPORT" + (f" - {report['deal_name']}" if report["deal_name"] else ""))
    print(f"Date: {report['report_date']}")
    print(f"{'='*70}\n")

    print(f"STATUS: {report['deal_status']}")
    print(f"Overall Completion: {report['overall_completion']}% ({report['total_items']} items)")
    print(f"Red Flags: {report['red_flags_count']}\n")

    print("BY DOMAIN:")
    print("-" * 60)
    for d_key, d_data in report["by_domain"].items():
        if d_data["total"] > 0:
            bar = "#" * (d_data["completion_pct"] // 10) + "." * (10 - d_data["completion_pct"] // 10)
            flag_indicator = f" [!{d_data['red_flags']} RED FLAGS]" if d_data["red_flags"] else ""
            print(f"  {d_data['name']:<15s} [{bar}] {d_data['completion_pct']:>3}% ({d_data['completed']}/{d_data['total']}){flag_indicator}")

    print("\nBY PRIORITY:")
    for p, p_data in report["by_priority"].items():
        if p_data["total"] > 0:
            print(f"  P{p}: {p_data['label']:<35s} {p_data['completed']}/{p_data['total']} complete")

    if report["red_flags"]:
        print(f"\nRED FLAGS ({report['red_flags_count']}):")
        print("-" * 60)
        for f in report["red_flags"]:
            print(f"  [!] P{f['priority']} {f['domain']}: {f['item']}")
            if f["notes"]:
                print(f"      Notes: {f['notes']}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Track M&A due diligence items")
    subparsers = parser.add_subparsers(dest="command")

    add_p = subparsers.add_parser("add", help="Add DD item")
    add_p.add_argument("--domain", required=True, choices=list(DOMAINS.keys()))
    add_p.add_argument("--item", required=True, help="DD item description")
    add_p.add_argument("--priority", type=int, required=True, choices=[1,2,3,4])
    add_p.add_argument("--assignee", default="")
    add_p.add_argument("--notes", default="")
    add_p.add_argument("--json", action="store_true")
    add_p.add_argument("--store", default=DEFAULT_STORE)

    update_p = subparsers.add_parser("update", help="Update DD item")
    update_p.add_argument("--id", type=int, required=True)
    update_p.add_argument("--status", choices=STATUSES)
    update_p.add_argument("--red-flag", action="store_true")
    update_p.add_argument("--notes", default="")
    update_p.add_argument("--json", action="store_true")
    update_p.add_argument("--store", default=DEFAULT_STORE)

    list_p = subparsers.add_parser("list", help="List DD items")
    list_p.add_argument("--domain", choices=list(DOMAINS.keys()))
    list_p.add_argument("--priority", type=int, choices=[1,2,3,4])
    list_p.add_argument("--json", action="store_true")
    list_p.add_argument("--store", default=DEFAULT_STORE)

    report_p = subparsers.add_parser("report", help="Full DD report")
    report_p.add_argument("--json", action="store_true")
    report_p.add_argument("--store", default=DEFAULT_STORE)

    init_p = subparsers.add_parser("init", help="Initialize DD tracker with standard items")
    init_p.add_argument("--deal-name", required=True)
    init_p.add_argument("--json", action="store_true")
    init_p.add_argument("--store", default=DEFAULT_STORE)

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

    data = load_data(args.store)

    if args.command == "init":
        data["deal_name"] = args.deal_name
        # Add standard DD items
        standard_items = [
            ("financial", "Revenue recognition verification", 1),
            ("financial", "Customer concentration analysis", 1),
            ("financial", "Cash position and burn rate verification", 1),
            ("financial", "Liability inventory (known and contingent)", 1),
            ("financial", "Cohort retention analysis", 2),
            ("technical", "Code quality and architecture review", 2),
            ("technical", "Tech debt assessment", 2),
            ("technical", "Security posture evaluation", 1),
            ("technical", "CI/CD and deployment practices", 3),
            ("legal", "IP ownership verification", 1),
            ("legal", "Pending litigation review", 1),
            ("legal", "Contract assignability assessment", 2),
            ("legal", "Employee agreement review", 2),
            ("people", "Key person risk assessment", 1),
            ("people", "Culture compatibility evaluation", 3),
            ("people", "Retention plan for critical talent", 2),
            ("people", "Org structure and compensation review", 3),
            ("market", "Market position assessment", 2),
            ("market", "Competitive landscape analysis", 2),
            ("customers", "Churn rate and NPS verification", 2),
            ("customers", "Contract terms review", 2),
            ("product", "PMF evidence review", 2),
            ("product", "Roadmap alignment assessment", 3),
            ("security", "Compliance certification status", 2),
            ("security", "Incident history review", 2),
        ]
        for domain, item, priority in standard_items:
            add_item(data, domain, item, priority)
        save_data(data, args.store)
        if args.json:
            print(json.dumps({"deal_name": args.deal_name, "items_created": len(standard_items)}, indent=2))
        else:
            print(f"DD tracker initialized for '{args.deal_name}' with {len(standard_items)} standard items")

    elif args.command == "add":
        item = add_item(data, args.domain, args.item, args.priority, args.assignee, args.notes)
        save_data(data, args.store)
        if args.json:
            print(json.dumps(item, indent=2))
        else:
            print(f"DD item #{item['id']} added: [{args.domain}] {args.item}")

    elif args.command == "update":
        item = update_item(data, args.id, args.status, args.red_flag if args.red_flag else None, args.notes)
        if item:
            save_data(data, args.store)
            if args.json:
                print(json.dumps(item, indent=2))
            else:
                print(f"DD item #{item['id']} updated: {item['status']}" + (" [RED FLAG]" if item["red_flag"] else ""))
        else:
            print(f"Error: Item #{args.id} not found", file=sys.stderr)
            sys.exit(1)

    elif args.command == "list":
        items = data["items"]
        if args.domain:
            items = [i for i in items if i["domain"] == args.domain]
        if args.priority:
            items = [i for i in items if i["priority"] == args.priority]
        if args.json:
            print(json.dumps(items, indent=2))
        else:
            for i in items:
                flag = "[!]" if i["red_flag"] else "   "
                print(f"  {flag} #{i['id']:>3} P{i['priority']} [{i['domain']:<10s}] {i['status']:<12s} {i['item']}")

    elif args.command == "report":
        report = generate_report(data)
        if args.json:
            print(json.dumps(report, indent=2))
        else:
            print_report_human(report)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Integration Planner - Generate 100-day post-acquisition integration plan.

Creates a phased integration plan with milestones, owners, and status tracking.
Supports three integration modes: absorb, preserve, and hybrid.

Usage:
    python integration_planner.py --mode absorb --target-name "AcquiredCo" --headcount 25
    python integration_planner.py --mode hybrid --target-name "TargetCo" --headcount 50 --has-product-overlap --json
"""

import argparse
import json
import sys
from datetime import datetime, timedelta

INTEGRATION_MODES = {
    "absorb": {
        "name": "Full Absorption",
        "description": "Fully integrate acquired company into acquirer operations",
        "when": "Product overlap, same ICP, maximum synergy potential",
        "risk": "Loss of acquired team culture and key talent",
        "timeline": "Aggressive: 60-90 days for core integration"
    },
    "preserve": {
        "name": "Preserve Independence",
        "description": "Acquired company operates independently with shared backend",
        "when": "Different market/product, brand value, minimal overlap",
        "risk": "Missed synergies, coordination overhead",
        "timeline": "Gradual: 6-12 months for selective integration"
    },
    "hybrid": {
        "name": "Hybrid Integration",
        "description": "Shared backend and infrastructure, independent product and GTM",
        "when": "Complementary products, shared customer base, distinct brands",
        "risk": "Complexity in execution, unclear boundaries",
        "timeline": "Moderate: 90-120 days for core, ongoing for product"
    }
}


def generate_plan(mode, target_name, headcount, has_product_overlap, start_date):
    mode_info = INTEGRATION_MODES[mode]

    phases = []

    # Phase 1: Stabilize (Days 0-30)
    phase1_items = [
        {"item": f"CEO welcome communication to {target_name} team", "owner": "CEO", "day": 0, "priority": "critical", "status": "not-started"},
        {"item": "Customer communication (if acquisition is public)", "owner": "CMO + CRO", "day": 0, "priority": "critical", "status": "not-started"},
        {"item": "Key person 1:1 meetings (schedule within 48 hours)", "owner": "CHRO + CEO", "day": 1, "priority": "critical", "status": "not-started"},
        {"item": "Systems access granted to acquired team", "owner": "CTO", "day": 1, "priority": "critical", "status": "not-started"},
        {"item": "Reporting structure clarified and communicated", "owner": "COO", "day": 1, "priority": "critical", "status": "not-started"},
        {"item": "Compensation and benefits confirmed for all acquired employees", "owner": "CHRO", "day": 3, "priority": "critical", "status": "not-started"},
        {"item": "Integration lead appointed and introduced", "owner": "CEO", "day": 1, "priority": "critical", "status": "not-started"},
        {"item": "Retention bonuses executed for key personnel", "owner": "CHRO", "day": 7, "priority": "high", "status": "not-started"},
        {"item": "Customer success outreach to top 20 accounts", "owner": "CRO", "day": 7, "priority": "high", "status": "not-started"},
        {"item": "IT security audit of acquired systems", "owner": "CISO", "day": 14, "priority": "high", "status": "not-started"},
        {"item": "Cultural integration assessment initiated", "owner": "CHRO", "day": 14, "priority": "medium", "status": "not-started"},
        {"item": "Weekly integration standup established", "owner": "Integration Lead", "day": 7, "priority": "high", "status": "not-started"},
    ]
    phases.append({"phase": 1, "name": "Stabilize", "days": "0-30", "focus": "Retain people, retain customers, establish communication", "items": phase1_items})

    # Phase 2: Integrate (Days 30-60)
    phase2_items = [
        {"item": "IT systems integration plan finalized", "owner": "CTO", "day": 30, "priority": "high", "status": "not-started"},
        {"item": "Tool consolidation plan (identify overlapping tools)", "owner": "CTO + COO", "day": 35, "priority": "medium", "status": "not-started"},
        {"item": "Process mapping: identify redundant and complementary processes", "owner": "COO", "day": 35, "priority": "medium", "status": "not-started"},
        {"item": "Combined org chart finalized and communicated", "owner": "CHRO", "day": 40, "priority": "high", "status": "not-started"},
        {"item": "Unified customer support model defined", "owner": "CRO", "day": 40, "priority": "high", "status": "not-started"},
        {"item": "Financial systems integration (billing, reporting)", "owner": "CFO", "day": 45, "priority": "high", "status": "not-started"},
        {"item": "Email, Slack, and communication platform migration", "owner": "CTO", "day": 45, "priority": "medium", "status": "not-started"},
        {"item": "Brand and marketing alignment decision", "owner": "CMO", "day": 50, "priority": "medium", "status": "not-started"},
    ]

    if has_product_overlap and mode != "preserve":
        phase2_items.append({"item": "Product overlap analysis and roadmap consolidation", "owner": "CPO", "day": 35, "priority": "high", "status": "not-started"})
        phase2_items.append({"item": "Customer migration plan for overlapping products", "owner": "CPO + CRO", "day": 50, "priority": "high", "status": "not-started"})

    phases.append({"phase": 2, "name": "Integrate", "days": "30-60", "focus": "Systems alignment, process merge, team unification", "items": phase2_items})

    # Phase 3: Optimize (Days 60-90)
    phase3_items = [
        {"item": "Cross-sell campaign to combined customer base", "owner": "CRO + CMO", "day": 60, "priority": "high", "status": "not-started"},
        {"item": "Combined product roadmap published", "owner": "CPO", "day": 65, "priority": "high", "status": "not-started"},
        {"item": "Headcount optimization (if planned)", "owner": "CHRO + COO", "day": 70, "priority": "medium", "status": "not-started"},
        {"item": "Vendor contract consolidation", "owner": "CFO + COO", "day": 75, "priority": "medium", "status": "not-started"},
        {"item": "Combined OKRs for next quarter defined", "owner": "COO", "day": 80, "priority": "high", "status": "not-started"},
        {"item": "Integration success metrics assessed", "owner": "Integration Lead", "day": 85, "priority": "high", "status": "not-started"},
    ]
    phases.append({"phase": 3, "name": "Optimize", "days": "60-90", "focus": "Synergy realization, combined roadmap, efficiency gains", "items": phase3_items})

    # Phase 4: Accelerate (Days 90-100)
    phase4_items = [
        {"item": "Joint GTM strategy launched", "owner": "CRO + CMO", "day": 90, "priority": "high", "status": "not-started"},
        {"item": "Integration retrospective conducted", "owner": "Integration Lead", "day": 95, "priority": "high", "status": "not-started"},
        {"item": "100-day integration report to board", "owner": "CEO", "day": 100, "priority": "critical", "status": "not-started"},
        {"item": "Transition from integration to BAU operations", "owner": "COO", "day": 100, "priority": "high", "status": "not-started"},
    ]
    phases.append({"phase": 4, "name": "Accelerate", "days": "90-100", "focus": "Scale combined capabilities, transition to business-as-usual", "items": phase4_items})

    # Calculate all item dates
    total_items = 0
    for phase in phases:
        for item in phase["items"]:
            item["target_date"] = (start_date + timedelta(days=item["day"])).strftime("%Y-%m-%d")
            total_items += 1

    # Success metrics
    success_metrics = [
        {"metric": "Key person retention", "target": ">= 90% at 100 days", "owner": "CHRO"},
        {"metric": "Customer retention", "target": "Zero churn attributable to integration", "owner": "CRO"},
        {"metric": "Systems integrated", "target": "Core systems unified by Day 60", "owner": "CTO"},
        {"metric": "Revenue synergies initiated", "target": "First cross-sell campaign live by Day 60", "owner": "CRO"},
        {"metric": "Employee engagement", "target": "eNPS survey at Day 90 >= baseline", "owner": "CHRO"},
        {"metric": "Customer satisfaction", "target": "NPS maintained or improved at Day 90", "owner": "CPO"},
    ]

    return {
        "plan_date": datetime.now().strftime("%Y-%m-%d"),
        "target_company": target_name,
        "headcount": headcount,
        "integration_mode": mode_info["name"],
        "mode_description": mode_info["description"],
        "mode_risk": mode_info["risk"],
        "start_date": start_date.strftime("%Y-%m-%d"),
        "end_date": (start_date + timedelta(days=100)).strftime("%Y-%m-%d"),
        "total_items": total_items,
        "phases": phases,
        "success_metrics": success_metrics,
        "critical_first_week": [i for phase in phases for i in phase["items"] if i["day"] <= 7]
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"100-DAY INTEGRATION PLAN: {result['target_company']}")
    print(f"Mode: {result['integration_mode']}")
    print(f"Period: {result['start_date']} to {result['end_date']}")
    print(f"{'='*70}\n")

    print(f"Headcount: {result['headcount']}")
    print(f"Risk: {result['mode_risk']}")
    print(f"Total Items: {result['total_items']}\n")

    for phase in result["phases"]:
        print(f"\n--- PHASE {phase['phase']}: {phase['name'].upper()} (Days {phase['days']}) ---")
        print(f"Focus: {phase['focus']}")
        for item in sorted(phase["items"], key=lambda x: x["day"]):
            priority_marker = "!" if item["priority"] == "critical" else "*" if item["priority"] == "high" else " "
            print(f"  [{priority_marker}] Day {item['day']:>3}  {item['owner']:<20s}  {item['item']}")

    print(f"\nSUCCESS METRICS:")
    print("-" * 60)
    for m in result["success_metrics"]:
        print(f"  {m['metric']:<30s} Target: {m['target']:<35s} Owner: {m['owner']}")

    print(f"\nCRITICAL FIRST WEEK:")
    for i in sorted(result["critical_first_week"], key=lambda x: x["day"]):
        print(f"  Day {i['day']}: {i['item']} ({i['owner']})")
    print()


def main():
    parser = argparse.ArgumentParser(description="Generate 100-day post-acquisition integration plan")
    parser.add_argument("--mode", required=True, choices=list(INTEGRATION_MODES.keys()), help="Integration mode")
    parser.add_argument("--target-name", required=True, help="Acquired company name")
    parser.add_argument("--headcount", type=int, required=True, help="Acquired company headcount")
    parser.add_argument("--has-product-overlap", action="store_true", help="Product overlap exists")
    parser.add_argument("--start-date", default=None, help="Integration start date (YYYY-MM-DD)")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    start_date = datetime.strptime(args.start_date, "%Y-%m-%d") if args.start_date else datetime.now()
    result = generate_plan(args.mode, args.target_name, args.headcount, args.has_product_overlap, start_date)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Synergy Calculator - Calculate and track revenue and cost synergies for M&A.

Provides confidence-weighted projections for revenue synergies (cross-sell, upsell,
market expansion) and cost synergies (headcount, tools, infrastructure). Outputs
phased realization timeline.

Usage:
    python synergy_calculator.py --revenue-synergies 500000 --cost-synergies 200000 --confidence 0.7 --timeline-months 24
    python synergy_calculator.py --revenue-synergies 1000000 --cost-synergies 500000 --confidence 0.6 --timeline-months 18 --deal-value 5000000 --json
"""

import argparse
import json
import sys
from datetime import datetime

SYNERGY_TYPES = {
    "revenue": {
        "categories": [
            {"name": "Cross-sell to acquired customer base", "typical_pct": 0.30, "realization_months": "6-18"},
            {"name": "Upsell combined product to existing customers", "typical_pct": 0.25, "realization_months": "9-24"},
            {"name": "New market access / geographic expansion", "typical_pct": 0.25, "realization_months": "12-24"},
            {"name": "Pricing power from combined offering", "typical_pct": 0.10, "realization_months": "6-12"},
            {"name": "Combined brand / reputation leverage", "typical_pct": 0.10, "realization_months": "12-36"}
        ],
        "typical_confidence_discount": 0.50,
        "warning": "Revenue synergies are historically overestimated by 30-50%"
    },
    "cost": {
        "categories": [
            {"name": "Headcount optimization (overlapping roles)", "typical_pct": 0.35, "realization_months": "1-6"},
            {"name": "Tool and vendor consolidation", "typical_pct": 0.20, "realization_months": "3-12"},
            {"name": "Infrastructure consolidation", "typical_pct": 0.20, "realization_months": "6-18"},
            {"name": "G&A overhead reduction", "typical_pct": 0.15, "realization_months": "3-9"},
            {"name": "Procurement leverage", "typical_pct": 0.10, "realization_months": "6-12"}
        ],
        "typical_confidence_discount": 0.75,
        "warning": "Cost synergies are more reliable but require execution discipline"
    }
}

REALIZATION_PHASES = [
    {"phase": 1, "name": "Quick Wins", "months": "0-3", "typical_pct": 0.15, "focus": "Tool consolidation, obvious overlaps, procurement wins"},
    {"phase": 2, "name": "Integration", "months": "3-6", "typical_pct": 0.25, "focus": "Headcount optimization, process merge, initial cross-sell"},
    {"phase": 3, "name": "Optimization", "months": "6-12", "typical_pct": 0.35, "focus": "Revenue synergies begin, infrastructure consolidation, combined product"},
    {"phase": 4, "name": "Full Realization", "months": "12-24", "typical_pct": 0.25, "focus": "Market expansion, full revenue synergies, pricing optimization"}
]


def calculate_synergies(revenue_synergies, cost_synergies, confidence, timeline_months, deal_value=None):
    # Confidence-weighted projections
    revenue_weighted = round(revenue_synergies * confidence * SYNERGY_TYPES["revenue"]["typical_confidence_discount"])
    cost_weighted = round(cost_synergies * confidence * SYNERGY_TYPES["cost"]["typical_confidence_discount"])
    total_raw = revenue_synergies + cost_synergies
    total_weighted = revenue_weighted + cost_weighted

    # Scenario modeling
    scenarios = {
        "optimistic": {
            "revenue": round(revenue_synergies * 1.0),
            "cost": round(cost_synergies * 1.0),
            "total": round(revenue_synergies + cost_synergies),
            "probability": f"{int(confidence * 30)}%"
        },
        "base": {
            "revenue": revenue_weighted,
            "cost": cost_weighted,
            "total": total_weighted,
            "probability": f"{int(confidence * 100)}%"
        },
        "conservative": {
            "revenue": round(revenue_synergies * confidence * 0.3),
            "cost": round(cost_synergies * confidence * 0.6),
            "total": round(revenue_synergies * confidence * 0.3 + cost_synergies * confidence * 0.6),
            "probability": f"{int(min(95, confidence * 100 + 20))}%"
        }
    }

    # Phased realization timeline
    phases = []
    cumulative = 0
    for phase in REALIZATION_PHASES:
        phase_amount = round(total_weighted * phase["typical_pct"])
        cumulative += phase_amount
        phases.append({
            "phase": phase["phase"],
            "name": phase["name"],
            "months": phase["months"],
            "amount": phase_amount,
            "cumulative": cumulative,
            "focus": phase["focus"],
            "pct_of_total": f"{int(phase['typical_pct'] * 100)}%"
        })

    # Revenue synergy breakdown
    revenue_breakdown = []
    for cat in SYNERGY_TYPES["revenue"]["categories"]:
        revenue_breakdown.append({
            "category": cat["name"],
            "estimated_amount": round(revenue_synergies * cat["typical_pct"]),
            "weighted_amount": round(revenue_weighted * cat["typical_pct"]),
            "realization_timeline": cat["realization_months"]
        })

    # Cost synergy breakdown
    cost_breakdown = []
    for cat in SYNERGY_TYPES["cost"]["categories"]:
        cost_breakdown.append({
            "category": cat["name"],
            "estimated_amount": round(cost_synergies * cat["typical_pct"]),
            "weighted_amount": round(cost_weighted * cat["typical_pct"]),
            "realization_timeline": cat["realization_months"]
        })

    # ROI if deal value provided
    roi_analysis = None
    if deal_value and deal_value > 0:
        annual_synergy = total_weighted * (12 / timeline_months) if timeline_months > 0 else 0
        payback_months = round(deal_value / (total_weighted / timeline_months)) if total_weighted > 0 else 999
        roi_pct = round((total_weighted / deal_value) * 100, 1) if deal_value > 0 else 0
        roi_analysis = {
            "deal_value": deal_value,
            "total_synergies_over_period": total_weighted,
            "annualized_synergies": round(annual_synergy),
            "payback_months": payback_months,
            "roi_percentage": roi_pct,
            "synergy_as_pct_of_deal": round(total_weighted / deal_value * 100, 1)
        }

    return {
        "calculation_date": datetime.now().strftime("%Y-%m-%d"),
        "inputs": {
            "revenue_synergies_raw": revenue_synergies,
            "cost_synergies_raw": cost_synergies,
            "confidence_level": confidence,
            "timeline_months": timeline_months,
            "deal_value": deal_value
        },
        "summary": {
            "total_raw": total_raw,
            "total_confidence_weighted": total_weighted,
            "revenue_weighted": revenue_weighted,
            "cost_weighted": cost_weighted,
            "confidence_discount_applied": f"Revenue: {int(confidence * SYNERGY_TYPES['revenue']['typical_confidence_discount'] * 100)}%, Cost: {int(confidence * SYNERGY_TYPES['cost']['typical_confidence_discount'] * 100)}%"
        },
        "scenarios": scenarios,
        "revenue_breakdown": revenue_breakdown,
        "cost_breakdown": cost_breakdown,
        "realization_phases": phases,
        "roi_analysis": roi_analysis,
        "warnings": [
            SYNERGY_TYPES["revenue"]["warning"],
            SYNERGY_TYPES["cost"]["warning"],
            f"Timeline assumes {timeline_months} months; delays common in first 6 months",
            "Track synergies quarterly with specific metrics and owners"
        ]
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"SYNERGY CALCULATION")
    print(f"Date: {result['calculation_date']}")
    print(f"{'='*70}\n")

    s = result["summary"]
    print(f"SUMMARY:")
    print(f"  Total Raw Estimate:        ${s['total_raw']:>12,}")
    print(f"  Confidence-Weighted Total:  ${s['total_confidence_weighted']:>12,}")
    print(f"  Revenue Synergies (weighted): ${s['revenue_weighted']:>10,}")
    print(f"  Cost Synergies (weighted):    ${s['cost_weighted']:>10,}")
    print(f"  Discount Applied: {s['confidence_discount_applied']}\n")

    print("SCENARIOS:")
    print("-" * 50)
    for name, sc in result["scenarios"].items():
        print(f"  {name.upper():<15s} ${sc['total']:>10,}  (probability: {sc['probability']})")

    print(f"\nREVENUE SYNERGY BREAKDOWN:")
    print("-" * 60)
    for r in result["revenue_breakdown"]:
        print(f"  ${r['weighted_amount']:>8,}  {r['category']:<45s}  ({r['realization_timeline']})")

    print(f"\nCOST SYNERGY BREAKDOWN:")
    print("-" * 60)
    for c in result["cost_breakdown"]:
        print(f"  ${c['weighted_amount']:>8,}  {c['category']:<45s}  ({c['realization_timeline']})")

    print(f"\nREALIZATION TIMELINE:")
    print("-" * 60)
    for p in result["realization_phases"]:
        print(f"  Phase {p['phase']}: {p['name']:<20s} Months {p['months']:<8s} ${p['amount']:>8,}  (cumulative: ${p['cumulative']:>10,})")

    if result["roi_analysis"]:
        roi = result["roi_analysis"]
        print(f"\nROI ANALYSIS:")
        print(f"  Deal Value:         ${roi['deal_value']:>12,}")
        print(f"  Total Synergies:    ${roi['total_synergies_over_period']:>12,} ({roi['synergy_as_pct_of_deal']}% of deal)")
        print(f"  Annualized:         ${roi['annualized_synergies']:>12,}")
        print(f"  Payback:            {roi['payback_months']} months")

    print(f"\nWARNINGS:")
    for w in result["warnings"]:
        print(f"  [!] {w}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Calculate M&A synergies with confidence weighting")
    parser.add_argument("--revenue-synergies", type=float, required=True, help="Estimated revenue synergies ($)")
    parser.add_argument("--cost-synergies", type=float, required=True, help="Estimated cost synergies ($)")
    parser.add_argument("--confidence", type=float, required=True, help="Confidence level (0.0-1.0)")
    parser.add_argument("--timeline-months", type=int, required=True, help="Realization timeline in months")
    parser.add_argument("--deal-value", type=float, default=None, help="Deal value for ROI calculation ($)")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    if not 0 < args.confidence <= 1.0:
        print("Error: Confidence must be between 0 and 1.0", file=sys.stderr)
        sys.exit(1)

    result = calculate_synergies(args.revenue_synergies, args.cost_synergies, args.confidence, args.timeline_months, args.deal_value)

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


if __name__ == "__main__":
    main()