Vendor Due Diligence

#!/usr/bin/env python3
"""
Vendor Comparison Tool

Takes multiple vendor risk assessment JSONs and generates a side-by-side
comparison matrix. Ranks vendors by composite score, highlights strengths
and weaknesses per dimension, and recommends preferred vendor with rationale.

Usage:
    python vendor_comparison.py vendor_a.json vendor_b.json
    python vendor_comparison.py vendor_a.json vendor_b.json vendor_c.json --json
    python vendor_comparison.py vendor_a.json vendor_b.json --critical
"""

import argparse
import json
import sys
from typing import Any, Dict, List, Tuple

# Dimension weights
STANDARD_WEIGHTS: Dict[str, float] = {
    "financial": 1.0, "operational": 1.0, "compliance": 1.0,
    "security": 1.0, "reputational": 0.8, "strategic": 0.8,
}

CRITICAL_WEIGHTS: Dict[str, float] = {
    "financial": 1.0, "operational": 1.0, "compliance": 2.0,
    "security": 2.0, "reputational": 0.8, "strategic": 0.8,
}

DIMENSIONS = ["financial", "operational", "compliance", "security", "reputational", "strategic"]

RISK_LEVELS: List[Tuple[float, str, str]] = [
    (1.5, "Low Risk", "Approve"),
    (2.5, "Moderate Risk", "Approve with Conditions"),
    (3.5, "High Risk", "Enhanced Due Diligence"),
    (5.0, "Critical Risk", "Reject or Remediate"),
]


def load_vendor_data(file_path: str) -> Dict[str, Any]:
    """Load and validate a vendor assessment JSON file."""
    try:
        with open(file_path, "r", encoding="utf-8") as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: File not found: {file_path}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON in {file_path}: {e}", file=sys.stderr)
        sys.exit(1)

    # Validate required structure
    vendor_name = data.get("vendor_name", file_path.split("/")[-1].replace(".json", ""))
    scores: Dict[str, int] = {}

    for dim in DIMENSIONS:
        dim_data = data.get(dim, {})
        if isinstance(dim_data, dict) and "score" in dim_data:
            # Pre-scored format (output from vendor_risk_scorer.py)
            scores[dim] = dim_data["score"]
        elif isinstance(dim_data, dict):
            # Raw questionnaire format -- apply basic scoring
            scores[dim] = _quick_score(dim, dim_data)
        else:
            scores[dim] = 3  # default moderate if missing

    return {"vendor_name": vendor_name, "scores": scores, "raw_data": data}


def _quick_score(dimension: str, data: Dict[str, Any]) -> int:
    """Quick-score a dimension from raw questionnaire data (simplified)."""
    score = 3  # baseline
    positive_keys = [
        "audited_financials", "disaster_recovery_plan", "business_continuity_tested",
        "geographic_redundancy", "dedicated_support", "compliance_team_exists",
        "encryption_at_rest", "encryption_in_transit", "mfa_enforced",
        "incident_response_plan", "soc2_type2", "vulnerability_management",
        "client_references_available", "industry_recognition",
        "exit_strategy_feasible", "innovation_track_record",
    ]
    negative_keys = [
        "key_person_dependency", "breach_history", "litigation_history",
        "negative_press",
    ]

    for key in positive_keys:
        if data.get(key, False) is True:
            score -= 0.3

    for key in negative_keys:
        if data.get(key, False) is True:
            score += 0.5

    certs = data.get("certifications", [])
    score -= min(1.5, len(certs) * 0.5)

    return max(1, min(5, round(score)))


def calculate_composite(scores: Dict[str, int], weights: Dict[str, float]) -> float:
    """Calculate weighted composite score."""
    weighted_sum = sum(scores[d] * weights[d] for d in DIMENSIONS)
    total_weight = sum(weights[d] for d in DIMENSIONS)
    return round(weighted_sum / total_weight, 2)


def get_risk_level(composite: float) -> Tuple[str, str]:
    """Get risk level and recommendation from composite score."""
    for threshold, level, rec in RISK_LEVELS:
        if composite <= threshold:
            return level, rec
    return "Critical Risk", "Reject or Remediate"


