Marketing Ops

#!/usr/bin/env python3
"""Campaign Budget Allocator - Allocate marketing budget across campaigns and channels.

Distributes a total budget across campaigns based on priority, historical
performance, and strategic objectives.

Usage:
    python campaign_budget_allocator.py campaigns.json --budget 100000
    python campaign_budget_allocator.py campaigns.json --budget 100000 --json
    python campaign_budget_allocator.py --demo
"""

import argparse
import json
import sys


PRIORITY_WEIGHTS = {"critical": 4, "high": 3, "medium": 2, "low": 1}
OBJECTIVE_WEIGHTS = {"revenue": 3, "pipeline": 2.5, "leads": 2, "awareness": 1.5, "retention": 1.5}


def allocate_budget(campaigns, total_budget, strategy="balanced"):
    """Allocate budget across campaigns."""
    if not campaigns:
        return {"error": "No campaigns provided"}

    # Calculate priority scores
    for camp in campaigns:
        priority = camp.get("priority", "medium")
        historical_roas = camp.get("historical_roas", 1.0)
        objective = camp.get("objective", "leads")
        strategic_importance = camp.get("strategic_importance", 5)

        # Composite score
        priority_score = PRIORITY_WEIGHTS.get(priority, 2)
        objective_score = OBJECTIVE_WEIGHTS.get(objective, 2)
        performance_score = min(5, historical_roas)  # Cap at 5

        if strategy == "performance":
            # Weight heavily toward historical performance
            camp["_score"] = performance_score * 3 + priority_score + objective_score
        elif strategy == "strategic":
            # Weight toward strategic importance
            camp["_score"] = strategic_importance * 2 + priority_score * 2 + objective_score
        else:  # balanced
            camp["_score"] = priority_score * 2 + performance_score * 1.5 + objective_score + strategic_importance * 0.5

    # Normalize scores to get allocation percentages
    total_score = sum(c["_score"] for c in campaigns)

    allocations = []
    remaining = total_budget

    for camp in sorted(campaigns, key=lambda x: x["_score"], reverse=True):
        share = camp["_score"] / max(total_score, 1)

        # Apply min/max constraints
        min_budget = camp.get("min_budget", 0)
        max_budget = camp.get("max_budget", total_budget)
        allocated = max(min_budget, min(max_budget, int(total_budget * share)))

        allocations.append({
            "campaign": camp.get("name", "Unnamed"),
            "objective": camp.get("objective", "leads"),
            "priority": camp.get("priority", "medium"),
            "historical_roas": camp.get("historical_roas"),
            "score": round(camp["_score"], 2),
            "allocated_budget": allocated,
            "budget_share": round(share * 100, 1),
        })

    # Normalize to fit exact budget
    total_allocated = sum(a["allocated_budget"] for a in allocations)
    if total_allocated > 0:
        scale = total_budget / total_allocated
        for a in allocations:
            a["allocated_budget"] = int(a["allocated_budget"] * scale)

    # Projected outcomes
    for a in allocations:
        camp_data = next((c for c in campaigns if c.get("name") == a["campaign"]), {})
        roas = camp_data.get("historical_roas", 1.0)
        cpl = camp_data.get("historical_cpl", 100)

        a["projected_revenue"] = round(a["allocated_budget"] * roas, 2)
        a["projected_leads"] = int(a["allocated_budget"] / max(cpl, 1))

    total_projected_revenue = sum(a["projected_revenue"] for a in allocations)
    total_projected_leads = sum(a["projected_leads"] for a in allocations)

    return {
        "strategy": strategy,
        "total_budget": total_budget,
        "total_allocated": sum(a["allocated_budget"] for a in allocations),
        "projected_revenue": round(total_projected_revenue, 2),
        "projected_roas": round(total_projected_revenue / max(total_budget, 1), 2),
        "projected_leads": total_projected_leads,
        "projected_cpl": round(total_budget / max(total_projected_leads, 1), 2),
        "allocations": allocations,
    }


