Contract And Proposal Writer

#!/usr/bin/env python3
"""
Contract Clause Checker

Validate a contract document against required clauses for a given
jurisdiction and engagement type. Identifies missing clauses, incomplete
sections, and jurisdiction-specific compliance gaps.

Usage:
    python contract_clause_checker.py contract.json --jurisdiction us-delaware
    python contract_clause_checker.py contract.json --jurisdiction eu --json
"""

import argparse
import json
import sys


REQUIRED_CLAUSES = {
    "fixed-price": [
        {"clause": "parties", "label": "Parties and legal names", "all_jurisdictions": True},
        {"clause": "scope_of_work", "label": "Scope of Work / Deliverables", "all_jurisdictions": True},
        {"clause": "acceptance_criteria", "label": "Acceptance criteria with sign-off process", "all_jurisdictions": True},
        {"clause": "payment_terms", "label": "Payment terms and schedule", "all_jurisdictions": True},
        {"clause": "ip_assignment", "label": "Intellectual property assignment", "all_jurisdictions": True},
        {"clause": "pre_existing_ip", "label": "Pre-existing IP carve-out", "all_jurisdictions": True},
        {"clause": "confidentiality", "label": "Confidentiality / NDA clause", "all_jurisdictions": True},
        {"clause": "liability_cap", "label": "Liability limitation", "all_jurisdictions": True},
        {"clause": "termination", "label": "Termination for cause and convenience", "all_jurisdictions": True},
        {"clause": "change_order", "label": "Change order process", "all_jurisdictions": True},
        {"clause": "governing_law", "label": "Governing law and dispute resolution", "all_jurisdictions": True},
        {"clause": "force_majeure", "label": "Force majeure", "all_jurisdictions": True},
        {"clause": "warranties", "label": "Warranties and representations", "all_jurisdictions": True},
    ],
    "hourly": [
        {"clause": "parties", "label": "Parties and legal names", "all_jurisdictions": True},
        {"clause": "scope_of_work", "label": "Scope of Work / Services description", "all_jurisdictions": True},
        {"clause": "rate_schedule", "label": "Rate schedule and invoicing terms", "all_jurisdictions": True},
        {"clause": "time_tracking", "label": "Time tracking requirements", "all_jurisdictions": True},
        {"clause": "payment_terms", "label": "Payment terms (net-30 etc.)", "all_jurisdictions": True},
        {"clause": "ip_assignment", "label": "IP assignment", "all_jurisdictions": True},
        {"clause": "confidentiality", "label": "Confidentiality", "all_jurisdictions": True},
        {"clause": "liability_cap", "label": "Liability limitation", "all_jurisdictions": True},
        {"clause": "termination", "label": "Termination with notice period", "all_jurisdictions": True},
        {"clause": "governing_law", "label": "Governing law", "all_jurisdictions": True},
    ],
    "retainer": [
        {"clause": "parties", "label": "Parties and legal names", "all_jurisdictions": True},
        {"clause": "services_description", "label": "Services description", "all_jurisdictions": True},
        {"clause": "retainer_amount", "label": "Monthly retainer amount", "all_jurisdictions": True},
        {"clause": "hours_included", "label": "Hours included and overflow rate", "all_jurisdictions": True},
        {"clause": "payment_terms", "label": "Payment terms (prepaid monthly)", "all_jurisdictions": True},
        {"clause": "sla", "label": "Response time SLAs", "all_jurisdictions": True},
        {"clause": "ip_assignment", "label": "IP assignment", "all_jurisdictions": True},
        {"clause": "confidentiality", "label": "Confidentiality", "all_jurisdictions": True},
        {"clause": "termination", "label": "Termination with notice period", "all_jurisdictions": True},
        {"clause": "governing_law", "label": "Governing law", "all_jurisdictions": True},
    ],
    "nda": [
        {"clause": "parties", "label": "Parties and legal names", "all_jurisdictions": True},
        {"clause": "definition", "label": "Definition of confidential information", "all_jurisdictions": True},
        {"clause": "obligations", "label": "Obligations of receiving party", "all_jurisdictions": True},
        {"clause": "exceptions", "label": "Exceptions to confidentiality", "all_jurisdictions": True},
        {"clause": "term", "label": "Term and duration", "all_jurisdictions": True},
        {"clause": "return_destruction", "label": "Return or destruction of materials", "all_jurisdictions": True},
        {"clause": "governing_law", "label": "Governing law", "all_jurisdictions": True},
    ],
    "msa": [
        {"clause": "parties", "label": "Parties and legal names", "all_jurisdictions": True},
        {"clause": "master_terms", "label": "Master terms and conditions", "all_jurisdictions": True},
        {"clause": "sow_framework", "label": "SOW attachment framework", "all_jurisdictions": True},
        {"clause": "payment_terms", "label": "General payment terms", "all_jurisdictions": True},
        {"clause": "ip_assignment", "label": "IP assignment (default for all SOWs)", "all_jurisdictions": True},
        {"clause": "confidentiality", "label": "Confidentiality", "all_jurisdictions": True},
        {"clause": "liability_cap", "label": "Liability limitation", "all_jurisdictions": True},
        {"clause": "termination", "label": "Termination of master and individual SOWs", "all_jurisdictions": True},
        {"clause": "governing_law", "label": "Governing law", "all_jurisdictions": True},
        {"clause": "amendments", "label": "Amendment process (written only)", "all_jurisdictions": True},
    ],
}

