Competitive Teardown

#!/usr/bin/env python3
"""
Battle Card Generator

Generate a one-page battle card from competitor profile data for sales
team use. Includes positioning, strengths/weaknesses, landmine questions,
objection handling, and pricing comparison.

Usage:
    python battle_card_generator.py competitor_profile.json
    python battle_card_generator.py competitor_profile.json --json
    python battle_card_generator.py competitor_profile.json --format markdown
"""

import argparse
import json
import sys
from datetime import date


def generate_battle_card(data: dict, output_format: str = "text") -> dict:
    """Generate battle card from competitor profile."""
    competitor = data.get("competitor", {})
    your_product = data.get("your_product", {})

    comp_name = competitor.get("name", "Competitor")
    your_name = your_product.get("name", "Your Product")

    # Threat assessment
    threat_score = 0
    if competitor.get("market_share_growing", False):
        threat_score += 2
    if competitor.get("recent_funding", False):
        threat_score += 1
    if competitor.get("targeting_your_icp", False):
        threat_score += 2
    if competitor.get("price_advantage", False):
        threat_score += 1
    if competitor.get("feature_parity", False):
        threat_score += 2

    if threat_score >= 6:
        threat_level = "CRITICAL"
    elif threat_score >= 4:
        threat_level = "HIGH"
    elif threat_score >= 2:
        threat_level = "MEDIUM"
    else:
        threat_level = "LOW"

    # Build battle card
    card = {
        "competitor_name": comp_name,
        "your_product_name": your_name,
        "last_updated": date.today().isoformat(),
        "threat_level": threat_level,
        "threat_score": threat_score,
        "positioning": {
            "their_positioning": competitor.get("positioning", "Not specified"),
            "your_positioning_against_them": your_product.get("positioning_vs", "Not specified"),
        },
        "where_they_win": competitor.get("strengths", [])[:5],
        "where_we_win": your_product.get("advantages", [])[:5],
        "landmine_questions": _generate_landmines(competitor),
        "objection_handling": _build_objection_handling(competitor, your_product),
        "pricing_comparison": {
            "their_pricing": competitor.get("pricing", {}),
            "your_pricing": your_product.get("pricing", {}),
        },
        "customer_quotes": your_product.get("switcher_quotes", [])[:2],
        "key_differentiators": your_product.get("differentiators", [])[:3],
    }

    return card


def _generate_landmines(competitor: dict) -> list:
    """Generate landmine questions that expose competitor weaknesses."""
    landmines = []
    weaknesses = competitor.get("weaknesses", [])

    for w in weaknesses[:5]:
        area = w.get("area", "this area")
        detail = w.get("detail", "")
        landmines.append({
            "question": f"How does {competitor.get('name', 'the competitor')} handle {area}?",
            "why_it_works": detail or f"They are weak in {area}.",
        })

    if not landmines:
        landmines.append({
            "question": "Can you show me customer case studies in my industry?",
            "why_it_works": "Tests whether they have relevant customer proof.",
        })

    return landmines


def _build_objection_handling(competitor: dict, your_product: dict) -> list:
    """Build objection handling responses."""
    objections = []
    comp_name = competitor.get("name", "They")

    if competitor.get("price_advantage", False):
        objections.append({
            "objection": f"{comp_name} is cheaper",
            "response": your_product.get("price_response",
                        "Compare total cost of ownership including implementation, training, and ongoing support. Our customers see ROI within [X] months."),
        })

    for feat in competitor.get("unique_features", [])[:3]:
        objections.append({
            "objection": f"{comp_name} has {feat.get('name', 'this feature')}",
            "response": feat.get("counter", f"We address this through {feat.get('alternative', 'our approach')}."),
        })

    if competitor.get("market_leader", False):
        objections.append({
            "objection": f"Everyone uses {comp_name}",
            "response": your_product.get("market_response",
                        "Market share does not mean best fit. Here is what makes us different for your specific use case."),
        })

    return objections