def get_demo_data():
    return {
        "campaigns": [
            {"name": "Paid Search - Brand", "priority": "critical", "objective": "revenue", "historical_roas": 4.2, "historical_cpl": 45, "strategic_importance": 8},
            {"name": "LinkedIn ABM Campaign", "priority": "high", "objective": "pipeline", "historical_roas": 2.8, "historical_cpl": 120, "strategic_importance": 9},
            {"name": "Content Marketing", "priority": "high", "objective": "leads", "historical_roas": 3.5, "historical_cpl": 35, "strategic_importance": 7},
            {"name": "Email Nurture", "priority": "medium", "objective": "revenue", "historical_roas": 8.5, "historical_cpl": 12, "strategic_importance": 6},
            {"name": "Display Retargeting", "priority": "medium", "objective": "leads", "historical_roas": 1.8, "historical_cpl": 85, "strategic_importance": 4},
            {"name": "Brand Awareness", "priority": "low", "objective": "awareness", "historical_roas": 0.5, "historical_cpl": 200, "strategic_importance": 5},
        ],
        "budget": 100000,
    }


def format_report(analysis):
    """Format human-readable allocation report."""
    lines = []
    lines.append("=" * 75)
    lines.append(f"BUDGET ALLOCATION ({analysis['strategy'].upper()} STRATEGY)")
    lines.append("=" * 75)
    lines.append(f"Total Budget:       ${analysis['total_budget']:,.0f}")
    lines.append(f"Projected Revenue:  ${analysis['projected_revenue']:,.0f}")
    lines.append(f"Projected ROAS:     {analysis['projected_roas']:.1f}x")
    lines.append(f"Projected Leads:    {analysis['projected_leads']:,}")
    lines.append(f"Projected CPL:      ${analysis['projected_cpl']:.0f}")
    lines.append("")

    lines.append("--- ALLOCATIONS ---")
    lines.append(f"{'Campaign':<25} {'Budget':>10} {'Share':>6} {'ROAS':>6} {'Proj Rev':>12} {'Leads':>7}")
    lines.append("-" * 70)

    for a in sorted(analysis["allocations"], key=lambda x: x["allocated_budget"], reverse=True):
        roas = a.get("historical_roas", "N/A")
        roas_str = f"{roas:.1f}x" if isinstance(roas, (int, float)) else roas
        lines.append(
            f"{a['campaign']:<25} ${a['allocated_budget']:>9,} {a['budget_share']:>5.0f}% "
            f"{roas_str:>6} ${a['projected_revenue']:>11,.0f} {a['projected_leads']:>7,}"
        )

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Allocate marketing budget across campaigns")
    parser.add_argument("input", nargs="?", help="JSON file with campaign data")
    parser.add_argument("--budget", type=float, help="Total budget to allocate")
    parser.add_argument("--strategy", choices=["balanced", "performance", "strategic"], default="balanced")
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON")
    parser.add_argument("--demo", action="store_true", help="Run with demo data")
    args = parser.parse_args()

    if args.demo:
        data = get_demo_data()
        campaigns = data["campaigns"]
        budget = data["budget"]
    elif args.input:
        try:
            with open(args.input, "r", encoding="utf-8") as f:
                data = json.load(f)
            campaigns = data if isinstance(data, list) else data.get("campaigns", [])
            budget = args.budget or data.get("budget", 100000)
        except FileNotFoundError:
            print(f"Error: File not found: {args.input}", file=sys.stderr)
            sys.exit(1)
    else:
        parser.print_help()
        sys.exit(1)

    if args.budget:
        budget = args.budget

    analysis = allocate_budget(campaigns, budget, args.strategy)

    if args.json_output:
        print(json.dumps(analysis, indent=2))
    else:
        print(format_report(analysis))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Lead Scoring Simulator - Simulate and validate lead scoring models.

Scores leads based on demographic fit and behavioral signals, validates
model effectiveness against actual outcomes, and tunes thresholds.

Usage:
    python lead_scoring_simulator.py leads.json
    python lead_scoring_simulator.py leads.json --model scoring_model.json --json
    python lead_scoring_simulator.py --demo