def analyze_strengths_weaknesses(
    vendors: List[Dict[str, Any]]
) -> Dict[str, Dict[str, List[str]]]:
    """Identify per-vendor strengths and weaknesses relative to the group."""
    analysis: Dict[str, Dict[str, List[str]]] = {}

    for vendor in vendors:
        name = vendor["vendor_name"]
        strengths: List[str] = []
        weaknesses: List[str] = []

        for dim in DIMENSIONS:
            vendor_score = vendor["scores"][dim]
            other_scores = [v["scores"][dim] for v in vendors if v["vendor_name"] != name]

            if not other_scores:
                continue

            avg_other = sum(other_scores) / len(other_scores)

            if vendor_score < avg_other - 0.5:
                strengths.append(f"{dim.title()} ({vendor_score}/5 vs avg {avg_other:.1f})")
            elif vendor_score > avg_other + 0.5:
                weaknesses.append(f"{dim.title()} ({vendor_score}/5 vs avg {avg_other:.1f})")

        analysis[name] = {"strengths": strengths, "weaknesses": weaknesses}

    return analysis


def generate_recommendation(
    vendors: List[Dict[str, Any]], weights: Dict[str, float]
) -> Dict[str, Any]:
    """Generate preferred vendor recommendation with rationale."""
    ranked = sorted(
        vendors,
        key=lambda v: calculate_composite(v["scores"], weights),
    )

    preferred = ranked[0]
    preferred_composite = calculate_composite(preferred["scores"], weights)
    risk_level, rec = get_risk_level(preferred_composite)

    rationale_parts: List[str] = []
    rationale_parts.append(
        f"Lowest composite risk score ({preferred_composite:.2f})"
    )

    # Find dimensions where preferred vendor leads
    for dim in DIMENSIONS:
        is_best = all(
            preferred["scores"][dim] <= v["scores"][dim]
            for v in vendors if v["vendor_name"] != preferred["vendor_name"]
        )
        if is_best and preferred["scores"][dim] <= 2:
            rationale_parts.append(f"Best-in-class {dim} risk ({preferred['scores'][dim]}/5)")

    # Note any concerns
    concerns: List[str] = []
    for dim in DIMENSIONS:
        if preferred["scores"][dim] >= 4:
            concerns.append(f"{dim.title()} dimension scores {preferred['scores'][dim]}/5 -- requires mitigation")

    return {
        "preferred_vendor": preferred["vendor_name"],
        "composite_score": preferred_composite,
        "risk_level": risk_level,
        "recommendation": rec,
        "rationale": rationale_parts,
        "concerns": concerns,
    }


def build_comparison_matrix(
    vendors: List[Dict[str, Any]], weights: Dict[str, float]
) -> Dict[str, Any]:
    """Build the full comparison result."""
    # Calculate composites
    vendor_results: List[Dict[str, Any]] = []
    for v in vendors:
        composite = calculate_composite(v["scores"], weights)
        risk_level, rec = get_risk_level(composite)
        vendor_results.append({
            "vendor_name": v["vendor_name"],
            "scores": v["scores"],
            "composite_score": composite,
            "risk_level": risk_level,
            "recommendation": rec,
        })

    # Sort by composite (lower is better)
    vendor_results.sort(key=lambda x: x["composite_score"])

    # Rank
    for i, vr in enumerate(vendor_results, 1):
        vr["rank"] = i

    # Analysis
    sw_analysis = analyze_strengths_weaknesses(vendors)
    recommendation = generate_recommendation(vendors, weights)

    # Risk deltas
    if len(vendor_results) >= 2:
        best = vendor_results[0]["composite_score"]
        worst = vendor_results[-1]["composite_score"]
        delta = round(worst - best, 2)
    else:
        delta = 0.0

    return {
        "vendor_count": len(vendors),
        "ranking": vendor_results,
        "strengths_weaknesses": sw_analysis,
        "recommendation": recommendation,
        "risk_delta": delta,
    }