def format_text(card: dict) -> str:
    """Format battle card as text."""
    lines = []
    lines.append("=" * 60)
    lines.append(f"BATTLE CARD: {card['competitor_name']}")
    lines.append(f"Last Updated: {card['last_updated']}")
    lines.append(f"Threat Level: {card['threat_level']}")
    lines.append("=" * 60)

    pos = card["positioning"]
    lines.append(f"\nTHEIR POSITIONING: {pos['their_positioning']}")
    lines.append(f"OUR POSITIONING:   {pos['your_positioning_against_them']}")

    lines.append(f"\nWHERE THEY WIN:")
    for s in card["where_they_win"]:
        if isinstance(s, dict):
            lines.append(f"  - {s.get('point', s)}")
        else:
            lines.append(f"  - {s}")

    lines.append(f"\nWHERE WE WIN:")
    for a in card["where_we_win"]:
        if isinstance(a, dict):
            lines.append(f"  + {a.get('point', a)}")
        else:
            lines.append(f"  + {a}")

    lines.append(f"\nLANDMINE QUESTIONS:")
    for lm in card["landmine_questions"]:
        lines.append(f"  Q: \"{lm['question']}\"")
        lines.append(f"     Why: {lm['why_it_works']}")

    lines.append(f"\nOBJECTION HANDLING:")
    for obj in card["objection_handling"]:
        lines.append(f"  \"{obj['objection']}\"")
        lines.append(f"  -> {obj['response']}")

    if card["customer_quotes"]:
        lines.append(f"\nCUSTOMER QUOTES:")
        for q in card["customer_quotes"]:
            if isinstance(q, dict):
                lines.append(f"  \"{q.get('quote', '')}\" -- {q.get('attribution', '')}")
            else:
                lines.append(f"  \"{q}\"")

    lines.append("")
    return "\n".join(lines)


def format_markdown(card: dict) -> str:
    """Format battle card as markdown."""
    lines = []
    lines.append(f"# Battle Card: {card['competitor_name']}")
    lines.append(f"\n**Last Updated:** {card['last_updated']}  ")
    lines.append(f"**Threat Level:** {card['threat_level']}")

    pos = card["positioning"]
    lines.append(f"\n## Positioning")
    lines.append(f"**Their positioning:** {pos['their_positioning']}  ")
    lines.append(f"**Our positioning:** {pos['your_positioning_against_them']}")

    lines.append(f"\n## Where They Win")
    for s in card["where_they_win"]:
        text = s.get("point", s) if isinstance(s, dict) else s
        lines.append(f"- {text}")

    lines.append(f"\n## Where We Win")
    for a in card["where_we_win"]:
        text = a.get("point", a) if isinstance(a, dict) else a
        lines.append(f"- {text}")

    lines.append(f"\n## Landmine Questions")
    for lm in card["landmine_questions"]:
        lines.append(f"- **\"{lm['question']}\"** -- {lm['why_it_works']}")

    lines.append(f"\n## Objection Handling")
    for obj in card["objection_handling"]:
        lines.append(f"- **\"{obj['objection']}\"** -> {obj['response']}")

    if card["customer_quotes"]:
        lines.append(f"\n## Customer Quotes")
        for q in card["customer_quotes"]:
            if isinstance(q, dict):
                lines.append(f"> \"{q.get('quote', '')}\" -- {q.get('attribution', '')}")
            else:
                lines.append(f"> \"{q}\"")

    lines.append("")
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(
        description="Generate a one-page battle card from competitor profile data."
    )
    parser.add_argument("input_file", help="JSON file with competitor profile data")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument("--format", choices=["text", "markdown"], default="text",
                        help="Output format (default: text)")

    args = parser.parse_args()

    try:
        with open(args.input_file, "r") as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: File not found: {args.input_file}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON in {args.input_file}: {e}", file=sys.stderr)
        sys.exit(1)

    card = generate_battle_card(data, args.format)

    if args.json:
        print(json.dumps(card, indent=2))
    elif args.format == "markdown":
        print(format_markdown(card))
    else:
        print(format_text(card))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Competitor Scorer

Score competitors across a 12-dimension rubric and generate a numeric
comparison scorecard with gap analysis and strategic recommendations.

Usage:
    python competitor_scorer.py competitor_data.json
    python competitor_scorer.py competitor_data.json --json
