Strategic Alignment

#!/usr/bin/env python3
"""Alignment Scorer - Calculate alignment score across 5 dimensions with trend tracking.

Scores strategy clarity, cascade completeness, conflict resolution, coverage,
and communication effectiveness. Compares to previous score for trend analysis.

Usage:
    python alignment_scorer.py --clarity 8 --cascade 6 --conflicts 7 --coverage 5 --communication 6
    python alignment_scorer.py --clarity 8 --cascade 6 --conflicts 7 --coverage 5 --communication 6 --previous-score 28 --json
"""

import argparse
import json
import sys
from datetime import datetime

DIMENSIONS = {
    "clarity": {
        "name": "Strategy Clarity",
        "question": "Can 5 people from different teams state the strategy consistently?",
        "scoring_guide": {
            "9-10": "All 5 give the same answer with specifics",
            "7-8": "4 of 5 give similar answers",
            "5-6": "3 agree, some confusion on details",
            "3-4": "Only 2 agree, strategy unclear to most",
            "1-2": "No shared understanding of strategy"
        },
        "improvement_actions": {
            "low": [
                "Rewrite strategy as one falsifiable sentence",
                "CEO communicates strategy through 7+ channels over 2 weeks",
                "Re-run 5-person test after 2 weeks"
            ],
            "medium": [
                "Clarify the specific parts causing confusion",
                "Add visual strategy map to all team areas",
                "Include strategy restatement in monthly all-hands"
            ]
        }
    },
    "cascade": {
        "name": "Cascade Completeness",
        "question": "Do all team goals connect to company goals?",
        "scoring_guide": {
            "9-10": "Every team OKR traces to a company OKR with clear impact",
            "7-8": "90%+ connected, minor gaps",
            "5-6": "70-90% connected, some orphan goals",
            "3-4": "50-70% connected, significant orphan goals",
            "1-2": "Most team goals disconnected from company strategy"
        },
        "improvement_actions": {
            "low": [
                "Map every team OKR to a company OKR (connect or cut workshop)",
                "Require parent OKR for every new team goal",
                "Review cascade at start of every quarter"
            ],
            "medium": [
                "Address specific orphan goals identified",
                "Strengthen goal-setting process with cascade template",
                "Quarterly cascade validation review"
            ]
        }
    },
    "conflicts": {
        "name": "Conflict Detection",
        "question": "Have cross-team OKR conflicts been reviewed and resolved?",
        "scoring_guide": {
            "9-10": "All potential conflicts identified and resolved with shared metrics",
            "7-8": "Most conflicts addressed, minor tensions remain",
            "5-6": "Some conflicts identified but not all resolved",
            "3-4": "Known conflicts unaddressed",
            "1-2": "No conflict detection process exists"
        },
        "improvement_actions": {
            "low": [
                "Run cross-functional OKR review to identify conflicts",
                "Create shared metrics for conflicting team pairs",
                "Establish escalation process for unresolved conflicts"
            ],
            "medium": [
                "Review and resolve remaining identified conflicts",
                "Add conflict check to quarterly planning process",
                "Track shared metrics monthly"
            ]
        }
    },
    "coverage": {
        "name": "Coverage",
        "question": "Does each company OKR have explicit team ownership?",
        "scoring_guide": {
            "9-10": "Every company OKR has 2+ teams supporting it with clear ownership",
            "7-8": "Most company OKRs covered, 1 may be light",
            "5-6": "1-2 company OKRs have no team support",
            "3-4": "Multiple company OKRs unsupported",
            "1-2": "Company OKRs exist on paper but no teams actively support them"
        },
        "improvement_actions": {
            "low": [
                "Assign explicit team ownership to every company OKR",
                "Ensure resource allocation matches stated priorities",
                "CEO reviews coverage gaps with leadership team"
            ],
            "medium": [
                "Strengthen support for lightly-covered OKRs",
                "Review resource allocation vs priority ranking",
                "Add coverage check to quarterly planning"
            ]
        }
    },
    "communication": {
        "name": "Communication",
        "question": "Do teams' behaviors reflect the strategy?",
        "scoring_guide": {
            "9-10": "Team decisions and resource allocation clearly reflect strategy",
            "7-8": "Mostly aligned, occasional drift",
            "5-6": "Strategy communicated but not consistently reflected in daily work",
            "3-4": "Significant gap between stated strategy and team behavior",
            "1-2": "Strategy is a document nobody references"
        },
        "improvement_actions": {
            "low": [
                "Increase communication frequency (weekly, not quarterly)",
                "Add skip-level communication to reduce message decay",
                "Show resource proof: money and time follow stated words"
            ],
            "medium": [
                "Vary communication format (written, visual, verbal)",
                "Include strategy connection in team standups",
                "Monthly strategy check-in at all-hands"
            ]
        }
    }
}