"""

import argparse
import json
import sys


DEFAULT_MODEL = {
    "demographic": {
        "title_match": {"values": ["vp", "director", "head", "manager", "lead", "chief"], "score": 20},
        "company_size_fit": {"min": 50, "max": 5000, "score": 15},
        "industry_fit": {"values": ["saas", "technology", "fintech", "software"], "score": 15},
    },
    "behavioral": {
        "pricing_page_visit": {"score": 25},
        "demo_requested": {"score": 30},
        "case_study_viewed": {"score": 15},
        "emails_opened_3plus": {"score": 10},
        "content_downloaded": {"score": 10},
        "webinar_attended": {"score": 15},
        "trial_started": {"score": 30},
        "feature_used": {"score": 20},
    },
    "negative": {
        "competitor_employee": {"score": -50},
        "student_email": {"score": -40},
        "unsubscribed": {"score": -30},
        "bounced_email": {"score": -20},
    },
    "thresholds": {
        "hot": 76,
        "sql": 51,
        "mql": 26,
        "nurture": 0,
    },
}


def score_lead(lead, model=None):
    """Score a single lead against the scoring model."""
    if model is None:
        model = DEFAULT_MODEL

    total_score = 0
    scoring_details = []

    # Demographic scoring
    for signal, config in model.get("demographic", {}).items():
        lead_value = lead.get(signal)
        if lead_value is None:
            continue

        matched = False
        if "values" in config:
            if isinstance(lead_value, str):
                matched = any(v.lower() in lead_value.lower() for v in config["values"])
            elif isinstance(lead_value, bool):
                matched = lead_value
        elif "min" in config and "max" in config:
            try:
                val = float(lead_value)
                matched = config["min"] <= val <= config["max"]
            except (ValueError, TypeError):
                pass

        if matched:
            total_score += config["score"]
            scoring_details.append({
                "signal": signal,
                "type": "demographic",
                "score": config["score"],
                "value": lead_value,
            })

    # Behavioral scoring
    for signal, config in model.get("behavioral", {}).items():
        lead_value = lead.get(signal, False)
        if lead_value:
            total_score += config["score"]
            scoring_details.append({
                "signal": signal,
                "type": "behavioral",
                "score": config["score"],
            })

    # Negative signals
    for signal, config in model.get("negative", {}).items():
        lead_value = lead.get(signal, False)
        if lead_value:
            total_score += config["score"]
            scoring_details.append({
                "signal": signal,
                "type": "negative",
                "score": config["score"],
            })

    # Determine segment
    thresholds = model.get("thresholds", DEFAULT_MODEL["thresholds"])
    if total_score >= thresholds.get("hot", 76):
        segment = "hot"
    elif total_score >= thresholds.get("sql", 51):
        segment = "sql"
    elif total_score >= thresholds.get("mql", 26):
        segment = "mql"
    else:
        segment = "nurture"

    return {
        "lead": lead.get("name", lead.get("email", "Unknown")),
        "total_score": total_score,
        "segment": segment,
        "details": scoring_details,
        "demographic_score": sum(d["score"] for d in scoring_details if d["type"] == "demographic"),
        "behavioral_score": sum(d["score"] for d in scoring_details if d["type"] == "behavioral"),
        "negative_score": sum(d["score"] for d in scoring_details if d["type"] == "negative"),
    }


def simulate_scoring(leads, model=None):
    """Score all leads and generate distribution analysis."""
    results = [score_lead(lead, model) for lead in leads]

    # Segment distribution
    segments = {"hot": 0, "sql": 0, "mql": 0, "nurture": 0}
    for r in results:
        segments[r["segment"]] = segments.get(r["segment"], 0) + 1

    # Score distribution
    scores = [r["total_score"] for r in results]
    avg_score = sum(scores) / max(len(scores), 1)
    min_score = min(scores) if scores else 0
    max_score = max(scores) if scores else 0

    # Validation against outcomes (if available)
    validation = None
    leads_with_outcome = [l for l in leads if "converted" in l]
    if leads_with_outcome:
        scored_with_outcome = []
        for lead in leads_with_outcome:
            result = score_lead(lead, model)
            result["actual_converted"] = lead["converted"]
            scored_with_outcome.append(result)

        # Check if high scores correlate with conversions
        high_scored = [s for s in scored_with_outcome if s["segment"] in ("hot", "sql")]
        low_scored = [s for s in scored_with_outcome if s["segment"] in ("mql", "nurture")]

        high_conversion = (
            sum(1 for s in high_scored if s["actual_converted"]) / max(len(high_scored), 1) * 100
        )
        low_conversion = (
            sum(1 for s in low_scored if s["actual_converted"]) / max(len(low_scored), 1) * 100
        )

        validation = {
            "leads_with_outcome": len(leads_with_outcome),
            "high_score_conversion_rate": round(high_conversion, 1),
            "low_score_conversion_rate": round(low_conversion, 1),
            "model_effective": high_conversion > low_conversion,
            "lift": round(high_conversion / max(low_conversion, 0.1), 1),
        }

    results.sort(key=lambda x: x["total_score"], reverse=True)

    return {
        "total_leads": len(leads),
        "segments": segments,
        "score_stats": {
            "average": round(avg_score, 1),
            "min": min_score,
            "max": max_score,
        },
        "leads": results,
        "validation": validation,
        "segment_percentages": {
            seg: round(count / max(len(leads), 1) * 100, 1)
            for seg, count in segments.items()
        },
    }


def get_demo_data():
    return [
        {"name": "Alice VP", "title_match": "VP of Marketing", "company_size_fit": 200, "industry_fit": "saas", "pricing_page_visit": True, "demo_requested": True, "emails_opened_3plus": True, "converted": True},
        {"name": "Bob Manager", "title_match": "Product Manager", "company_size_fit": 500, "industry_fit": "technology", "case_study_viewed": True, "content_downloaded": True, "converted": True},
        {"name": "Carol Dev", "title_match": "Developer", "company_size_fit": 100, "industry_fit": "saas", "trial_started": True, "feature_used": True, "converted": False},
        {"name": "Dan Student", "title_match": "Student", "company_size_fit": 5, "student_email": True, "content_downloaded": True, "converted": False},
        {"name": "Eve Director", "title_match": "Director of Ops", "company_size_fit": 1000, "industry_fit": "fintech", "pricing_page_visit": True, "webinar_attended": True, "demo_requested": True, "converted": True},
        {"name": "Frank Lead", "title_match": "Team Lead", "company_size_fit": 80, "industry_fit": "retail", "emails_opened_3plus": True, "converted": False},
    ]


def format_report(analysis):
    """Format human-readable report."""
    lines = []
    lines.append("=" * 65)
    lines.append("LEAD SCORING SIMULATION")
    lines.append("=" * 65)
    lines.append(f"Total Leads: {analysis['total_leads']}")
    lines.append(f"Avg Score:   {analysis['score_stats']['average']}")
    lines.append(f"Range:       {analysis['score_stats']['min']} to {analysis['score_stats']['max']}")
    lines.append("")

    # Segment distribution
    lines.append("--- SEGMENT DISTRIBUTION ---")
    for seg in ["hot", "sql", "mql", "nurture"]:
        count = analysis["segments"].get(seg, 0)
        pct = analysis["segment_percentages"].get(seg, 0)
        bar = "#" * int(pct / 5) + "." * (20 - int(pct / 5))
        lines.append(f"  {seg.upper():<8} [{bar}] {count:>4} ({pct:.0f}%)")
    lines.append("")

    # Top leads
    lines.append("--- LEAD SCORES ---")
    lines.append(f"{'Lead':<20} {'Score':>6} {'Demo':>5} {'Behav':>5} {'Neg':>5} {'Segment':>8}")
    lines.append("-" * 55)
    for lead in analysis["leads"]:
        lines.append(
            f"{lead['lead']:<20} {lead['total_score']:>6} {lead['demographic_score']:>5} "
            f"{lead['behavioral_score']:>5} {lead['negative_score']:>5} {lead['segment']:>8}"
        )
    lines.append("")

    # Validation
    if analysis["validation"]:
        v = analysis["validation"]
        lines.append("--- MODEL VALIDATION ---")
        lines.append(f"  High-score conversion: {v['high_score_conversion_rate']:.0f}%")
        lines.append(f"  Low-score conversion:  {v['low_score_conversion_rate']:.0f}%")
        lines.append(f"  Lift:                  {v['lift']:.1f}x")
        lines.append(f"  Model effective:       {'Yes' if v['model_effective'] else 'No'}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Simulate and validate lead scoring models")
    parser.add_argument("input", nargs="?", help="JSON file with lead data")
    parser.add_argument("--model", help="Custom scoring model JSON")
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON")
    parser.add_argument("--demo", action="store_true", help="Run with demo data")
    args = parser.parse_args()

    model = None
    if args.model:
        with open(args.model, "r") as f:
            model = json.load(f)

    if args.demo:
        leads = get_demo_data()
    elif args.input:
        try:
            with open(args.input, "r", encoding="utf-8") as f:
                data = json.load(f)
            leads = data if isinstance(data, list) else data.get("leads", [])
        except FileNotFoundError:
            print(f"Error: File not found: {args.input}", file=sys.stderr)
            sys.exit(1)
    else:
        parser.print_help()
        sys.exit(1)

    analysis = simulate_scoring(leads, model)

    if args.json_output:
        print(json.dumps(analysis, indent=2))
    else:
        print(format_report(analysis))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""MarTech Stack Auditor - Audit marketing technology stack for gaps and redundancies.

Evaluates each tool on integration health, utilization, cost efficiency,
and identifies overlaps, gaps, and optimization opportunities.

Usage:
    python martech_stack_auditor.py stack.json
    python martech_stack_auditor.py stack.json --json
    python martech_stack_auditor.py --demo
"""