JURISDICTION_EXTRAS = {
    "eu": [
        {"clause": "dpa", "label": "GDPR Data Processing Addendum (Art. 28)", "condition": "personal_data"},
        {"clause": "right_to_withdraw", "label": "Right to withdraw (14-day, B2C only)", "condition": "b2c"},
        {"clause": "ip_deed", "label": "Separate IP assignment deed", "condition": "always"},
    ],
    "dach": [
        {"clause": "dpa", "label": "DSGVO Data Processing Addendum", "condition": "personal_data"},
        {"clause": "nutzungsrechte", "label": "Explicit Nutzungsrechte (usage rights) transfer", "condition": "always"},
        {"clause": "schriftformklausel", "label": "Schriftformklausel (written form clause)", "condition": "always"},
        {"clause": "kuendigungsfristen", "label": "Statutory notice periods (Kuendigungsfristen)", "condition": "always"},
        {"clause": "moral_rights", "label": "Acknowledgment of Urheberpersoernlichkeitsrecht (cannot be transferred)", "condition": "always"},
    ],
    "uk": [
        {"clause": "uk_gdpr", "label": "UK GDPR compliance for data processing", "condition": "personal_data"},
        {"clause": "cdpa", "label": "CDPA 1988 IP provisions", "condition": "always"},
    ],
    "us-delaware": [
        {"clause": "work_for_hire", "label": "Work-for-hire declaration (Copyright Act 101)", "condition": "always"},
        {"clause": "esign_compliance", "label": "ESIGN Act / UETA compliance for e-signatures", "condition": "always"},
    ],
}