SCORE_INTERPRETATION = [
    {"range": "45-50", "status": "Excellent", "action": "Maintain. Quarterly check sufficient."},
    {"range": "35-44", "status": "Good", "action": "Address specific weak areas in next OKR cycle."},
    {"range": "20-34", "status": "Misalignment Costing You", "action": "Immediate attention. Workshop within 2 weeks."},
    {"range": "0-19", "status": "Strategic Drift", "action": "Crisis-level intervention. CEO-led realignment."}
]


def score_alignment(scores, previous_score=None):
    total = sum(scores.values())

    dimension_results = []
    for dim_key, score in scores.items():
        dim_info = DIMENSIONS[dim_key]
        level = "low" if score < 5 else "medium"
        actions = dim_info["improvement_actions"].get(level, [])

        dimension_results.append({
            "dimension": dim_info["name"],
            "key": dim_key,
            "score": score,
            "question": dim_info["question"],
            "scoring_guide": dim_info["scoring_guide"],
            "improvement_actions": actions if score < 8 else []
        })

    # Determine status
    if total >= 45:
        status = "Excellent"
        action = "Maintain. Quarterly check sufficient."
    elif total >= 35:
        status = "Good"
        action = "Address specific weak areas in next OKR cycle."
    elif total >= 20:
        status = "Misalignment Costing You"
        action = "Immediate attention. Workshop within 2 weeks."
    else:
        status = "Strategic Drift"
        action = "Crisis-level intervention. CEO-led realignment."

    # Trend
    trend = None
    if previous_score is not None:
        delta = total - previous_score
        if delta > 2:
            trend = {"direction": "IMPROVING", "delta": delta, "previous": previous_score}
        elif delta < -2:
            trend = {"direction": "DECLINING", "delta": delta, "previous": previous_score}
        else:
            trend = {"direction": "STABLE", "delta": delta, "previous": previous_score}

    # Weakest dimension
    weakest = min(dimension_results, key=lambda d: d["score"])
    strongest = max(dimension_results, key=lambda d: d["score"])

    return {
        "assessment_date": datetime.now().strftime("%Y-%m-%d"),
        "total_score": total,
        "max_score": 50,
        "status": status,
        "recommended_action": action,
        "trend": trend,
        "dimensions": dimension_results,
        "weakest": {"dimension": weakest["dimension"], "score": weakest["score"]},
        "strongest": {"dimension": strongest["dimension"], "score": strongest["score"]},
        "priority_improvements": [d for d in dimension_results if d["score"] < 7],
        "score_interpretation": SCORE_INTERPRETATION
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"STRATEGIC ALIGNMENT SCORE")
    print(f"Date: {result['assessment_date']}")
    print(f"{'='*70}\n")

    print(f"TOTAL: {result['total_score']}/{result['max_score']} ({result['status']})")

    if result["trend"]:
        t = result["trend"]
        arrow = "^" if t["direction"] == "IMPROVING" else "v" if t["direction"] == "DECLINING" else "="
        print(f"Trend: {arrow} {t['direction']} ({'+' if t['delta'] > 0 else ''}{t['delta']} from {t['previous']})")

    print(f"Action: {result['recommended_action']}\n")

    print("DIMENSIONS:")
    print("-" * 60)
    for d in sorted(result["dimensions"], key=lambda x: -x["score"]):
        bar = "#" * d["score"] + "." * (10 - d["score"])
        print(f"  {d['dimension']:<25s} {d['score']:>2}/10  [{bar}]")

    print(f"\nStrongest: {result['strongest']['dimension']} ({result['strongest']['score']}/10)")
    print(f"Weakest:   {result['weakest']['dimension']} ({result['weakest']['score']}/10)")

    if result["priority_improvements"]:
        print(f"\nPRIORITY IMPROVEMENTS:")
        for d in result["priority_improvements"]:
            print(f"\n  {d['dimension']} ({d['score']}/10):")
            for a in d["improvement_actions"]:
                print(f"    -> {a}")

    print(f"\nSCORE GUIDE:")
    for si in result["score_interpretation"]:
        print(f"  {si['range']:<8s} {si['status']:<30s} {si['action']}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Calculate strategic alignment score across 5 dimensions")
    parser.add_argument("--clarity", type=int, required=True, help="Strategy clarity (1-10)")
    parser.add_argument("--cascade", type=int, required=True, help="Cascade completeness (1-10)")
    parser.add_argument("--conflicts", type=int, required=True, help="Conflict detection/resolution (1-10)")
    parser.add_argument("--coverage", type=int, required=True, help="OKR coverage (1-10)")
    parser.add_argument("--communication", type=int, required=True, help="Communication effectiveness (1-10)")
    parser.add_argument("--previous-score", type=int, default=None, help="Previous total score for trend comparison")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    for attr in ["clarity", "cascade", "conflicts", "coverage", "communication"]:
        val = getattr(args, attr)
        if val < 1 or val > 10:
            print(f"Error: {attr} must be between 1 and 10", file=sys.stderr)
            sys.exit(1)

    scores = {
        "clarity": args.clarity,
        "cascade": args.cascade,
        "conflicts": args.conflicts,
        "coverage": args.coverage,
        "communication": args.communication
    }

    result = score_alignment(scores, args.previous_score)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""OKR Cascade Validator - Validate team OKRs connect to company OKRs.