import argparse
import json
import sys


REQUIRED_CATEGORIES = {
    "crm": {"priority": "critical", "description": "Customer relationship management"},
    "marketing_automation": {"priority": "critical", "description": "Email workflows, lead scoring"},
    "analytics": {"priority": "critical", "description": "Traffic and behavior tracking"},
    "email": {"priority": "critical", "description": "Email sending and deliverability"},
    "ad_platforms": {"priority": "high", "description": "Paid advertising management"},
    "seo": {"priority": "high", "description": "Keyword research and tracking"},
    "social_management": {"priority": "medium", "description": "Social publishing and scheduling"},
    "content_management": {"priority": "high", "description": "Content creation and hosting"},
    "attribution": {"priority": "medium", "description": "Multi-touch attribution"},
    "abm": {"priority": "medium", "description": "Account-based marketing"},
}


def audit_stack(tools):
    """Audit a MarTech stack for gaps, redundancies, and optimization."""
    categories_covered = {}
    total_annual_cost = 0
    tool_results = []

    for tool in tools:
        name = tool.get("name", "Unknown")
        category = tool.get("category", "other")
        annual_cost = tool.get("annual_cost", 0)
        utilization = tool.get("utilization_pct", 50)  # 0-100
        integrations = tool.get("integrations", [])
        has_crm_integration = tool.get("crm_connected", False)
        owner = tool.get("owner", "unassigned")
        users = tool.get("active_users", 0)

        total_annual_cost += annual_cost

        # Score the tool
        scores = {}

        # Integration score
        integration_score = min(100, len(integrations) * 15)
        if has_crm_integration:
            integration_score = min(100, integration_score + 30)
        scores["integration"] = integration_score

        # Utilization score
        scores["utilization"] = utilization

        # Cost efficiency (cost per user per month)
        if users > 0 and annual_cost > 0:
            cost_per_user_month = annual_cost / 12 / users
            scores["cost_efficiency"] = max(0, 100 - cost_per_user_month)  # Lower cost = higher score
        else:
            scores["cost_efficiency"] = 50

        # Ownership
        scores["governance"] = 100 if owner != "unassigned" else 0

        overall = sum(scores.values()) / len(scores)

        # Issues
        issues = []
        if not has_crm_integration:
            issues.append({"severity": "high", "issue": "Not connected to CRM"})
        if utilization < 30:
            issues.append({"severity": "high", "issue": f"Low utilization ({utilization}%)"})
        elif utilization < 60:
            issues.append({"severity": "medium", "issue": f"Moderate utilization ({utilization}%)"})
        if owner == "unassigned":
            issues.append({"severity": "medium", "issue": "No assigned owner"})

        # Track categories
        if category not in categories_covered:
            categories_covered[category] = []
        categories_covered[category].append(name)

        tool_results.append({
            "name": name,
            "category": category,
            "annual_cost": annual_cost,
            "utilization": utilization,
            "crm_connected": has_crm_integration,
            "active_users": users,
            "owner": owner,
            "scores": scores,
            "overall_score": round(overall, 1),
            "issues": issues,
            "recommendation": _recommend(overall, utilization, annual_cost),
        })

    # Identify redundancies (multiple tools in same category)
    redundancies = {cat: tools_list for cat, tools_list in categories_covered.items() if len(tools_list) > 1}

    # Identify gaps (required categories not covered)
    gaps = []
    for cat, config in REQUIRED_CATEGORIES.items():
        if cat not in categories_covered:
            gaps.append({
                "category": cat,
                "priority": config["priority"],
                "description": config["description"],
            })

    # Cost optimization
    low_util_cost = sum(t["annual_cost"] for t in tool_results if t["utilization"] < 30)
    potential_savings = low_util_cost * 0.5  # Assume 50% could be saved

    # Stack health score
    coverage_score = (len(categories_covered) / len(REQUIRED_CATEGORIES)) * 100
    avg_tool_score = sum(t["overall_score"] for t in tool_results) / max(len(tool_results), 1)
    redundancy_penalty = len(redundancies) * 5
    stack_health = max(0, min(100, (coverage_score + avg_tool_score) / 2 - redundancy_penalty))

    return {
        "stack_health": round(stack_health, 1),
        "total_tools": len(tools),
        "total_annual_cost": total_annual_cost,
        "potential_savings": round(potential_savings, 2),
        "categories_covered": len(categories_covered),
        "categories_required": len(REQUIRED_CATEGORIES),
        "tools": sorted(tool_results, key=lambda x: x["overall_score"]),
        "redundancies": redundancies,
        "gaps": sorted(gaps, key=lambda x: {"critical": 0, "high": 1, "medium": 2}[x["priority"]]),
        "recommendations": _stack_recommendations(tool_results, redundancies, gaps),
    }