"""

import argparse
import json
import sys


DIMENSIONS = [
    "features", "pricing", "ux_design", "performance", "documentation",
    "support", "integrations", "security", "scalability", "brand",
    "community", "innovation",
]

DIMENSION_LABELS = {
    "features": "Features",
    "pricing": "Pricing",
    "ux_design": "UX / Design",
    "performance": "Performance",
    "documentation": "Documentation",
    "support": "Support",
    "integrations": "Integrations",
    "security": "Security",
    "scalability": "Scalability",
    "brand": "Brand",
    "community": "Community",
    "innovation": "Innovation",
}


def score_competitors(data: dict, custom_weights: dict = None) -> dict:
    """Score competitors across 12 dimensions."""
    competitors = data.get("competitors", [])
    if not competitors:
        return {"error": "No competitor data provided."}

    weights = custom_weights or {d: 1.0 / len(DIMENSIONS) for d in DIMENSIONS}
    total_weight = sum(weights.values())
    weights = {k: v / total_weight for k, v in weights.items()}

    scorecards = []
    for comp in competitors:
        name = comp.get("name", "Unknown")
        scores = comp.get("scores", {})
        evidence = comp.get("evidence", {})

        dimension_scores = []
        raw_total = 0
        weighted_total = 0.0

        for dim in DIMENSIONS:
            score = scores.get(dim, 0)
            score = max(0, min(5, score))
            weight = weights.get(dim, 1.0 / len(DIMENSIONS))
            weighted = score * weight * len(DIMENSIONS)

            dimension_scores.append({
                "dimension": dim,
                "label": DIMENSION_LABELS.get(dim, dim),
                "score": score,
                "weight": round(weight, 4),
                "weighted_score": round(weighted, 2),
                "evidence": evidence.get(dim, ""),
            })
            raw_total += score
            weighted_total += weighted

        scorecards.append({
            "name": name,
            "raw_total": raw_total,
            "max_possible": len(DIMENSIONS) * 5,
            "weighted_total": round(weighted_total, 2),
            "percentage": round((raw_total / (len(DIMENSIONS) * 5)) * 100, 1),
            "dimensions": dimension_scores,
        })

    scorecards.sort(key=lambda x: x["weighted_total"], reverse=True)

    # Gap analysis (compare first two)
    gaps = []
    if len(scorecards) >= 2:
        leader = scorecards[0]
        for other in scorecards[1:]:
            comp_gaps = []
            for i, dim in enumerate(DIMENSIONS):
                leader_score = leader["dimensions"][i]["score"]
                other_score = other["dimensions"][i]["score"]
                diff = leader_score - other_score
                if abs(diff) >= 1:
                    comp_gaps.append({
                        "dimension": DIMENSION_LABELS.get(dim, dim),
                        "leader_score": leader_score,
                        "other_score": other_score,
                        "gap": diff,
                        "direction": "leader ahead" if diff > 0 else "other ahead",
                    })
            gaps.append({
                "comparison": f"{leader['name']} vs {other['name']}",
                "gaps": sorted(comp_gaps, key=lambda x: abs(x["gap"]), reverse=True),
            })

    # Strategic recommendations
    recommendations = _generate_recommendations(scorecards)

    return {
        "scorecards": scorecards,
        "ranking": [{"rank": i + 1, "name": s["name"], "score": s["raw_total"],
                      "percentage": s["percentage"]} for i, s in enumerate(scorecards)],
        "gap_analysis": gaps,
        "recommendations": recommendations,
    }


def _generate_recommendations(scorecards: list) -> list:
    """Generate strategic recommendations from scorecard analysis."""
    recs = []
    if not scorecards:
        return recs

    # Find dimensions where your product (first entry typically) scores lowest
    if scorecards:
        first = scorecards[0]
        weak_dims = sorted(first["dimensions"], key=lambda x: x["score"])[:3]
        for dim in weak_dims:
            if dim["score"] <= 2:
                recs.append({
                    "priority": "HIGH",
                    "dimension": dim["label"],
                    "recommendation": f"{first['name']} scores {dim['score']}/5 on {dim['label']}. This is a significant gap that competitors can exploit.",
                })

        strong_dims = sorted(first["dimensions"], key=lambda x: x["score"], reverse=True)[:3]
        for dim in strong_dims:
            if dim["score"] >= 4:
                recs.append({
                    "priority": "LEVERAGE",
                    "dimension": dim["label"],
                    "recommendation": f"{first['name']} leads on {dim['label']} ({dim['score']}/5). Feature this in positioning and battle cards.",
                })

    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 70)
    lines.append("COMPETITOR SCORECARD -- 12-Dimension Analysis")
    lines.append("=" * 70)

    lines.append(f"\n--- Ranking ---")
    for r in result["ranking"]:
        bar = "#" * int(r["percentage"] / 5)
        lines.append(f"  {r['rank']}. {r['name']:<25} {r['score']:>3}/60  ({r['percentage']:>5.1f}%)  {bar}")

    for sc in result["scorecards"]:
        lines.append(f"\n--- {sc['name']} ---")
        lines.append(f"{'Dimension':<16} {'Score':>6} {'Evidence'}")
        for d in sc["dimensions"]:
            ev = d["evidence"][:50] + "..." if len(d["evidence"]) > 50 else d["evidence"]
            lines.append(f"{d['label']:<16} {d['score']:>4}/5  {ev}")
        lines.append(f"{'TOTAL':<16} {sc['raw_total']:>4}/60 ({sc['percentage']:.1f}%)")

    if result["gap_analysis"]:
        lines.append(f"\n--- Gap Analysis ---")
        for ga in result["gap_analysis"]:
            lines.append(f"\n  {ga['comparison']}:")
            for g in ga["gaps"][:5]:
                lines.append(f"    {g['dimension']:<16} {g['leader_score']} vs {g['other_score']} (gap: {g['gap']:+d})")

    if result["recommendations"]:
        lines.append(f"\n--- Recommendations ---")
        for r in result["recommendations"]:
            lines.append(f"[{r['priority']}] {r['dimension']}: {r['recommendation']}")

    lines.append("")
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(
        description="Score competitors across a 12-dimension rubric and generate comparison scorecard."
    )
    parser.add_argument("input_file", help="JSON file with competitor dimension scores")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument("--weights", type=str, default=None,
                        help="Custom dimension weights as JSON string")

    args = parser.parse_args()

    try:
        with open(args.input_file, "r") as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: File not found: {args.input_file}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON in {args.input_file}: {e}", file=sys.stderr)
        sys.exit(1)

    custom_weights = None
    if args.weights:
        try:
            custom_weights = json.loads(args.weights)
        except json.JSONDecodeError:
            print("Error: Invalid JSON in --weights argument.", file=sys.stderr)
            sys.exit(1)

    result = score_competitors(data, custom_weights)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Feature Matrix Builder

Build a feature comparison matrix from structured feature data. Calculates
per-category and overall coverage scores for each competitor.

Usage:
    python feature_matrix_builder.py features.json
    python feature_matrix_builder.py features.json --json
"""