Detects orphan goals (no parent), conflicting goals, and coverage gaps.
Reads OKRs from CSV files or inline input.

Usage:
    python okr_cascade_validator.py --company-okrs company_okrs.csv --team-okrs team_okrs.csv
    python okr_cascade_validator.py --company "Reach 5M ARR by Q4" --company "NPS above 40" --team "Sales:Close 50 new logos:Reach 5M ARR by Q4" --team "Eng:Ship HIPAA feature:Reach 5M ARR by Q4" --team "Marketing:Generate 1000 MQLs:" --json
"""

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


def load_csv_okrs(filepath, okr_type):
    """Load OKRs from CSV. Expected columns depend on type."""
    if not os.path.exists(filepath):
        print(f"Error: File not found: {filepath}", file=sys.stderr)
        sys.exit(1)

    okrs = []
    with open(filepath, "r") as f:
        reader = csv.DictReader(f)
        for row in reader:
            if okr_type == "company":
                okrs.append({
                    "id": row.get("id", f"C{len(okrs)+1}"),
                    "objective": row.get("objective", row.get("okr", ""))
                })
            else:
                okrs.append({
                    "team": row.get("team", "Unknown"),
                    "objective": row.get("objective", row.get("okr", "")),
                    "parent": row.get("parent", row.get("company_okr", "")).strip()
                })
    return okrs


def validate(company_okrs, team_okrs):
    """Validate cascade: orphans, conflicts, coverage gaps."""
    company_objectives = {c["objective"]: c for c in company_okrs}

    # Detect orphans (team OKRs with no parent or parent not matching any company OKR)
    orphans = []
    connected = []
    for t in team_okrs:
        if not t["parent"] or t["parent"] not in company_objectives:
            orphans.append({
                "team": t["team"],
                "objective": t["objective"],
                "stated_parent": t["parent"] or "None",
                "issue": "No valid parent company OKR" if not t["parent"] else f"Parent '{t['parent']}' not found in company OKRs"
            })
        else:
            connected.append(t)

    # Detect coverage gaps (company OKRs with no team OKRs supporting them)
    coverage = {}
    for c in company_okrs:
        supporting = [t for t in connected if t["parent"] == c["objective"]]
        coverage[c["objective"]] = {
            "company_okr": c["objective"],
            "supporting_teams": [t["team"] for t in supporting],
            "support_count": len(supporting),
            "gap": len(supporting) == 0
        }

    gaps = [c for c in coverage.values() if c["gap"]]

    # Detect potential conflicts (multiple teams working on same parent with potentially conflicting approaches)
    conflicts = []
    by_parent = {}
    for t in connected:
        if t["parent"] not in by_parent:
            by_parent[t["parent"]] = []
        by_parent[t["parent"]].append(t)

    # Simple conflict detection: teams with opposing optimization targets
    conflict_pairs = [
        (["new logos", "new customers", "acquisition", "volume"], ["NPS", "retention", "satisfaction", "quality"]),
        (["ship fast", "velocity", "speed", "launch"], ["security", "compliance", "audit", "quality"]),
        (["reduce cost", "efficiency", "cut", "savings"], ["hire", "invest", "expand", "grow"]),
    ]

    for parent, teams in by_parent.items():
        if len(teams) >= 2:
            for i in range(len(teams)):
                for j in range(i + 1, len(teams)):
                    t1_lower = teams[i]["objective"].lower()
                    t2_lower = teams[j]["objective"].lower()
                    for signal_a, signal_b in conflict_pairs:
                        t1_has_a = any(s in t1_lower for s in signal_a)
                        t1_has_b = any(s in t1_lower for s in signal_b)
                        t2_has_a = any(s in t2_lower for s in signal_a)
                        t2_has_b = any(s in t2_lower for s in signal_b)
                        if (t1_has_a and t2_has_b) or (t1_has_b and t2_has_a):
                            conflicts.append({
                                "parent_okr": parent,
                                "team_1": teams[i]["team"],
                                "objective_1": teams[i]["objective"],
                                "team_2": teams[j]["team"],
                                "objective_2": teams[j]["objective"],
                                "resolution": "Create shared metric that both teams own"
                            })

    # Alignment score
    total_team_okrs = len(team_okrs)
    orphan_pct = len(orphans) / total_team_okrs * 100 if total_team_okrs > 0 else 0
    coverage_pct = sum(1 for c in coverage.values() if not c["gap"]) / len(coverage) * 100 if coverage else 0

    cascade_score = 10
    cascade_score -= len(orphans) * 1.5
    cascade_score -= len(gaps) * 2
    cascade_score -= len(conflicts) * 1
    cascade_score = max(0, min(10, cascade_score))

    return {
        "validation_date": datetime.now().strftime("%Y-%m-%d"),
        "company_okrs_count": len(company_okrs),
        "team_okrs_count": total_team_okrs,
        "cascade_score": round(cascade_score, 1),
        "cascade_health": "HEALTHY" if cascade_score >= 7 else "NEEDS WORK" if cascade_score >= 4 else "BROKEN",
        "orphans": {
            "count": len(orphans),
            "percentage": round(orphan_pct, 1),
            "items": orphans
        },
        "coverage": {
            "fully_covered": sum(1 for c in coverage.values() if not c["gap"]),
            "gaps": len(gaps),
            "details": list(coverage.values()),
            "gap_items": gaps
        },
        "conflicts": {
            "count": len(conflicts),
            "items": conflicts
        },
        "recommendations": generate_recommendations(orphans, gaps, conflicts)
    }


def generate_recommendations(orphans, gaps, conflicts):
    recs = []
    if orphans:
        recs.append(f"ORPHANS: {len(orphans)} team OKR(s) have no valid parent. Connect each to a company OKR or cut the work.")
        for o in orphans[:3]:
            recs.append(f"  -> {o['team']}: '{o['objective']}' -- assign a parent company OKR")
    if gaps:
        recs.append(f"GAPS: {len(gaps)} company OKR(s) have no team support. Assign explicit team ownership.")
        for g in gaps[:3]:
            recs.append(f"  -> '{g['company_okr']}' -- no team assigned")
    if conflicts:
        recs.append(f"CONFLICTS: {len(conflicts)} potential goal conflict(s) detected between teams.")
        for c in conflicts[:3]:
            recs.append(f"  -> {c['team_1']} vs {c['team_2']}: create shared metric")
    if not recs:
        recs.append("No issues detected. Cascade looks healthy.")
    return recs


def print_human(result):
    print(f"\n{'='*70}")
    print(f"OKR CASCADE VALIDATION")
    print(f"Date: {result['validation_date']}")
    print(f"Company OKRs: {result['company_okrs_count']}  |  Team OKRs: {result['team_okrs_count']}")
    print(f"{'='*70}\n")

    print(f"CASCADE SCORE: {result['cascade_score']}/10 ({result['cascade_health']})\n")

    # Orphans
    o = result["orphans"]
    print(f"ORPHAN GOALS: {o['count']} ({o['percentage']}% of team OKRs)")
    if o["items"]:
        for item in o["items"]:
            print(f"  [!] {item['team']}: {item['objective']}")
            print(f"       Issue: {item['issue']}")

    # Coverage
    c = result["coverage"]
    print(f"\nCOVERAGE: {c['fully_covered']}/{c['fully_covered'] + c['gaps']} company OKRs have team support")
    for d in c["details"]:
        status = "+" if not d["gap"] else "!"
        teams = ", ".join(d["supporting_teams"]) if d["supporting_teams"] else "NO TEAMS ASSIGNED"
        print(f"  [{status}] {d['company_okr'][:50]}")
        print(f"       Supported by: {teams}")

    # Conflicts
    cf = result["conflicts"]
    if cf["items"]:
        print(f"\nCONFLICTS: {cf['count']}")
        for item in cf["items"]:
            print(f"  [!] {item['team_1']} ({item['objective_1'][:30]}...) vs {item['team_2']} ({item['objective_2'][:30]}...)")
            print(f"       Resolution: {item['resolution']}")

    print(f"\nRECOMMENDATIONS:")
    for r in result["recommendations"]:
        print(f"  {r}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Validate OKR cascade: orphans, conflicts, coverage gaps")
    parser.add_argument("--company-okrs", help="CSV file with company OKRs (columns: id, objective)")
    parser.add_argument("--team-okrs", help="CSV file with team OKRs (columns: team, objective, parent)")
    parser.add_argument("--company", action="append", help="Inline company OKR (multiple allowed)")
    parser.add_argument("--team", action="append", help="Inline team OKR as 'team:objective:parent_okr' (multiple allowed)")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    company_okrs = []
    team_okrs = []

    if args.company_okrs and args.team_okrs:
        company_okrs = load_csv_okrs(args.company_okrs, "company")
        team_okrs = load_csv_okrs(args.team_okrs, "team")
    elif args.company and args.team:
        for i, c in enumerate(args.company):
            company_okrs.append({"id": f"C{i+1}", "objective": c.strip()})
        for t_str in args.team:
            parts = t_str.split(":")
            if len(parts) >= 2:
                team_okrs.append({
                    "team": parts[0].strip(),
                    "objective": parts[1].strip(),
                    "parent": parts[2].strip() if len(parts) > 2 else ""
                })
    else:
        print("Error: Provide either --company-okrs/--team-okrs CSV files or --company/--team inline", file=sys.stderr)
        sys.exit(1)

    result = validate(company_okrs, team_okrs)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Strategy Map Generator - Generate balanced scorecard strategy map.

Creates a strategy map linking financial, customer, internal process, and
learning & growth perspectives following Kaplan & Norton's balanced scorecard framework.

Usage:
    python strategy_map_generator.py --objective "Win mid-market healthcare in DACH" --financial "5M ARR by Q4" --customer "NPS > 40" --process "Ship workflow automation" --learning "Hire 3 healthcare domain experts"
    python strategy_map_generator.py --objective "Become category leader" --financial "10M ARR,positive unit economics" --customer "NPS > 50,NRR > 120%" --process "Deploy PLG motion,reduce onboarding time 50%" --learning "Hire VP Product,build data team" --json
"""