def format_text_output(result: Dict[str, Any], critical: bool) -> str:
    """Format comparison results as human-readable text."""
    lines: List[str] = []
    lines.append("=" * 78)
    lines.append("VENDOR COMPARISON MATRIX")
    lines.append(f"Vendors Compared: {result['vendor_count']}")
    lines.append(f"Weighting: {'Critical Service (2x Security & Compliance)' if critical else 'Standard'}")
    lines.append("=" * 78)
    lines.append("")

    # Ranking table
    lines.append("-" * 78)
    lines.append(f"{'Rank':<6} {'Vendor':<25} {'Composite':>10} {'Risk Level':<18} {'Recommendation'}")
    lines.append("-" * 78)
    for vr in result["ranking"]:
        lines.append(
            f"  {vr['rank']:<4} {vr['vendor_name']:<25} {vr['composite_score']:>8.2f}   "
            f"{vr['risk_level']:<18} {vr['recommendation']}"
        )
    lines.append("")

    # Dimension comparison
    lines.append("-" * 78)
    lines.append("DIMENSION COMPARISON (1=Low Risk, 5=Critical Risk)")
    lines.append("-" * 78)

    header = f"{'Dimension':<16}"
    for vr in result["ranking"]:
        header += f" {vr['vendor_name'][:15]:>15}"
    lines.append(header)
    lines.append("-" * 78)

    for dim in DIMENSIONS:
        row = f"  {dim.title():<14}"
        scores_for_dim = []
        for vr in result["ranking"]:
            score = vr["scores"][dim]
            scores_for_dim.append(score)
            bar = "█" * score + "░" * (5 - score)
            row += f" {bar} {score:<3}"
        # Mark best
        best_score = min(scores_for_dim)
        lines.append(row)
    lines.append("")

    # Strengths and weaknesses
    lines.append("-" * 78)
    lines.append("STRENGTHS & WEAKNESSES")
    lines.append("-" * 78)
    for vendor_name, sw in result["strengths_weaknesses"].items():
        lines.append(f"\n  {vendor_name}:")
        if sw["strengths"]:
            lines.append("    Strengths:")
            for s in sw["strengths"]:
                lines.append(f"      + {s}")
        if sw["weaknesses"]:
            lines.append("    Weaknesses:")
            for w in sw["weaknesses"]:
                lines.append(f"      - {w}")
        if not sw["strengths"] and not sw["weaknesses"]:
            lines.append("    No significant differentiators vs. other vendors")
    lines.append("")

    # Recommendation
    rec = result["recommendation"]
    lines.append("-" * 78)
    lines.append("RECOMMENDATION")
    lines.append("-" * 78)
    lines.append(f"  Preferred Vendor: {rec['preferred_vendor']}")
    lines.append(f"  Composite Score:  {rec['composite_score']:.2f}")
    lines.append(f"  Risk Level:       {rec['risk_level']}")
    lines.append(f"  Action:           {rec['recommendation']}")
    lines.append("")
    lines.append("  Rationale:")
    for r in rec["rationale"]:
        lines.append(f"    - {r}")
    if rec["concerns"]:
        lines.append("  Concerns:")
        for c in rec["concerns"]:
            lines.append(f"    ! {c}")

    lines.append("")
    lines.append(f"  Risk Delta (best to worst): {result['risk_delta']:.2f}")
    lines.append("")

    return "\n".join(lines)


def main() -> None:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Compare multiple vendors side-by-side and recommend preferred vendor."
    )
    parser.add_argument(
        "input_files", nargs="+",
        help="Paths to vendor assessment JSON files (minimum 2)"
    )
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument("--critical", action="store_true",
                        help="Apply 2x weight to security and compliance")
    args = parser.parse_args()

    if len(args.input_files) < 2:
        print("Error: At least 2 vendor files required for comparison.", file=sys.stderr)
        sys.exit(1)

    vendors: List[Dict[str, Any]] = []
    for fp in args.input_files:
        vendors.append(load_vendor_data(fp))

    # Check for duplicate vendor names
    names = [v["vendor_name"] for v in vendors]
    if len(names) != len(set(names)):
        print("Warning: Duplicate vendor names detected. Results may be ambiguous.", file=sys.stderr)

    weights = CRITICAL_WEIGHTS if args.critical else STANDARD_WEIGHTS
    result = build_comparison_matrix(vendors, weights)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Vendor Risk Scorer

Scores a vendor across 6 risk dimensions based on questionnaire responses.
Calculates weighted composite score with optional 2x multiplier for critical
services on security and compliance dimensions.

Usage:
    python vendor_risk_scorer.py vendor_responses.json
    python vendor_risk_scorer.py vendor_responses.json --json
    python vendor_risk_scorer.py vendor_responses.json --critical