def check_contract(data: dict, jurisdiction: str, contract_type: str) -> dict:
    """Check contract against required clauses."""
    clauses_present = data.get("clauses", {})
    metadata = data.get("metadata", {})
    involves_personal_data = metadata.get("personal_data", False)
    is_b2c = metadata.get("b2c", False)

    # Check base clauses
    base_required = REQUIRED_CLAUSES.get(contract_type, REQUIRED_CLAUSES["fixed-price"])
    results = []
    passed = 0

    for req in base_required:
        present = bool(clauses_present.get(req["clause"]))
        if present:
            passed += 1
        results.append({
            "clause": req["clause"],
            "label": req["label"],
            "present": present,
            "required": True,
            "source": "base",
        })

    # Check jurisdiction extras
    extras = JURISDICTION_EXTRAS.get(jurisdiction, [])
    for extra in extras:
        applicable = True
        if extra["condition"] == "personal_data" and not involves_personal_data:
            applicable = False
        if extra["condition"] == "b2c" and not is_b2c:
            applicable = False

        if applicable:
            present = bool(clauses_present.get(extra["clause"]))
            if present:
                passed += 1
            results.append({
                "clause": extra["clause"],
                "label": extra["label"],
                "present": present,
                "required": True,
                "source": f"jurisdiction:{jurisdiction}",
            })

    # Check for unfilled placeholders
    placeholder_warnings = []
    for key, value in clauses_present.items():
        if isinstance(value, str) and "[" in value and "]" in value:
            placeholder_warnings.append({
                "clause": key,
                "warning": f"Contains unfilled placeholder: {value[:80]}",
            })

    total_required = len(results)
    missing = [r for r in results if not r["present"]]
    compliance_pct = (passed / total_required * 100) if total_required > 0 else 0

    if compliance_pct >= 95:
        status = "COMPLIANT"
    elif compliance_pct >= 75:
        status = "NEEDS_REVIEW"
    else:
        status = "NON_COMPLIANT"

    return {
        "contract_type": contract_type,
        "jurisdiction": jurisdiction,
        "status": status,
        "compliance_pct": round(compliance_pct, 1),
        "clauses_checked": total_required,
        "clauses_present": passed,
        "clauses_missing": len(missing),
        "results": results,
        "missing_clauses": missing,
        "placeholder_warnings": placeholder_warnings,
        "recommendations": _generate_recommendations(missing, jurisdiction, placeholder_warnings),
    }


def _generate_recommendations(missing: list, jurisdiction: str, placeholders: list) -> list:
    """Generate recommendations."""
    recs = []
    for m in missing:
        recs.append({
            "priority": "HIGH",
            "action": f"Add missing clause: {m['label']}",
            "source": m["source"],
        })
    if placeholders:
        recs.append({
            "priority": "CRITICAL",
            "action": f"{len(placeholders)} unfilled placeholder(s) found. Fill all [BRACKETED] values before sending.",
            "source": "validation",
        })
    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 60)
    lines.append(f"CONTRACT CLAUSE CHECKER")
    lines.append("=" * 60)

    lines.append(f"\nType: {result['contract_type']}")
    lines.append(f"Jurisdiction: {result['jurisdiction']}")
    lines.append(f"Status: {result['status']}")
    lines.append(f"Compliance: {result['compliance_pct']}% ({result['clauses_present']}/{result['clauses_checked']})")

    lines.append(f"\n--- Clause Checklist ---")
    for r in result["results"]:
        status = "[OK]  " if r["present"] else "[MISS]"
        lines.append(f"  {status} {r['label']}")

    if result["placeholder_warnings"]:
        lines.append(f"\n--- Placeholder Warnings ---")
        for pw in result["placeholder_warnings"]:
            lines.append(f"  [WARN] {pw['clause']}: {pw['warning']}")

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

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


def main():
    parser = argparse.ArgumentParser(
        description="Validate contract against required clauses for jurisdiction and type."
    )
    parser.add_argument("input_file", help="JSON file with contract clauses and metadata")
    parser.add_argument("--jurisdiction", choices=["us-delaware", "eu", "uk", "dach"],
                        default="us-delaware", help="Jurisdiction (default: us-delaware)")
    parser.add_argument("--type", choices=["fixed-price", "hourly", "retainer", "nda", "msa"],
                        default="fixed-price", help="Contract type (default: fixed-price)")
    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 = check_contract(data, args.jurisdiction, args.type)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Contract Comparison Analyzer

Compare two contract versions and identify differences in key clauses,
payment terms, and risk areas. Useful for reviewing redlines and
tracking changes between negotiation rounds.

Usage:
    python contract_comparison_analyzer.py contract_v1.json contract_v2.json
    python contract_comparison_analyzer.py contract_v1.json contract_v2.json --json
