Marketing Context

#!/usr/bin/env python3
"""Competitive Landscape Mapper - Map and analyze competitive positioning.

Analyzes competitors across positioning, messaging, features, and pricing
to identify gaps and opportunities.

Usage:
    python competitive_landscape_mapper.py competitors.json
    python competitive_landscape_mapper.py competitors.json --json
    python competitive_landscape_mapper.py --demo
"""

import argparse
import json
import sys


def analyze_landscape(data):
    """Analyze competitive landscape from competitor data."""
    our_product = data.get("our_product", {})
    competitors = data.get("competitors", [])
    all_players = [our_product] + competitors if our_product else competitors

    # Feature comparison
    all_features = set()
    for player in all_players:
        all_features.update(player.get("features", []))

    feature_matrix = {}
    for feature in sorted(all_features):
        feature_matrix[feature] = {}
        for player in all_players:
            name = player.get("name", "Unknown")
            feature_matrix[feature][name] = feature in player.get("features", [])

    # Unique features per player
    unique_features = {}
    for player in all_players:
        name = player.get("name", "Unknown")
        player_features = set(player.get("features", []))
        other_features = set()
        for other in all_players:
            if other.get("name") != name:
                other_features.update(other.get("features", []))
        unique = player_features - other_features
        unique_features[name] = list(unique)

    # Feature coverage
    our_features = set(our_product.get("features", [])) if our_product else set()
    feature_gaps = []
    for comp in competitors:
        comp_features = set(comp.get("features", []))
        gaps = comp_features - our_features
        if gaps:
            feature_gaps.append({
                "competitor": comp.get("name", "Unknown"),
                "features_they_have": list(gaps),
                "count": len(gaps),
            })

    # Pricing analysis
    pricing = []
    for player in all_players:
        price = player.get("starting_price")
        if price is not None:
            pricing.append({
                "name": player.get("name", "Unknown"),
                "starting_price": price,
                "pricing_model": player.get("pricing_model", "unknown"),
            })
    pricing.sort(key=lambda x: x["starting_price"])

    # Positioning analysis
    positioning = []
    all_categories = set()
    all_audiences = set()
    for player in all_players:
        cat = player.get("category", "unknown")
        audience = player.get("target_audience", "unknown")
        all_categories.add(cat)
        all_audiences.add(audience)
        positioning.append({
            "name": player.get("name", "Unknown"),
            "category": cat,
            "target_audience": audience,
            "key_differentiator": player.get("key_differentiator", ""),
            "tagline": player.get("tagline", ""),
        })

    # Competitive tiers
    tiers = {"direct": [], "adjacent": [], "status_quo": []}
    for comp in competitors:
        tier = comp.get("tier", "direct")
        tiers[tier].append(comp.get("name", "Unknown"))

    # SWOT per competitor
    competitor_analysis = []
    for comp in competitors:
        strengths = comp.get("strengths", [])
        weaknesses = comp.get("weaknesses", [])
        competitor_analysis.append({
            "name": comp.get("name", "Unknown"),
            "tier": comp.get("tier", "direct"),
            "strengths": strengths,
            "weaknesses": weaknesses,
            "feature_count": len(comp.get("features", [])),
            "unique_features": unique_features.get(comp.get("name"), []),
        })

    # Opportunity gaps
    opportunities = []
    if len(all_categories) > 1:
        opportunities.append("Category positioning is fragmented - opportunity to own a specific category.")
    if feature_gaps:
        top_gaps = sorted(feature_gaps, key=lambda x: x["count"], reverse=True)
        for gap in top_gaps[:3]:
            opportunities.append(f"{gap['competitor']} has {gap['count']} features we lack: {', '.join(gap['features_they_have'][:3])}")
    our_unique = unique_features.get(our_product.get("name", ""), [])
    if our_unique:
        opportunities.append(f"We uniquely offer: {', '.join(our_unique[:5])}. Emphasize in positioning.")

    return {
        "summary": {
            "total_competitors": len(competitors),
            "total_features_in_market": len(all_features),
            "our_feature_count": len(our_features),
            "categories_in_market": list(all_categories),
            "audiences_targeted": list(all_audiences),
        },
        "tiers": tiers,
        "positioning": positioning,
        "pricing": pricing,
        "feature_gaps": sorted(feature_gaps, key=lambda x: x["count"], reverse=True),
        "unique_features": unique_features,
        "competitor_analysis": competitor_analysis,
        "opportunities": opportunities,
    }