def _recommend(score, utilization, cost):
    if score < 40 and utilization < 30:
        return "REMOVE - Low score and utilization"
    elif score < 50:
        return "REVIEW - Consider replacement or better integration"
    elif utilization < 40:
        return "TRAIN - Increase adoption through team training"
    elif score >= 75:
        return "KEEP - Well-utilized and integrated"
    return "OPTIMIZE - Good tool, improve integration or usage"


def _stack_recommendations(tools, redundancies, gaps):
    recs = []
    if gaps:
        critical_gaps = [g for g in gaps if g["priority"] == "critical"]
        if critical_gaps:
            recs.append(f"CRITICAL: Missing {len(critical_gaps)} essential categories: {', '.join(g['category'] for g in critical_gaps)}")
    if redundancies:
        recs.append(f"REDUNDANCY: {len(redundancies)} categories have overlapping tools. Consolidate to reduce cost.")
    low_util = [t for t in tools if t["utilization"] < 30]
    if low_util:
        recs.append(f"WASTE: {len(low_util)} tools have <30% utilization. Review for removal or training.")
    disconnected = [t for t in tools if not t["crm_connected"]]
    if disconnected:
        recs.append(f"INTEGRATION: {len(disconnected)} tools not connected to CRM. Data silos likely.")
    return recs