"""

import argparse
import json
import sys


KEY_CLAUSES = [
    "parties", "scope_of_work", "deliverables", "acceptance_criteria",
    "payment_terms", "payment_schedule", "ip_assignment", "pre_existing_ip",
    "confidentiality", "confidentiality_term", "liability_cap",
    "termination_for_cause", "termination_for_convenience", "notice_period",
    "governing_law", "dispute_resolution", "force_majeure",
    "change_order", "warranties", "indemnification", "non_compete",
    "non_solicitation", "dpa", "insurance",
]

RISK_INDICATORS = {
    "liability_cap": {"field": "liability_cap", "risk": "Liability cap changed -- review exposure"},
    "indemnification": {"field": "indemnification", "risk": "Indemnification terms changed -- may shift risk"},
    "termination_for_convenience": {"field": "termination_for_convenience", "risk": "Termination convenience changed -- check notice and financial terms"},
    "ip_assignment": {"field": "ip_assignment", "risk": "IP assignment changed -- verify ownership is clear"},
    "non_compete": {"field": "non_compete", "risk": "Non-compete added or modified -- check scope and duration"},
    "governing_law": {"field": "governing_law", "risk": "Governing law changed -- may affect enforceability"},
}


def compare_contracts(v1: dict, v2: dict) -> dict:
    """Compare two contract versions."""
    v1_clauses = v1.get("clauses", {})
    v2_clauses = v2.get("clauses", {})
    v1_meta = v1.get("metadata", {})
    v2_meta = v2.get("metadata", {})

    changes = []
    additions = []
    removals = []
    unchanged = []

    all_keys = set(list(v1_clauses.keys()) + list(v2_clauses.keys()))

    for key in sorted(all_keys):
        v1_val = v1_clauses.get(key)
        v2_val = v2_clauses.get(key)

        if v1_val is None and v2_val is not None:
            additions.append({
                "clause": key,
                "new_value": _summarize(v2_val),
                "is_key_clause": key in KEY_CLAUSES,
            })
        elif v1_val is not None and v2_val is None:
            removals.append({
                "clause": key,
                "old_value": _summarize(v1_val),
                "is_key_clause": key in KEY_CLAUSES,
            })
        elif v1_val != v2_val:
            changes.append({
                "clause": key,
                "old_value": _summarize(v1_val),
                "new_value": _summarize(v2_val),
                "is_key_clause": key in KEY_CLAUSES,
            })
        else:
            unchanged.append(key)

    # Risk assessment
    risk_flags = []
    for change in changes:
        if change["clause"] in RISK_INDICATORS:
            ri = RISK_INDICATORS[change["clause"]]
            risk_flags.append({
                "clause": change["clause"],
                "risk": ri["risk"],
                "old_value": change["old_value"],
                "new_value": change["new_value"],
                "severity": "HIGH",
            })

    for removal in removals:
        if removal["is_key_clause"]:
            risk_flags.append({
                "clause": removal["clause"],
                "risk": f"Key clause '{removal['clause']}' was removed -- this may create exposure",
                "old_value": removal["old_value"],
                "new_value": "(removed)",
                "severity": "HIGH",
            })

    for addition in additions:
        if addition["clause"] in ["non_compete", "non_solicitation", "indemnification"]:
            risk_flags.append({
                "clause": addition["clause"],
                "risk": f"New clause '{addition['clause']}' was added -- review carefully",
                "old_value": "(not present)",
                "new_value": addition["new_value"],
                "severity": "MEDIUM",
            })

    return {
        "version_1": v1_meta.get("version", "v1"),
        "version_2": v2_meta.get("version", "v2"),
        "summary": {
            "total_clauses_compared": len(all_keys),
            "changes": len(changes),
            "additions": len(additions),
            "removals": len(removals),
            "unchanged": len(unchanged),
            "risk_flags": len(risk_flags),
        },
        "changes": changes,
        "additions": additions,
        "removals": removals,
        "risk_flags": risk_flags,
        "recommendations": _generate_recommendations(changes, additions, removals, risk_flags),
    }


def _summarize(value) -> str:
    """Summarize a clause value for display."""
    if isinstance(value, str):
        return value[:100] + "..." if len(value) > 100 else value
    elif isinstance(value, dict):
        return json.dumps(value)[:100]
    elif isinstance(value, list):
        return f"[{len(value)} items]"
    return str(value)


def _generate_recommendations(changes: list, additions: list,
                              removals: list, risks: list) -> list:
    """Generate recommendations."""
    recs = []
    if risks:
        recs.append({
            "priority": "HIGH",
            "recommendation": f"{len(risks)} risk flag(s) detected. Review each flagged clause before signing.",
        })
    if removals:
        key_removals = [r for r in removals if r["is_key_clause"]]
        if key_removals:
            recs.append({
                "priority": "HIGH",
                "recommendation": f"{len(key_removals)} key clause(s) removed: {', '.join(r['clause'] for r in key_removals)}. Ensure this is intentional.",
            })
    if not changes and not additions and not removals:
        recs.append({
            "priority": "INFO",
            "recommendation": "No differences found between versions.",
        })
    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 60)
    lines.append(f"CONTRACT COMPARISON: {result['version_1']} vs {result['version_2']}")
    lines.append("=" * 60)

    s = result["summary"]
    lines.append(f"\nClauses Compared: {s['total_clauses_compared']}")
    lines.append(f"Changes: {s['changes']}, Additions: {s['additions']}, Removals: {s['removals']}, Unchanged: {s['unchanged']}")
    lines.append(f"Risk Flags: {s['risk_flags']}")

    if result["changes"]:
        lines.append(f"\n--- Changes ---")
        for c in result["changes"]:
            key_marker = " [KEY]" if c["is_key_clause"] else ""
            lines.append(f"  {c['clause']}{key_marker}:")
            lines.append(f"    OLD: {c['old_value']}")
            lines.append(f"    NEW: {c['new_value']}")

    if result["additions"]:
        lines.append(f"\n--- Additions ---")
        for a in result["additions"]:
            key_marker = " [KEY]" if a["is_key_clause"] else ""
            lines.append(f"  + {a['clause']}{key_marker}: {a['new_value']}")

    if result["removals"]:
        lines.append(f"\n--- Removals ---")
        for r in result["removals"]:
            key_marker = " [KEY]" if r["is_key_clause"] else ""
            lines.append(f"  - {r['clause']}{key_marker}: {r['old_value']}")

    if result["risk_flags"]:
        lines.append(f"\n--- Risk Flags ---")
        for rf in result["risk_flags"]:
            lines.append(f"  [{rf['severity']}] {rf['clause']}: {rf['risk']}")

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

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


def main():
    parser = argparse.ArgumentParser(
        description="Compare two contract versions and identify differences and risk areas."
    )
    parser.add_argument("file_v1", help="JSON file with first contract version")
    parser.add_argument("file_v2", help="JSON file with second contract version")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")

    args = parser.parse_args()

    try:
        with open(args.file_v1, "r") as f:
            v1 = json.load(f)
        with open(args.file_v2, "r") as f:
            v2 = json.load(f)
    except FileNotFoundError as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    result = compare_contracts(v1, v2)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Proposal Cost Estimator

Generate a project cost estimate with phase breakdown, payment schedule,
and margin analysis. Supports multiple billing models and currencies.

Usage:
    python proposal_cost_estimator.py --hourly-rate 150 --hours 200 --phases 4
    python proposal_cost_estimator.py --hourly-rate 150 --hours 200 --phases 4 --json
"""