def get_demo_data():
    return {
        "our_product": {
            "name": "OurProduct",
            "category": "analytics platform",
            "target_audience": "product managers",
            "features": ["funnel analysis", "cohort analysis", "real-time dashboard", "custom events", "api access", "slack integration"],
            "starting_price": 99,
            "pricing_model": "per_seat",
            "key_differentiator": "No-code analytics for PMs",
            "tagline": "Analytics without engineering",
        },
        "competitors": [
            {"name": "Amplitude", "tier": "direct", "category": "product analytics", "target_audience": "product teams", "features": ["funnel analysis", "cohort analysis", "behavioral analytics", "experimentation", "cdp"], "starting_price": 0, "pricing_model": "usage", "strengths": ["market leader", "deep analytics"], "weaknesses": ["complex setup", "expensive at scale"]},
            {"name": "Mixpanel", "tier": "direct", "category": "product analytics", "target_audience": "product teams", "features": ["funnel analysis", "cohort analysis", "a/b testing", "messaging"], "starting_price": 0, "pricing_model": "usage", "strengths": ["easy to use", "good free tier"], "weaknesses": ["limited enterprise features", "data governance"]},
            {"name": "Spreadsheets", "tier": "status_quo", "category": "manual analysis", "target_audience": "everyone", "features": ["custom formulas", "charts"], "starting_price": 0, "pricing_model": "free", "strengths": ["familiar", "flexible"], "weaknesses": ["manual", "error-prone", "not real-time"]},
        ],
    }