Input: JSON with vendor_name, service_description, and dimension objects
(financial, operational, compliance, security, reputational, strategic).
See SKILL.md for full input schema.
"""

import argparse
import json
import sys
from typing import Any, Dict, List, Tuple


# Dimension weights (standard)
STANDARD_WEIGHTS: Dict[str, float] = {
    "financial": 1.0, "operational": 1.0, "compliance": 1.0,
    "security": 1.0, "reputational": 0.8, "strategic": 0.8,
}

# Critical service weights (2x on security and compliance)
CRITICAL_WEIGHTS: Dict[str, float] = {
    "financial": 1.0, "operational": 1.0, "compliance": 2.0,
    "security": 2.0, "reputational": 0.8, "strategic": 0.8,
}

# Composite score interpretation
RISK_LEVELS: List[Tuple[float, str, str]] = [
    (1.5, "Low Risk", "Approve"),
    (2.5, "Moderate Risk", "Approve with Conditions"),
    (3.5, "High Risk", "Enhanced Due Diligence Required"),
    (5.0, "Critical Risk", "Reject or Require Remediation"),
]


def _clamp(score: int) -> int:
    """Clamp score to 1-5 range."""
    return max(1, min(5, score))


def score_financial(data: Dict[str, Any]) -> Tuple[int, List[str]]:
    """Score financial dimension (1=Low Risk, 5=Critical Risk)."""
    score, findings = 3, []
    revenue = data.get("annual_revenue", 0)
    if revenue > 100_000_000:
        score -= 1; findings.append("Large revenue base reduces financial risk")
    elif revenue < 5_000_000:
        score += 1; findings.append("Small revenue base increases financial risk")
    years = data.get("years_in_business", 0)
    if years >= 10:
        score -= 1; findings.append(f"{years} years in business -- established track record")
    elif years < 3:
        score += 1; findings.append(f"{years} years in business -- limited operating history")
    prof = data.get("profitability")
    if prof == "profitable":
        score -= 1; findings.append("Company is profitable")
    elif prof == "loss_making":
        score += 1; findings.append("Company is loss-making -- monitor cash runway")
    if data.get("audited_financials", False):
        findings.append("Audited financials available")
    else:
        score += 1; findings.append("No audited financials -- reduced transparency")
    findings.append("Insurance coverage in place" if data.get("insurance_coverage") else "No insurance coverage reported")
    return _clamp(score), findings


def score_operational(data: Dict[str, Any]) -> Tuple[int, List[str]]:
    """Score operational dimension."""
    score, findings = 3, []
    employees = data.get("employee_count", 0)
    if employees > 500:
        score -= 1; findings.append(f"{employees} employees -- robust operational capacity")
    elif employees < 20:
        score += 1; findings.append(f"{employees} employees -- limited operational capacity")
    for key, pos_msg, neg_msg, neg_score in [
        ("disaster_recovery_plan", "Disaster recovery plan in place", "No disaster recovery plan -- critical gap", 1),
        ("business_continuity_tested", "Business continuity plan tested", "Business continuity not tested", 1),
    ]:
        if data.get(key, False):
            score -= 1; findings.append(pos_msg)
        else:
            score += neg_score; findings.append(neg_msg)
    if data.get("geographic_redundancy", False):
        score -= 1; findings.append("Geographic redundancy in place")
    if data.get("key_person_dependency", False):
        score += 1; findings.append("Key person dependency identified -- concentration risk")
    if data.get("dedicated_support", False):
        findings.append("Dedicated support available")
    return _clamp(score), findings


def score_compliance(data: Dict[str, Any]) -> Tuple[int, List[str]]:
    """Score compliance dimension."""
    score, findings = 3, []
    certs = data.get("certifications", [])
    if len(certs) >= 3:
        score -= 2; findings.append(f"Strong certification portfolio: {', '.join(certs)}")
    elif len(certs) >= 1:
        score -= 1; findings.append(f"Certifications held: {', '.join(certs)}")
    else:
        score += 1; findings.append("No recognized certifications -- significant compliance gap")
    if data.get("compliance_team_exists", False):
        score -= 1; findings.append("Dedicated compliance team exists")
    else:
        findings.append("No dedicated compliance team")
    audit_freq = data.get("audit_frequency", "none")
    if audit_freq in ("quarterly", "semi_annual"):
        score -= 1; findings.append(f"Audit frequency: {audit_freq}")
    elif audit_freq == "annual":
        findings.append("Annual audit cycle")
    else:
        score += 1; findings.append("No regular audit cycle")
    if data.get("breach_history", False):
        score += 2; findings.append("Prior compliance breach on record -- elevated risk")
    return _clamp(score), findings


def score_security(data: Dict[str, Any]) -> Tuple[int, List[str]]:
    """Score security dimension."""
    score, findings = 3, []
    enc_rest, enc_transit = data.get("encryption_at_rest", False), data.get("encryption_in_transit", False)
    if enc_rest and enc_transit:
        score -= 1; findings.append("Full encryption (at rest and in transit)")
    elif not enc_rest and not enc_transit:
        score += 2; findings.append("No encryption reported -- critical security gap")
    else:
        findings.append("Partial encryption coverage")
    if data.get("mfa_enforced", False):
        score -= 1; findings.append("MFA enforced")
    else:
        score += 1; findings.append("MFA not enforced -- access control gap")
    pen_test = data.get("pen_test_frequency", "none")
    if pen_test in ("quarterly", "semi_annual"):
        score -= 1; findings.append(f"Penetration testing: {pen_test}")
    elif pen_test == "annual":
        findings.append("Annual penetration testing")
    else:
        score += 1; findings.append("No regular penetration testing")
    if data.get("incident_response_plan", False):
        findings.append("Incident response plan in place")
    else:
        score += 1; findings.append("No incident response plan")
    if data.get("soc2_type2", False):
        score -= 1; findings.append("SOC 2 Type II certified")
    if data.get("zero_trust_architecture", False):
        score -= 1; findings.append("Zero trust architecture implemented")
    return _clamp(score), findings


def score_reputational(data: Dict[str, Any]) -> Tuple[int, List[str]]:
    """Score reputational dimension."""
    score, findings = 2, []  # baseline low-moderate
    breaches = data.get("public_breaches", 0)
    if breaches > 2:
        score += 2; findings.append(f"{breaches} public breaches -- significant reputational concern")
    elif breaches > 0:
        score += 1; findings.append(f"{breaches} public breach(es) on record")
    else:
        findings.append("No public breaches on record")
    if data.get("litigation_history", False):
        score += 1; findings.append("Litigation history present")
    if data.get("negative_press", False):
        score += 1; findings.append("Negative press coverage identified")
    rating = data.get("glassdoor_rating", 0)
    if rating >= 4.0:
        score -= 1; findings.append(f"Glassdoor rating: {rating}/5 -- strong employee satisfaction")
    elif 0 < rating < 3.0:
        score += 1; findings.append(f"Glassdoor rating: {rating}/5 -- employee satisfaction concern")
    if data.get("client_references_available", False):
        findings.append("Client references available")
    else:
        score += 1; findings.append("No client references available")
    return _clamp(score), findings


def score_strategic(data: Dict[str, Any]) -> Tuple[int, List[str]]:
    """Score strategic dimension."""
    score, findings = 3, []
    position = data.get("market_position", "unknown")
    score += {"leader": -2, "established": -1, "growing": 0, "niche": 0, "declining": 2}.get(position, 0)
    findings.append(f"Market position: {position}")
    alignment = data.get("product_roadmap_alignment", "low")
    score += {"high": -1, "moderate": 0, "low": 1}.get(alignment, 0)
    findings.append(f"Product roadmap alignment: {alignment}")
    lock_in = data.get("lock_in_risk", "low")
    score += {"low": -1, "moderate": 0, "high": 1, "critical": 2}.get(lock_in, 0)
    findings.append(f"Lock-in risk: {lock_in}" + (" -- exit strategy critical" if lock_in in ("high", "critical") else ""))
    if data.get("exit_strategy_feasible", False):
        findings.append("Exit strategy assessed as feasible")
    else:
        score += 1; findings.append("Exit strategy not feasible -- significant strategic risk")
    return _clamp(score), findings


def calculate_composite(
    dimensions: Dict[str, Dict[str, Any]], critical: bool
) -> Tuple[float, str, str]:
    """Calculate weighted composite score and determine risk level and recommendation."""
    weights = CRITICAL_WEIGHTS if critical else STANDARD_WEIGHTS
    weighted_sum = sum(dimensions[d]["score"] * weights[d] for d in dimensions)
    total_weight = sum(weights[d] for d in dimensions)
    composite = weighted_sum / total_weight

    risk_level = "Critical Risk"
    recommendation = "Reject or Require Remediation"
    for threshold, level, rec in RISK_LEVELS:
        if composite <= threshold:
            risk_level = level
            recommendation = rec
            break

    return round(composite, 2), risk_level, recommendation


def generate_heat_map(dimensions: Dict[str, Dict[str, Any]]) -> List[str]:
    """Generate a text-based risk heat map."""
    labels = {1: "LOW", 2: "MOD-LOW", 3: "MODERATE", 4: "HIGH", 5: "CRITICAL"}
    lines: List[str] = []
    for dim, data in dimensions.items():
        score = data["score"]
        bar = "█" * score + "░" * (5 - score)
        label = labels.get(score, "???")
        lines.append(f"  {dim.title():<14} [{bar}] {score}/5 {label}")
    return lines


def format_text_output(result: Dict[str, Any]) -> str:
    """Format results as human-readable text."""
    lines: List[str] = []
    lines.append("=" * 70)
    lines.append(f"VENDOR RISK ASSESSMENT: {result['vendor_name']}")
    lines.append("=" * 70)
    lines.append("")
    lines.append(f"Service:          {result.get('service_description', 'N/A')}")
    lines.append(f"Critical Service: {'Yes (2x weight on Security & Compliance)' if result['critical'] else 'No (standard weighting)'}")
    lines.append(f"Composite Score:  {result['composite_score']:.2f} / 5.00")
    lines.append(f"Risk Level:       {result['risk_level']}")
    lines.append(f"Recommendation:   {result['recommendation']}")
    lines.append("")

    lines.append("-" * 70)
    lines.append("RISK HEAT MAP")
    lines.append("-" * 70)
    lines.extend(generate_heat_map(result["dimensions"]))
    lines.append("")

    lines.append("-" * 70)
    lines.append("DIMENSION FINDINGS")
    lines.append("-" * 70)
    for dim, data in result["dimensions"].items():
        lines.append(f"\n  {dim.title()} (Score: {data['score']}/5):")
        for finding in data["findings"]:
            lines.append(f"    - {finding}")

    lines.append("")

    gaps = result.get("gaps", [])
    if gaps:
        lines.append("-" * 70)
        lines.append("GAP ANALYSIS")
        lines.append("-" * 70)
        for gap in gaps:
            lines.append(f"  [{gap['severity'].upper()}] {gap['dimension'].title()}: {gap['description']}")
        lines.append("")

    return "\n".join(lines)


def identify_gaps(dimensions: Dict[str, Dict[str, Any]]) -> List[Dict[str, str]]:
    """Identify gaps based on dimension scores."""
    gaps: List[Dict[str, str]] = []
    severity_map = {5: "blocker", 4: "major_concern", 3: "minor_gap"}

    for dim, data in dimensions.items():
        score = data["score"]
        if score >= 3:
            severity = severity_map.get(score, "minor_gap")
            for finding in data["findings"]:
                if any(w in finding.lower() for w in ["gap", "no ", "not ", "concern", "critical", "elevated"]):
                    gaps.append({"dimension": dim, "severity": severity, "description": finding})

    return gaps


def main() -> None:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Score a vendor across 6 risk dimensions and generate recommendation."
    )
    parser.add_argument("input_file", help="Path to JSON file with vendor questionnaire responses")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument("--critical", action="store_true",
                        help="Apply 2x weight to security and compliance (critical services)")
    args = parser.parse_args()

    try:
        with open(args.input_file, "r", encoding="utf-8") 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: {e}", file=sys.stderr)
        sys.exit(1)

    # Score each dimension
    scorers = {
        "financial": score_financial,
        "operational": score_operational,
        "compliance": score_compliance,
        "security": score_security,
        "reputational": score_reputational,
        "strategic": score_strategic,
    }

    dimensions: Dict[str, Dict[str, Any]] = {}
    for dim, scorer in scorers.items():
        dim_data = data.get(dim, {})
        score, findings = scorer(dim_data)
        dimensions[dim] = {"score": score, "findings": findings}

    composite, risk_level, recommendation = calculate_composite(dimensions, args.critical)
    gaps = identify_gaps(dimensions)

    result = {
        "vendor_name": data.get("vendor_name", "Unknown Vendor"),
        "service_description": data.get("service_description", "N/A"),
        "critical": args.critical,
        "composite_score": composite,
        "risk_level": risk_level,
        "recommendation": recommendation,
        "dimensions": dimensions,
        "gaps": gaps,
    }

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


if __name__ == "__main__":
    main()