def get_demo_data():
    return [
        {"name": "HubSpot", "category": "marketing_automation", "annual_cost": 14400, "utilization_pct": 85, "crm_connected": True, "integrations": ["salesforce", "slack", "ga4"], "owner": "Marketing Ops", "active_users": 12},
        {"name": "Google Analytics 4", "category": "analytics", "annual_cost": 0, "utilization_pct": 70, "crm_connected": False, "integrations": ["google_ads", "gtm"], "owner": "Marketing Ops", "active_users": 20},
        {"name": "Ahrefs", "category": "seo", "annual_cost": 2388, "utilization_pct": 45, "crm_connected": False, "integrations": [], "owner": "Content Lead", "active_users": 3},
        {"name": "SEMrush", "category": "seo", "annual_cost": 2400, "utilization_pct": 20, "crm_connected": False, "integrations": [], "owner": "unassigned", "active_users": 1},
        {"name": "Buffer", "category": "social_management", "annual_cost": 600, "utilization_pct": 60, "crm_connected": False, "integrations": ["twitter", "linkedin"], "owner": "Social Lead", "active_users": 3},
        {"name": "Salesforce", "category": "crm", "annual_cost": 36000, "utilization_pct": 80, "crm_connected": True, "integrations": ["hubspot", "slack", "zoom"], "owner": "Sales Ops", "active_users": 25},
    ]