import argparse
import json
import math
import sys


DEFAULT_PHASE_NAMES = [
    "Discovery & Planning",
    "Development",
    "Testing & QA",
    "Launch & Handoff",
    "Post-Launch Support",
]

DEFAULT_PHASE_WEIGHTS = [0.10, 0.50, 0.20, 0.15, 0.05]

PAYMENT_SCHEDULES = {
    "milestone": {
        "description": "Milestone-based (recommended for >$10K)",
        "schedule": [
            {"milestone": "Contract signing", "percentage": 50},
            {"milestone": "Beta delivery", "percentage": 25},
            {"milestone": "Final acceptance", "percentage": 25},
        ],
    },
    "monthly": {
        "description": "Monthly invoicing (recommended for hourly/retainer)",
        "schedule": [
            {"milestone": "Monthly invoice", "percentage": "pro-rata"},
        ],
    },
    "phased": {
        "description": "Per-phase payment (recommended for multi-phase projects)",
        "schedule": [],  # Generated dynamically
    },
}


def estimate_cost(hourly_rate: float, hours: float, num_phases: int,
                  margin: float, currency: str) -> dict:
    """Generate project cost estimate."""
    base_cost = hourly_rate * hours
    margin_amount = base_cost * (margin / 100.0)
    total_cost = base_cost + margin_amount

    # Phase breakdown
    phases = []
    phase_names = DEFAULT_PHASE_NAMES[:num_phases]
    phase_weights = DEFAULT_PHASE_WEIGHTS[:num_phases]

    # Normalize weights
    weight_sum = sum(phase_weights)
    phase_weights = [w / weight_sum for w in phase_weights]

    for i, (name, weight) in enumerate(zip(phase_names, phase_weights)):
        phase_hours = round(hours * weight, 1)
        phase_cost = round(total_cost * weight, 2)
        phases.append({
            "phase": i + 1,
            "name": name,
            "weight_pct": round(weight * 100, 1),
            "estimated_hours": phase_hours,
            "estimated_cost": phase_cost,
        })

    # Payment schedule options
    milestone_schedule = []
    milestone_schedule.append({
        "event": "Contract signing (50%)",
        "amount": round(total_cost * 0.50, 2),
    })
    if num_phases >= 3:
        milestone_schedule.append({
            "event": "Beta delivery (25%)",
            "amount": round(total_cost * 0.25, 2),
        })
        milestone_schedule.append({
            "event": "Final acceptance (25%)",
            "amount": round(total_cost * 0.25, 2),
        })
    else:
        milestone_schedule.append({
            "event": "Final delivery (50%)",
            "amount": round(total_cost * 0.50, 2),
        })

    phased_schedule = []
    for p in phases:
        phased_schedule.append({
            "event": f"{p['name']} completion",
            "amount": p["estimated_cost"],
        })

    # Estimated duration (assuming 6 productive hours per day, 5 days per week)
    productive_hours_per_week = 30
    estimated_weeks = math.ceil(hours / productive_hours_per_week)

    # Risk buffer
    risk_buffer_hours = round(hours * 0.15, 1)
    risk_buffer_cost = round(risk_buffer_hours * hourly_rate, 2)

    return {
        "inputs": {
            "hourly_rate": hourly_rate,
            "total_hours": hours,
            "num_phases": num_phases,
            "margin_pct": margin,
            "currency": currency,
        },
        "cost_summary": {
            "base_cost": round(base_cost, 2),
            "margin_amount": round(margin_amount, 2),
            "total_project_cost": round(total_cost, 2),
            "effective_hourly_rate": round(total_cost / hours, 2),
            "currency": currency,
        },
        "phase_breakdown": phases,
        "timeline": {
            "estimated_weeks": estimated_weeks,
            "productive_hours_per_week": productive_hours_per_week,
            "total_hours": hours,
        },
        "payment_options": {
            "milestone": milestone_schedule,
            "phased": phased_schedule,
        },
        "risk_buffer": {
            "buffer_hours": risk_buffer_hours,
            "buffer_cost": risk_buffer_cost,
            "total_with_buffer": round(total_cost + risk_buffer_cost, 2),
            "note": "15% contingency for scope changes and unforeseen complexity",
        },
        "recommendations": _generate_recommendations(total_cost, hours, num_phases),
    }