import argparse
import json
import sys


COVERAGE_SCORES = {
    "full": 5,
    "partial": 3,
    "basic": 2,
    "planned": 1,
    "missing": 0,
}


def build_matrix(data: dict) -> dict:
    """Build feature comparison matrix."""
    products = data.get("products", [])
    categories = data.get("categories", [])

    if not products or not categories:
        return {"error": "Products and categories are required."}

    product_names = [p.get("name", f"Product {i+1}") for i, p in enumerate(products)]

    # Build matrix
    matrix_rows = []
    category_scores = {name: {} for name in product_names}
    overall_scores = {name: {"total": 0, "max": 0} for name in product_names}

    for cat in categories:
        cat_name = cat.get("name", "Unknown")
        features = cat.get("features", [])
        cat_rows = []

        for feat in features:
            feat_name = feat.get("name", "Unknown")
            row = {"feature": feat_name, "category": cat_name, "scores": {}, "notes": feat.get("notes", "")}

            for i, product in enumerate(products):
                name = product_names[i]
                product_features = product.get("features", {})
                cat_features = product_features.get(cat_name, {})
                coverage = cat_features.get(feat_name, "missing").lower()
                score = COVERAGE_SCORES.get(coverage, 0)

                row["scores"][name] = {
                    "coverage": coverage,
                    "score": score,
                }
                overall_scores[name]["total"] += score
                overall_scores[name]["max"] += 5

            cat_rows.append(row)
        matrix_rows.append({"category": cat_name, "features": cat_rows})

        # Calculate category scores
        for name in product_names:
            cat_total = sum(r["scores"][name]["score"] for r in cat_rows)
            cat_max = len(cat_rows) * 5
            pct = (cat_total / cat_max * 100) if cat_max > 0 else 0
            category_scores[name][cat_name] = {
                "score": cat_total,
                "max": cat_max,
                "percentage": round(pct, 1),
            }

    # Overall coverage
    overall_coverage = {}
    for name in product_names:
        total = overall_scores[name]["total"]
        max_score = overall_scores[name]["max"]
        pct = (total / max_score * 100) if max_score > 0 else 0
        overall_coverage[name] = {
            "total_score": total,
            "max_score": max_score,
            "coverage_pct": round(pct, 1),
        }

    # Differentiators (features where only one product has "full")
    differentiators = {name: [] for name in product_names}
    gaps = {name: [] for name in product_names}

    for cat_data in matrix_rows:
        for feat in cat_data["features"]:
            full_products = [n for n in product_names if feat["scores"][n]["coverage"] == "full"]
            missing_products = [n for n in product_names if feat["scores"][n]["coverage"] == "missing"]

            if len(full_products) == 1:
                differentiators[full_products[0]].append(
                    f"{feat['category']}: {feat['feature']}"
                )
            for name in missing_products:
                if any(feat["scores"][n]["coverage"] in ("full", "partial") for n in product_names if n != name):
                    gaps[name].append(f"{feat['category']}: {feat['feature']}")

    return {
        "products": product_names,
        "matrix": matrix_rows,
        "category_scores": category_scores,
        "overall_coverage": overall_coverage,
        "differentiators": differentiators,
        "gaps": {k: v[:10] for k, v in gaps.items()},
    }


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 70)
    lines.append("FEATURE COMPARISON MATRIX")
    lines.append("=" * 70)

    names = result["products"]

    # Overall coverage
    lines.append(f"\n--- Overall Coverage ---")
    for name in names:
        ov = result["overall_coverage"][name]
        bar = "#" * int(ov["coverage_pct"] / 5)
        lines.append(f"  {name:<25} {ov['total_score']:>3}/{ov['max_score']}  ({ov['coverage_pct']:>5.1f}%)  {bar}")

    # Category scores
    lines.append(f"\n--- Category Scores ---")
    header = f"{'Category':<20}"
    for name in names:
        header += f" {name[:15]:>15}"
    lines.append(header)

    if result["matrix"]:
        for cat_data in result["matrix"]:
            cat = cat_data["category"]
            row = f"{cat:<20}"
            for name in names:
                cs = result["category_scores"][name].get(cat, {})
                row += f" {cs.get('percentage', 0):>13.1f}%"
            lines.append(row)

    # Feature matrix
    for cat_data in result["matrix"]:
        lines.append(f"\n--- {cat_data['category']} ---")
        header = f"  {'Feature':<25}"
        for name in names:
            header += f" {name[:12]:>12}"
        lines.append(header)

        for feat in cat_data["features"]:
            row = f"  {feat['feature']:<25}"
            for name in names:
                coverage = feat["scores"][name]["coverage"]
                row += f" {coverage:>12}"
            lines.append(row)

    # Differentiators
    lines.append(f"\n--- Unique Differentiators ---")
    for name in names:
        diffs = result["differentiators"][name]
        if diffs:
            lines.append(f"  {name}:")
            for d in diffs[:5]:
                lines.append(f"    + {d}")

    # Gaps
    lines.append(f"\n--- Key Gaps ---")
    for name in names:
        g = result["gaps"][name]
        if g:
            lines.append(f"  {name}:")
            for gap in g[:5]:
                lines.append(f"    - {gap}")

    lines.append("")
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(
        description="Build a feature comparison matrix from structured feature data."
    )
    parser.add_argument("input_file", help="JSON file with feature comparison data")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")

    args = parser.parse_args()

    try:
        with open(args.input_file, "r") as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: File not found: {args.input_file}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON in {args.input_file}: {e}", file=sys.stderr)
        sys.exit(1)

    result = build_matrix(data)

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


if __name__ == "__main__":
    main()