import argparse
import json
import sys
from datetime import datetime

PERSPECTIVES = {
    "financial": {
        "name": "Financial Perspective",
        "question": "To succeed financially, how should we appear to our shareholders?",
        "typical_objectives": ["Revenue growth", "Profitability improvement", "Capital efficiency", "Unit economics"],
        "typical_metrics": ["ARR/MRR", "Gross margin", "Burn multiple", "LTV/CAC ratio", "Revenue per employee"]
    },
    "customer": {
        "name": "Customer Perspective",
        "question": "To achieve our vision, how should we appear to our customers?",
        "typical_objectives": ["Customer satisfaction", "Retention", "Market share", "Value delivery"],
        "typical_metrics": ["NPS", "NRR", "CSAT", "Churn rate", "Time to value", "Customer lifetime value"]
    },
    "process": {
        "name": "Internal Process Perspective",
        "question": "To satisfy shareholders and customers, what business processes must we excel at?",
        "typical_objectives": ["Product delivery", "Operational efficiency", "Innovation", "Quality"],
        "typical_metrics": ["Deploy frequency", "Cycle time", "Feature adoption", "MTTR", "OKR completion rate"]
    },
    "learning": {
        "name": "Learning & Growth Perspective",
        "question": "To achieve our vision, how will we sustain our ability to change and improve?",
        "typical_objectives": ["Talent development", "Knowledge management", "Culture", "Technology enablement"],
        "typical_metrics": ["eNPS", "Internal promotion rate", "Training hours", "Time to fill", "Innovation pipeline"]
    }
}