def _generate_recommendations(total_cost: float, hours: float, phases: int) -> list:
    """Generate recommendations for proposal."""
    recs = []
    if total_cost > 50000:
        recs.append({
            "priority": "HIGH",
            "recommendation": "Project over $50K -- use milestone-based payments and include legal review.",
        })
    if total_cost > 10000:
        recs.append({
            "priority": "MEDIUM",
            "recommendation": "Use milestone payments over net-30 to reduce cash flow risk.",
        })
    if hours > 500:
        recs.append({
            "priority": "MEDIUM",
            "recommendation": "Large project -- consider phased contracting with go/no-go gates between phases.",
        })
    recs.append({
        "priority": "MEDIUM",
        "recommendation": "Include a change order clause for scope changes with pricing mechanism.",
    })
    recs.append({
        "priority": "LOW",
        "recommendation": "Present the client with 2-3 pricing options (basic, recommended, premium) to avoid a yes/no decision.",
    })
    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    cur = result["inputs"]["currency"]
    lines.append("=" * 60)
    lines.append("PROPOSAL COST ESTIMATOR")
    lines.append("=" * 60)

    cs = result["cost_summary"]
    lines.append(f"\n--- Cost Summary ---")
    lines.append(f"Hourly Rate:           {cur} {result['inputs']['hourly_rate']:>10,.2f}")
    lines.append(f"Total Hours:           {result['inputs']['total_hours']:>10,.1f}")
    lines.append(f"Base Cost:             {cur} {cs['base_cost']:>10,.2f}")
    lines.append(f"Margin ({result['inputs']['margin_pct']}%):          {cur} {cs['margin_amount']:>10,.2f}")
    lines.append(f"Total Project Cost:    {cur} {cs['total_project_cost']:>10,.2f}")
    lines.append(f"Effective Rate:        {cur} {cs['effective_hourly_rate']:>10,.2f}/hr")

    lines.append(f"\n--- Phase Breakdown ---")
    lines.append(f"{'Phase':<25} {'Hours':>8} {'Cost':>12} {'%':>6}")
    for p in result["phase_breakdown"]:
        lines.append(f"{p['name']:<25} {p['estimated_hours']:>8.1f} {cur} {p['estimated_cost']:>8,.2f} {p['weight_pct']:>5.1f}%")

    tl = result["timeline"]
    lines.append(f"\n--- Timeline ---")
    lines.append(f"Estimated Duration: {tl['estimated_weeks']} weeks")
    lines.append(f"Productive Hours/Week: {tl['productive_hours_per_week']}")

    rb = result["risk_buffer"]
    lines.append(f"\n--- Risk Buffer ---")
    lines.append(f"Buffer Hours: {rb['buffer_hours']}")
    lines.append(f"Buffer Cost: {cur} {rb['buffer_cost']:,.2f}")
    lines.append(f"Total with Buffer: {cur} {rb['total_with_buffer']:,.2f}")

    lines.append(f"\n--- Payment Options ---")
    lines.append(f"\n  Milestone-based:")
    for m in result["payment_options"]["milestone"]:
        lines.append(f"    {m['event']:<35} {cur} {m['amount']:>10,.2f}")

    lines.append(f"\n  Per-phase:")
    for m in result["payment_options"]["phased"]:
        lines.append(f"    {m['event']:<35} {cur} {m['amount']:>10,.2f}")

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

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


def main():
    parser = argparse.ArgumentParser(
        description="Generate project cost estimate with phase breakdown and payment schedule."
    )
    parser.add_argument("--hourly-rate", type=float, required=True,
                        help="Hourly rate in dollars")
    parser.add_argument("--hours", type=float, required=True,
                        help="Estimated total hours")
    parser.add_argument("--phases", type=int, default=3,
                        help="Number of project phases (default: 3, max: 5)")
    parser.add_argument("--margin", type=float, default=20,
                        help="Desired profit margin percentage (default: 20)")
    parser.add_argument("--currency", default="USD",
                        help="Currency code (default: USD)")
    parser.add_argument("--json", action="store_true",
                        help="Output results as JSON")

    args = parser.parse_args()

    if args.hourly_rate <= 0:
        print("Error: --hourly-rate must be positive.", file=sys.stderr)
        sys.exit(1)
    if args.hours <= 0:
        print("Error: --hours must be positive.", file=sys.stderr)
        sys.exit(1)

    num_phases = max(1, min(5, args.phases))

    result = estimate_cost(args.hourly_rate, args.hours, num_phases,
                           args.margin, args.currency)

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


if __name__ == "__main__":
    main()