def format_report(analysis):
    """Format human-readable report."""
    lines = []
    lines.append("=" * 65)
    lines.append("COMPETITIVE LANDSCAPE MAP")
    lines.append("=" * 65)

    s = analysis["summary"]
    lines.append(f"Competitors:        {s['total_competitors']}")
    lines.append(f"Features in market: {s['total_features_in_market']}")
    lines.append(f"Our features:       {s['our_feature_count']}")
    lines.append("")

    # Tiers
    lines.append("--- COMPETITIVE TIERS ---")
    for tier, names in analysis["tiers"].items():
        if names:
            lines.append(f"  {tier.title()}: {', '.join(names)}")
    lines.append("")

    # Positioning
    lines.append("--- POSITIONING ---")
    for p in analysis["positioning"]:
        lines.append(f"  {p['name']}: {p['category']} for {p['target_audience']}")
        if p.get("key_differentiator"):
            lines.append(f"    Differentiator: {p['key_differentiator']}")
    lines.append("")

    # Pricing
    if analysis["pricing"]:
        lines.append("--- PRICING ---")
        for p in analysis["pricing"]:
            lines.append(f"  {p['name']}: ${p['starting_price']}/mo ({p['pricing_model']})")
        lines.append("")

    # Feature gaps
    if analysis["feature_gaps"]:
        lines.append("--- FEATURE GAPS ---")
        for gap in analysis["feature_gaps"][:5]:
            lines.append(f"  {gap['competitor']} has: {', '.join(gap['features_they_have'][:5])}")
        lines.append("")

    # Opportunities
    if analysis["opportunities"]:
        lines.append("--- OPPORTUNITIES ---")
        for opp in analysis["opportunities"]:
            lines.append(f"  * {opp}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Map and analyze competitive positioning")
    parser.add_argument("input", nargs="?", help="JSON file with competitive 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:
        data = get_demo_data()
    elif args.input:
        try:
            with open(args.input, "r", encoding="utf-8") as f:
                data = json.load(f)
        except FileNotFoundError:
            print(f"Error: File not found: {args.input}", file=sys.stderr)
            sys.exit(1)
    else:
        parser.print_help()
        sys.exit(1)

    analysis = analyze_landscape(data)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Context Completeness Checker - Audit marketing context document for gaps.

Checks a marketing context document for completeness across all required
sections, flags missing or thin sections, and scores overall readiness.

Usage:
    python context_completeness_checker.py context.md
    python context_completeness_checker.py context.json --json
"""

import argparse
import json
import re
import sys


REQUIRED_SECTIONS = {
    "product_overview": {
        "weight": 10,
        "required_fields": ["description", "category", "product_type", "business_model", "pricing"],
        "min_words": 50,
    },
    "target_audience": {
        "weight": 10,
        "required_fields": ["company_type", "decision_makers", "primary_use_case", "jobs_to_be_done"],
        "min_words": 75,
    },
    "buyer_personas": {
        "weight": 8,
        "required_fields": ["title", "role_in_purchase", "what_they_care_about", "language_they_use"],
        "min_words": 100,
    },
    "problems_pain_points": {
        "weight": 9,
        "required_fields": ["core_challenge", "why_current_solutions_fail", "cost_of_problem"],
        "min_words": 75,
    },
    "competitive_landscape": {
        "weight": 8,
        "required_fields": ["direct_competitors", "secondary_competitors"],
        "min_words": 75,
    },
    "differentiation": {
        "weight": 9,
        "required_fields": ["key_differentiators", "how_we_solve_differently", "why_customers_choose_us"],
        "min_words": 50,
    },
    "objections": {
        "weight": 7,
        "required_fields": ["objection", "response"],
        "min_words": 50,
    },
    "customer_language": {
        "weight": 8,
        "required_fields": ["how_they_describe_problem", "how_they_describe_solution"],
        "min_words": 50,
    },
    "brand_voice": {
        "weight": 7,
        "required_fields": ["tone", "communication_style", "personality"],
        "min_words": 40,
    },
    "proof_points": {
        "weight": 7,
        "required_fields": ["key_metrics", "testimonials"],
        "min_words": 40,
    },
    "content_seo_context": {
        "weight": 5,
        "required_fields": ["target_keywords"],
        "min_words": 30,
    },
    "goals": {
        "weight": 5,
        "required_fields": ["primary_goal", "key_conversion_action"],
        "min_words": 30,
    },
}

# Patterns to detect sections in markdown
SECTION_PATTERNS = {
    "product_overview": [r"product\s+overview", r"what\s+(it|we)\s+(is|do|are)"],
    "target_audience": [r"target\s+audience", r"ideal\s+customer", r"icp"],
    "buyer_personas": [r"persona", r"buyer\s+profile"],
    "problems_pain_points": [r"problems?", r"pain\s+points?", r"challenges?"],
    "competitive_landscape": [r"competitive?\s+landscape", r"competitors?"],
    "differentiation": [r"differenti", r"unique\s+(value|approach)"],
    "objections": [r"objections?", r"anti.?persona"],
    "customer_language": [r"customer\s+language", r"verbatim"],
    "brand_voice": [r"brand\s+voice", r"tone\s+(and|&)\s+voice"],
    "proof_points": [r"proof\s+points?", r"testimonial", r"social\s+proof"],
    "content_seo_context": [r"content\s+(&|and)\s+seo", r"keywords?"],
    "goals": [r"goals?", r"objectives?", r"kpis?"],
}


def check_markdown(filepath):
    """Check a markdown context document for completeness."""
    with open(filepath, "r", encoding="utf-8") as f:
        content = f.read()

    sections_found = {}
    content_lower = content.lower()

    for section, patterns in SECTION_PATTERNS.items():
        found = False
        section_content = ""
        for pattern in patterns:
            match = re.search(pattern, content_lower)
            if match:
                found = True
                # Extract content after the heading until next heading
                pos = match.start()
                next_heading = re.search(r"\n#{1,3}\s", content[pos + 10:])
                if next_heading:
                    section_content = content[pos:pos + 10 + next_heading.start()]
                else:
                    section_content = content[pos:]
                break

        word_count = len(section_content.split()) if section_content else 0
        min_words = REQUIRED_SECTIONS[section]["min_words"]

        sections_found[section] = {
            "found": found,
            "word_count": word_count,
            "meets_minimum": word_count >= min_words,
            "min_words": min_words,
        }

    return _compile_results(sections_found)


def check_json(filepath):
    """Check a JSON context document for completeness."""
    with open(filepath, "r", encoding="utf-8") as f:
        data = json.load(f)

    sections_found = {}
    data_lower = {k.lower().replace(" ", "_"): v for k, v in data.items()}

    for section, config in REQUIRED_SECTIONS.items():
        # Check if section key exists
        section_data = data_lower.get(section, data_lower.get(section.replace("_", ""), None))
        found = section_data is not None

        if found and isinstance(section_data, dict):
            word_count = sum(len(str(v).split()) for v in section_data.values())
        elif found and isinstance(section_data, str):
            word_count = len(section_data.split())
        elif found and isinstance(section_data, list):
            word_count = sum(len(str(item).split()) for item in section_data)
        else:
            word_count = 0

        min_words = config["min_words"]
        sections_found[section] = {
            "found": found,
            "word_count": word_count,
            "meets_minimum": word_count >= min_words,
            "min_words": min_words,
        }

    return _compile_results(sections_found)


def _compile_results(sections_found):
    """Compile analysis results from section findings."""
    total_weight = sum(REQUIRED_SECTIONS[s]["weight"] for s in REQUIRED_SECTIONS)
    earned_weight = 0
    missing = []
    thin = []
    complete = []

    for section, result in sections_found.items():
        weight = REQUIRED_SECTIONS[section]["weight"]
        if not result["found"]:
            missing.append({"section": section, "weight": weight})
        elif not result["meets_minimum"]:
            earned_weight += weight * 0.5
            thin.append({
                "section": section,
                "word_count": result["word_count"],
                "min_words": result["min_words"],
                "weight": weight,
            })
        else:
            earned_weight += weight
            complete.append({"section": section, "weight": weight})

    score = (earned_weight / max(total_weight, 1)) * 100

    # Readiness assessment
    if score >= 80 and not missing:
        readiness = "READY"
        message = "Context is comprehensive. Ready for marketing execution."
    elif score >= 60:
        readiness = "MOSTLY READY"
        message = "Core context exists. Fill gaps before major campaigns."
    elif score >= 40:
        readiness = "PARTIAL"
        message = "Significant gaps remain. Complete critical sections first."
    else:
        readiness = "NOT READY"
        message = "Major sections missing. Build context before marketing work."

    # Priority order for missing sections (by weight)
    priority_order = sorted(missing + thin, key=lambda x: x["weight"], reverse=True)

    return {
        "score": round(score, 1),
        "readiness": readiness,
        "message": message,
        "sections": sections_found,
        "complete": complete,
        "thin": thin,
        "missing": missing,
        "priority_to_fill": [p["section"] for p in priority_order],
        "stats": {
            "total_sections": len(REQUIRED_SECTIONS),
            "complete": len(complete),
            "thin": len(thin),
            "missing": len(missing),
        },
    }


def format_report(analysis):
    """Format human-readable report."""
    lines = []
    lines.append("=" * 60)
    lines.append("MARKETING CONTEXT COMPLETENESS CHECK")
    lines.append("=" * 60)
    lines.append(f"Score:       {analysis['score']:.0f}/100")
    lines.append(f"Readiness:   {analysis['readiness']}")
    lines.append(f"Assessment:  {analysis['message']}")
    lines.append(f"Sections:    {analysis['stats']['complete']}/{analysis['stats']['total_sections']} complete, "
                 f"{analysis['stats']['thin']} thin, {analysis['stats']['missing']} missing")
    lines.append("")

    # Section status
    lines.append("--- SECTION STATUS ---")
    for section, data in analysis["sections"].items():
        label = section.replace("_", " ").title()
        if not data["found"]:
            lines.append(f"  [MISSING]  {label}")
        elif not data["meets_minimum"]:
            lines.append(f"  [THIN]     {label} ({data['word_count']}/{data['min_words']} words)")
        else:
            lines.append(f"  [OK]       {label} ({data['word_count']} words)")
    lines.append("")

    # Priority
    if analysis["priority_to_fill"]:
        lines.append("--- FILL PRIORITY ---")
        for i, section in enumerate(analysis["priority_to_fill"], 1):
            lines.append(f"  {i}. {section.replace('_', ' ').title()}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Audit marketing context document for gaps")
    parser.add_argument("input", help="Markdown (.md) or JSON (.json) context file")
    parser.add_argument("--json", action="store_true", dest="json_output", help="Output JSON")
    args = parser.parse_args()

    try:
        if args.input.endswith(".json"):
            analysis = check_json(args.input)
        else:
            analysis = check_markdown(args.input)
    except FileNotFoundError:
        print(f"Error: File not found: {args.input}", file=sys.stderr)
        sys.exit(1)

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

    sys.exit(0 if analysis["readiness"] in ("READY", "MOSTLY READY") else 1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""ICP Fit Scorer - Score prospects against Ideal Customer Profile criteria.

Evaluates prospects on firmographic, technographic, and behavioral signals
to produce an A/B/C/D fit score.

Usage:
    python icp_fit_scorer.py prospects.json --icp icp_config.json
    python icp_fit_scorer.py prospects.json --json
    python icp_fit_scorer.py --demo
"""

import argparse
import json
import sys


DEFAULT_ICP = {
    "firmographics": {
        "employees": {"min": 50, "max": 5000, "weight": 20},
        "revenue": {"min": 5000000, "max": 500000000, "weight": 15},
        "industry": {"values": ["saas", "technology", "fintech", "services"], "weight": 20},
        "geography": {"values": ["us", "uk", "dach", "canada"], "weight": 10},
    },
    "technographics": {
        "tech_stack": {"values": ["salesforce", "hubspot", "slack", "jira"], "weight": 10},
        "maturity": {"values": ["growth", "scale"], "weight": 5},
    },
    "behavioral": {
        "funding_stage": {"values": ["series_a", "series_b", "series_c", "growth"], "weight": 10},
        "pain_level": {"min": 3, "max": 5, "weight": 10},
    },
}

GRADE_THRESHOLDS = {
    "A": 80,
    "B": 60,
    "C": 40,
    "D": 0,
}


def score_prospect(prospect, icp_config=None):
    """Score a single prospect against ICP criteria."""
    if icp_config is None:
        icp_config = DEFAULT_ICP

    total_score = 0
    total_weight = 0
    criteria_results = []

    for category, criteria in icp_config.items():
        for criterion, config in criteria.items():
            weight = config.get("weight", 10)
            total_weight += weight
            prospect_value = prospect.get(criterion)

            if prospect_value is None:
                criteria_results.append({
                    "criterion": criterion,
                    "category": category,
                    "status": "missing",
                    "score": 0,
                    "weight": weight,
                })
                continue

            score = 0
            status = "no_match"

            if "min" in config and "max" in config:
                # Range check
                val = float(prospect_value) if not isinstance(prospect_value, (int, float)) else prospect_value
                if config["min"] <= val <= config["max"]:
                    # Score based on position in range (center = best)
                    mid = (config["min"] + config["max"]) / 2
                    range_size = config["max"] - config["min"]
                    distance = abs(val - mid) / (range_size / 2)
                    score = max(0, (1 - distance * 0.3)) * weight
                    status = "match"
                elif val < config["min"]:
                    # Below range: partial credit
                    ratio = val / config["min"]
                    score = max(0, ratio * 0.5) * weight
                    status = "partial_below"
                else:
                    # Above range: partial credit
                    ratio = config["max"] / val
                    score = max(0, ratio * 0.5) * weight
                    status = "partial_above"

            elif "values" in config:
                # List match
                if isinstance(prospect_value, list):
                    matches = len(set(v.lower() for v in prospect_value) & set(v.lower() for v in config["values"]))
                    total_possible = len(config["values"])
                    score = (matches / max(total_possible, 1)) * weight
                    status = "match" if matches > 0 else "no_match"
                else:
                    val_lower = str(prospect_value).lower()
                    if val_lower in [v.lower() for v in config["values"]]:
                        score = weight
                        status = "match"

            total_score += score
            criteria_results.append({
                "criterion": criterion,
                "category": category,
                "value": prospect_value,
                "score": round(score, 1),
                "max_score": weight,
                "status": status,
            })

    # Calculate percentage and grade
    percentage = (total_score / max(total_weight, 1)) * 100
    grade = "D"
    for g, threshold in sorted(GRADE_THRESHOLDS.items()):
        if percentage >= threshold:
            grade = g

    return {
        "prospect": prospect.get("name", prospect.get("company", "Unknown")),
        "score": round(total_score, 1),
        "max_score": total_weight,
        "percentage": round(percentage, 1),
        "grade": grade,
        "criteria": criteria_results,
        "matched": len([c for c in criteria_results if c["status"] == "match"]),
        "missing": len([c for c in criteria_results if c["status"] == "missing"]),
    }


def get_demo_data():
    return {
        "prospects": [
            {"name": "TechStart Inc", "employees": 120, "revenue": 15000000, "industry": "saas", "geography": "us", "tech_stack": ["salesforce", "slack"], "funding_stage": "series_a", "pain_level": 4},
            {"name": "BigCorp Ltd", "employees": 8000, "revenue": 800000000, "industry": "manufacturing", "geography": "uk", "tech_stack": ["sap"], "funding_stage": "public", "pain_level": 2},
            {"name": "GrowthCo", "employees": 250, "revenue": 30000000, "industry": "fintech", "geography": "us", "tech_stack": ["hubspot", "jira", "slack"], "funding_stage": "series_b", "pain_level": 5},
            {"name": "SmallBiz", "employees": 15, "revenue": 500000, "industry": "retail", "geography": "canada", "tech_stack": [], "funding_stage": "seed", "pain_level": 3},
        ],
    }


def format_report(results):
    """Format human-readable report."""
    lines = []
    lines.append("=" * 65)
    lines.append("ICP FIT SCORING REPORT")
    lines.append("=" * 65)

    # Summary table
    lines.append(f"{'Prospect':<25} {'Score':>8} {'Grade':>6} {'Matched':>8}")
    lines.append("-" * 50)

    for r in sorted(results, key=lambda x: x["percentage"], reverse=True):
        lines.append(f"{r['prospect']:<25} {r['percentage']:>7.0f}% {r['grade']:>6} {r['matched']:>5}/{r['matched'] + r['missing']}")

    lines.append("")

    # Detailed per prospect
    for r in sorted(results, key=lambda x: x["percentage"], reverse=True):
        lines.append(f"--- {r['prospect']} (Grade: {r['grade']}, {r['percentage']:.0f}%) ---")
        for c in r["criteria"]:
            status_icon = {"match": "+", "partial_below": "~", "partial_above": "~", "no_match": "-", "missing": "?"}
            icon = status_icon.get(c["status"], "?")
            val = c.get("value", "N/A")
            lines.append(f"  [{icon}] {c['criterion']:<20} {str(val):<20} ({c['score']:.0f}/{c['max_score']})")
        lines.append("")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Score prospects against ICP criteria")
    parser.add_argument("input", nargs="?", help="JSON file with prospect data")
    parser.add_argument("--icp", help="Custom ICP config JSON file")
    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()

    icp_config = DEFAULT_ICP
    if args.icp:
        with open(args.icp, "r") as f:
            icp_config = json.load(f)

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

    prospects = data.get("prospects", data) if isinstance(data, dict) else data
    results = [score_prospect(p, icp_config) for p in prospects]

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


if __name__ == "__main__":
    main()