def generate_map(objective, financial, customer, process, learning):
    """Generate strategy map with linkages between perspectives."""
    perspectives = []

    for key, items_str in [("financial", financial), ("customer", customer), ("process", process), ("learning", learning)]:
        items = [i.strip() for i in items_str.split(",") if i.strip()]
        info = PERSPECTIVES[key]
        perspectives.append({
            "perspective": info["name"],
            "key": key,
            "question": info["question"],
            "objectives": items,
            "suggested_metrics": info["typical_metrics"]
        })

    # Generate linkages (how lower perspectives enable upper ones)
    linkages = []

    learning_objs = [i.strip() for i in learning.split(",") if i.strip()]
    process_objs = [i.strip() for i in process.split(",") if i.strip()]
    customer_objs = [i.strip() for i in customer.split(",") if i.strip()]
    financial_objs = [i.strip() for i in financial.split(",") if i.strip()]

    # Learning -> Process
    for l_obj in learning_objs:
        for p_obj in process_objs:
            linkages.append({
                "from_perspective": "Learning & Growth",
                "from_objective": l_obj,
                "to_perspective": "Internal Process",
                "to_objective": p_obj,
                "hypothesis": f"Investing in '{l_obj}' enables us to '{p_obj}'"
            })

    # Process -> Customer
    for p_obj in process_objs:
        for c_obj in customer_objs:
            linkages.append({
                "from_perspective": "Internal Process",
                "from_objective": p_obj,
                "to_perspective": "Customer",
                "to_objective": c_obj,
                "hypothesis": f"Excelling at '{p_obj}' drives '{c_obj}'"
            })

    # Customer -> Financial
    for c_obj in customer_objs:
        for f_obj in financial_objs:
            linkages.append({
                "from_perspective": "Customer",
                "from_objective": c_obj,
                "to_perspective": "Financial",
                "to_objective": f_obj,
                "hypothesis": f"Achieving '{c_obj}' leads to '{f_obj}'"
            })

    # Validation questions
    validation = [
        "Does every Learning objective enable at least one Process objective?",
        "Does every Process objective drive at least one Customer objective?",
        "Does every Customer objective contribute to at least one Financial objective?",
        "Are there Financial objectives with no clear path from lower perspectives?",
        "Is the strategy map simple enough to explain in 5 minutes?"
    ]

    return {
        "generated_date": datetime.now().strftime("%Y-%m-%d"),
        "strategic_objective": objective,
        "perspectives": perspectives,
        "linkages": linkages,
        "total_objectives": sum(len(p["objectives"]) for p in perspectives),
        "validation_questions": validation,
        "implementation_notes": [
            "Review strategy map quarterly -- update as strategy evolves",
            "Each objective should have 1-2 measurable KPIs",
            "Assign an owner for each objective",
            "Use this map as the basis for OKR cascade to teams",
            "Combine with OKR cascade validator for full alignment check"
        ]
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"STRATEGY MAP")
    print(f"Objective: {result['strategic_objective']}")
    print(f"Date: {result['generated_date']}")
    print(f"{'='*70}\n")

    # Visual map (top to bottom)
    for p in result["perspectives"]:
        print(f"  {'='*60}")
        print(f"  {p['perspective'].upper()}")
        print(f"  Question: {p['question']}")
        print(f"  {'='*60}")
        for obj in p["objectives"]:
            print(f"  | {obj}")
        print(f"  Suggested metrics: {', '.join(p['suggested_metrics'][:4])}")
        print(f"          |")
        print(f"          v")

    print(f"\nLINKAGES ({len(result['linkages'])} connections):")
    print("-" * 60)
    for l in result["linkages"]:
        print(f"  {l['from_perspective']} -> {l['to_perspective']}")
        print(f"    {l['hypothesis']}")

    print(f"\nVALIDATION QUESTIONS:")
    for v in result["validation_questions"]:
        print(f"  [ ] {v}")

    print(f"\nIMPLEMENTATION:")
    for n in result["implementation_notes"]:
        print(f"  -> {n}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Generate balanced scorecard strategy map")
    parser.add_argument("--objective", required=True, help="Strategic objective (one sentence)")
    parser.add_argument("--financial", required=True, help="Financial perspective objectives (comma-separated)")
    parser.add_argument("--customer", required=True, help="Customer perspective objectives (comma-separated)")
    parser.add_argument("--process", required=True, help="Internal process objectives (comma-separated)")
    parser.add_argument("--learning", required=True, help="Learning & growth objectives (comma-separated)")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    result = generate_map(args.objective, args.financial, args.customer, args.process, args.learning)

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


if __name__ == "__main__":
    main()