def format_report(analysis):
    """Format human-readable audit report."""
    lines = []
    lines.append("=" * 70)
    lines.append("MARTECH STACK AUDIT REPORT")
    lines.append("=" * 70)
    lines.append(f"Stack Health:      {analysis['stack_health']:.0f}/100")
    lines.append(f"Total Tools:       {analysis['total_tools']}")
    lines.append(f"Annual Cost:       ${analysis['total_annual_cost']:,.0f}")
    lines.append(f"Potential Savings: ${analysis['potential_savings']:,.0f}")
    lines.append(f"Coverage:          {analysis['categories_covered']}/{analysis['categories_required']} required categories")
    lines.append("")

    # Tool breakdown
    lines.append("--- TOOL SCORES ---")
    lines.append(f"{'Tool':<20} {'Category':<22} {'Cost':>8} {'Util':>5} {'Score':>6} {'Action':>8}")
    lines.append("-" * 75)
    for t in sorted(analysis["tools"], key=lambda x: x["overall_score"]):
        lines.append(
            f"{t['name']:<20} {t['category']:<22} ${t['annual_cost']:>7,} {t['utilization']:>4}% {t['overall_score']:>5.0f} {t['recommendation'].split(' - ')[0]:>8}"
        )
    lines.append("")

    # Gaps
    if analysis["gaps"]:
        lines.append("--- GAPS ---")
        for g in analysis["gaps"]:
            lines.append(f"  [{g['priority'].upper()}] Missing: {g['category']} - {g['description']}")
        lines.append("")

    # Redundancies
    if analysis["redundancies"]:
        lines.append("--- REDUNDANCIES ---")
        for cat, tool_names in analysis["redundancies"].items():
            lines.append(f"  {cat}: {', '.join(tool_names)} (consolidate to save cost)")
        lines.append("")

    # Recommendations
    if analysis["recommendations"]:
        lines.append("--- RECOMMENDATIONS ---")
        for rec in analysis["recommendations"]:
            lines.append(f"  * {rec}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Audit MarTech stack for gaps and redundancies")
    parser.add_argument("input", nargs="?", help="JSON file with tool data")
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON")
    parser.add_argument("--demo", action="store_true", help="Run with demo data")
    args = parser.parse_args()

    if args.demo:
        tools = get_demo_data()
    elif args.input:
        try:
            with open(args.input, "r", encoding="utf-8") as f:
                data = json.load(f)
            tools = data if isinstance(data, list) else data.get("tools", data.get("stack", []))
        except FileNotFoundError:
            print(f"Error: File not found: {args.input}", file=sys.stderr)
            sys.exit(1)
    else:
        parser.print_help()
        sys.exit(1)

    analysis = audit_stack(tools)

    if args.json_output:
        print(json.dumps(analysis, indent=2))
    else:
        print(format_report(analysis))


if __name__ == "__main__":
    main()