debtpilot 0.1.0__py3-none-any.whl

debtpilot_core/cli.py

@@ -0,0 +1,682 @@
+"""
+DebtPilot CLI
+Usage: debtpilot <command> [options]
+"""
+
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+from typing import List
+
+try:
+    from rich.console import Console
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich import box
+    HAS_RICH = True
+except ImportError:
+    HAS_RICH = False
+
+from debtpilot_core import database as db
+from debtpilot_core import linter, scanner, scorer
+
+console = Console() if HAS_RICH else None
+
+GRADE_COLORS = {"A": "green", "B": "yellow", "C": "orange3", "D": "red", "F": "bold red"}
+GRADE_EMOJI  = {"A": "✅", "B": "⚠️ ", "C": "🟠", "D": "🔴", "F": "💀"}
+
+
+def _cprint(msg, style=""):
+    if console:
+        console.print(msg, style=style)
+    else:
+        print(msg)
+
+
+def _bar(score: float, width: int = 20) -> str:
+    filled = int(score / 100 * width)
+    return "█" * filled + "░" * (width - filled)
+
+
+def _grade_style(grade: str) -> str:
+    return GRADE_COLORS.get(grade, "white")
+
+
+def cmd_scan(args) -> int:
+    db.ensure_db()
+    target = Path(args.path).resolve()
+
+    if target.is_file():
+        files = [str(target)]
+    elif target.is_dir():
+        exts = {".py", ".js", ".jsx", ".ts", ".tsx", ".mjs"}
+        ignored = {
+            "node_modules", ".git", "__pycache__", ".venv", "venv",
+            "dist", "build", ".mypy_cache", ".pytest_cache", ".tox",
+            "site-packages", "migrations",
+        }
+        files = []
+        import re
+        backup_pattern = re.compile(r'_\d{14}\.py$')
+        for f in target.rglob("*"):
+            if f.suffix in exts and not any(p in ignored for p in f.parts):
+                if not backup_pattern.search(f.name):
+                    files.append(str(f))
+    else:
+        _cprint(f"Path not found: {args.path}")
+        return 1
+
+    if not files:
+        _cprint("No supported files found.")
+        return 0
+
+    _cprint(f"\n[bold]DebtPilot scan[/bold] — {len(files)} file(s)\n" if HAS_RICH
+            else f"\nDebtPilot scan — {len(files)} file(s)\n")
+
+    results = []
+    for fp in files:
+        lint_data = linter.lint_file(fp)
+        all_issues = []
+        for issues in lint_data.values():
+            if isinstance(issues, list) and issues and isinstance(issues[0], dict) and "line" in issues[0]:
+                all_issues.extend(issues)
+        todos = lint_data.get("todos", [])
+        scan_data = scanner.scan_file(fp, todos)
+        score_data = scorer.compute_score(
+            churn=scan_data["churn"], complexity=scan_data["complexity"],
+            lint_issues=all_issues, todos=scan_data["todos"],
+            staleness_days=scan_data["staleness_days"],
+        )
+        db.upsert_score(fp, score_data)
+        if scan_data["churn"]["commits"] > 0:
+            db.upsert_churn(fp, scan_data["churn"]["commits"],
+                            scan_data["churn"]["authors"], scan_data["churn"]["last_commit"])
+        for tool, issues in lint_data.items():
+            if tool != "todos" and issues:
+                db.upsert_lint(fp, tool, issues)
+        if scan_data["todos"]:
+            db.upsert_todos(fp, scan_data["todos"])
+
+        results.append((fp, score_data))
+        grade = score_data["grade"]
+        total = score_data["total"]
+
+        if HAS_RICH:
+            console.print(
+                f"  {GRADE_EMOJI[grade]} [bold]{Path(fp).name:<40}[/bold] "
+                f"[{_grade_style(grade)}]{total:>5.1f}[/{_grade_style(grade)}] "
+                f"[dim]{score_data['label']}[/dim]"
+            )
+        else:
+            print(f"  [{grade}] {Path(fp).name:<40} {total:>5.1f}  {score_data['label']}")
+
+    if len(results) > 1:
+        avg = sum(s["total"] for _, s in results) / len(results)
+        worst = max(results, key=lambda x: x[1]["total"])
+        _cprint(f"\n  Average debt score : {avg:.1f}")
+        _cprint(f"  Highest risk file  : {Path(worst[0]).name}  ({worst[1]['total']:.1f})\n")
+
+    return 0
+
+
+def cmd_report(args) -> int:
+    db.ensure_db()
+    scores = db.get_all_scores(limit=args.limit or 20, min_score=args.min_score or 0)
+
+    if not scores:
+        _cprint("No data yet. Run: debtpilot scan .")
+        return 0
+
+    if HAS_RICH:
+        table = Table(title="⚡ Debt Report", box=box.ROUNDED, highlight=True)
+        table.add_column("Grade", justify="center", width=6)
+        table.add_column("File", style="cyan", min_width=35)
+        table.add_column("Score", justify="right", width=7)
+        table.add_column("Churn", justify="right", width=7)
+        table.add_column("Complexity", justify="right", width=11)
+        table.add_column("Lint", justify="right", width=6)
+        table.add_column("TODOs", justify="right", width=7)
+        for row in scores:
+            g = scorer.score_to_grade(row["score"])[0]
+            table.add_row(
+                f"[{_grade_style(g)}]{g}[/{_grade_style(g)}]",
+                Path(row["filepath"]).name,
+                f"[{_grade_style(g)}]{row['score']:.1f}[/{_grade_style(g)}]",
+                f"{row.get('churn_score', 0):.0f}",
+                f"{row.get('complexity_score', 0):.0f}",
+                f"{row.get('lint_score', 0):.0f}",
+                f"{row.get('todo_score', 0):.0f}",
+            )
+        console.print(table)
+    else:
+        print(f"\n{'Grade':<6} {'File':<40} {'Score':>6}")
+        print("-" * 55)
+        for row in scores:
+            g = scorer.score_to_grade(row["score"])[0]
+            print(f"  [{g}]  {Path(row['filepath']).name:<38} {row['score']:>6.1f}")
+
+    stats = db.get_stats()
+    _cprint(f"\n  📊 {stats['files_tracked']} files tracked  |  avg score {stats['avg_debt_score']:.1f}"
+            f"  |  {stats['active_alerts']} active alert(s)  |  {stats['stale_todos']} stale TODOs")
+    return 0
+
+
+def cmd_file(args) -> int:
+    db.ensure_db()
+    fp = str(Path(args.filepath).resolve())
+    score = db.get_latest_score(fp)
+
+    if not score:
+        _cprint(f"No data for {fp}. Run: debtpilot scan {args.filepath}")
+        return 1
+
+    g, label = scorer.score_to_grade(score["score"])
+    todos = db.get_todos(fp)
+
+    if HAS_RICH:
+        lines = ["[bold]Sub-scores[/bold]"]
+        for key, lbl in [("churn_score", "Churn"), ("complexity_score", "Complexity"),
+                          ("lint_score", "Lint"), ("todo_score", "TODOs"), ("staleness_score", "Staleness")]:
+            v = score.get(key, 0)
+            lines.append(f"  {lbl:<12} {_bar(v, 18)} {v:>5.1f}")
+        if todos:
+            lines.append(f"\n[bold]TODOs ({len(todos)})[/bold]")
+            for t in sorted(todos, key=lambda x: -x.get("age_days", 0))[:5]:
+                age = t.get("age_days", 0)
+                color = "red" if age > 90 else "yellow" if age > 30 else "white"
+                lines.append(f"  [{color}]L{t['line']:<5} {age:>3}d  {t.get('tag','TODO')}: {t.get('text','')[:60]}[/{color}]")
+        fake = {f"{k}_score": score.get(f"{k}_score", 0)
+                for k in ["churn","complexity","lint","todo","staleness"]}
+        recs = scorer.top_recommendations(fake)
+        if recs:
+            lines.append("\n[bold]Recommendations[/bold]")
+            for r in recs:
+                lines.append(f"  • {r}")
+        title = f"{GRADE_EMOJI[g]}  [bold]{Path(fp).name}[/bold]   [{_grade_style(g)}]{label} ({score['score']:.1f})[/{_grade_style(g)}]"
+        console.print(Panel("\n".join(lines), title=title, border_style=_grade_style(g)))
+    else:
+        print(f"\n[{g}] {Path(fp).name}  score={score['score']:.1f}  {label}")
+        for key, lbl in [("churn_score","Churn"),("complexity_score","Complexity"),
+                          ("lint_score","Lint"),("todo_score","TODOs")]:
+            print(f"  {lbl}: {score.get(key,0):.0f}")
+    return 0
+
+
+def cmd_alerts(args) -> int:
+    db.ensure_db()
+    alerts = db.get_alerts(dismissed=False)
+    if not alerts:
+        _cprint("✅  No active alerts.")
+        return 0
+    _cprint(f"\n🔔  {len(alerts)} active alert(s)\n")
+    for a in alerts:
+        ts = time.strftime("%Y-%m-%d %H:%M", time.localtime(a["created_at"]))
+        print(f"  #{a['id']}  {a['alert_type']:<16}  {Path(a['filepath']).name:<30}  score={a['score']:.1f}  {ts}")
+        print(f"    {a['message']}")
+    return 0
+
+
+def cmd_dismiss(args) -> int:
+    db.ensure_db()
+    db.dismiss_alert(args.alert_id)
+    _cprint(f"Alert #{args.alert_id} dismissed.")
+    return 0
+
+
+def cmd_start(args) -> int:
+    try:
+        from debtpilot_core.daemon import main_daemon
+    except ImportError as e:
+        _cprint(f"Daemon dependencies missing: {e}")
+        _cprint("Install with: pip install \"debtpilot[full]\"")
+        return 1
+    project = str(Path(args.dir or ".").resolve())
+    port = args.port or 57017
+    _cprint(f"🚀 Starting DebtPilot daemon — watching {project}  (ws://127.0.0.1:{port})")
+    _cprint("   Press Ctrl+C to stop.\n")
+    main_daemon(project, port)
+    return 0
+
+
+def cmd_todos(args) -> int:
+    db.ensure_db()
+    todos = db.get_todos(min_age_days=args.min_age or 0)
+    if not todos:
+        _cprint("No TODOs found.")
+        return 0
+    _cprint(f"\n📌 {len(todos)} TODO(s)\n")
+    for t in todos:
+        age = t.get("age_days", 0)
+        print(f"  {age:>4}d  {t.get('tag','TODO'):<6}  {Path(t['filepath']).name}:{t['line']}  {t.get('text','')[:70]}")
+    return 0
+
+
+def cmd_clean(args) -> int:
+    days = args.days or 90
+    db.clear_old_data(days)
+    _cprint(f"Cleaned data older than {days} days.")
+    return 0
+
+def cmd_dashboard(args) -> int:
+    from debtpilot_core.dashboard import generate_dashboard
+    db.ensure_db()
+    output = generate_dashboard(args.output)
+    _cprint(f"✅ Dashboard generated: [bold]{output}[/bold]" if HAS_RICH else f"Dashboard generated: {output}")
+    _cprint("   Open in your browser to view.")
+    return 0
+
+
+def cmd_ai(args) -> int:
+    from debtpilot_core.ai_advisor import analyze_file
+    db.ensure_db()
+    fp = str(Path(args.filepath).resolve())
+    score = db.get_latest_score(fp)
+    if not score:
+        _cprint(f"No scan data for {fp}. Run: debtpilot scan {args.filepath}")
+        return 1
+
+    _cprint(f"\n🤖 AI analysing [bold]{Path(fp).name}[/bold]...\n" if HAS_RICH
+            else f"\nAI analysing {Path(fp).name}...")
+
+    lint = db.get_lint(fp)
+    all_issues = []
+    for l in lint[:1]:
+        issues = l.get("issues", [])
+        if isinstance(issues, str):
+            import json as _json
+            issues = _json.loads(issues)
+        all_issues.extend(issues)
+
+    todos = db.get_todos(fp)
+    from debtpilot_core.scanner import analyze_complexity
+    complexity = analyze_complexity(fp)
+
+    result = analyze_file(fp, score, all_issues, todos, complexity)
+
+    if "error" in result and not result.get("fixes"):
+        _cprint(f"[red]{result['error']}[/red]" if HAS_RICH else result["error"])
+        return 1
+
+    if HAS_RICH:
+        from rich.panel import Panel
+        risk_colors = {"LOW":"green","MEDIUM":"yellow","HIGH":"orange3","CRITICAL":"bold red"}
+        risk = result.get("risk_level","UNKNOWN")
+        console.print(Panel(
+            f"[bold]Risk Level:[/bold] [{risk_colors.get(risk,'white')}]{risk}[/{risk_colors.get(risk,'white')}]\n\n"
+            f"{result.get('summary','')}",
+            title="🤖 AI Summary", border_style="blue"
+        ))
+        fixes = result.get("fixes", [])
+        if fixes:
+            console.print("\n[bold]Suggested Fixes:[/bold]\n")
+            for i, fix in enumerate(fixes, 1):
+                console.print(f"  [bold cyan]{i}. {fix['title']}[/bold cyan]  [dim]({fix.get('effort','?')})[/dim]")
+                console.print(f"     [yellow]Problem:[/yellow] {fix['problem']}")
+                console.print(f"     [green]Solution:[/green] {fix['solution']}")
+                if fix.get("code_example"):
+                    console.print(f"     [dim]{fix['code_example'][:200]}[/dim]")
+                console.print()
+        actions = result.get("priority_actions", [])
+        if actions:
+            console.print("[bold]Priority Actions:[/bold]")
+            for a in actions:
+                console.print(f"  • {a}")
+        eta = result.get("estimated_fix_time")
+        if eta:
+            console.print(f"\n  [dim]Estimated fix time: {eta}[/dim]")
+    else:
+        print(f"\nRisk: {result.get('risk_level')}")
+        print(f"Summary: {result.get('summary')}\n")
+        for i, fix in enumerate(result.get("fixes", []), 1):
+            print(f"{i}. {fix['title']} ({fix.get('effort')})")
+            print(f"   Problem: {fix['problem']}")
+            print(f"   Solution: {fix['solution']}\n")
+    return 0
+
+
+def cmd_predict(args) -> int:
+    from debtpilot_core.predictor import predict_all, team_risk_summary
+    db.ensure_db()
+    predictions = predict_all(limit=args.limit)
+    summary = team_risk_summary()
+
+    if not predictions:
+        _cprint("No data yet. Run: debtpilot scan .")
+        return 0
+
+    _cprint(f"\n🔮 [bold]Bug Prediction Report[/bold] — {summary['total_files']} files analysed\n"
+            if HAS_RICH else f"\nBug Prediction — {summary['total_files']} files\n")
+    _cprint(f"   Critical: {summary['critical']}  High: {summary['high']}  "
+            f"Medium: {summary['medium']}  Low: {summary['low']}\n")
+
+    for p in predictions:
+        colors = {"CRITICAL":"bold red","HIGH":"red","MEDIUM":"orange3","LOW":"green"}
+        risk = p["risk_level"]
+        prob = p["probability"]
+        name = Path(p["filepath"]).name
+        drivers = " · ".join(p["drivers"][:2])
+        if HAS_RICH:
+            console.print(f"  [{colors.get(risk,'white')}]{risk:<10}[/{colors.get(risk,'white')}]"
+                          f"  {prob:>4}%  [cyan]{name:<40}[/cyan]  [dim]{drivers}[/dim]")
+        else:
+            print(f"  {risk:<10}  {prob:>4}%  {name:<40}  {drivers}")
+    return 0
+
+
+def cmd_digest(args) -> int:
+    from debtpilot_core.digest import send_digest, preview_digest
+    db.ensure_db()
+    project = args.project
+
+    if args.preview:
+        output = preview_digest(project_name=project)
+        _cprint(f"✅ Digest preview saved: [bold]{output}[/bold]" if HAS_RICH else f"Preview saved: {output}")
+        _cprint("   Open in your browser to view.")
+        return 0
+
+    if args.send:
+        _cprint("📧 Sending weekly digest...")
+        result = send_digest(project_name=project)
+        if result["success"]:
+            _cprint(f"✅ Sent to: {', '.join(result['sent_to'])}")
+        else:
+            _cprint(f"❌ Failed: {result['error']}")
+        return 0 if result.get("success") else 1
+
+    _cprint("Use --preview to generate a preview or --send to send the email.")
+    return 0
+
+
+def cmd_report_pdf(args) -> int:
+    from debtpilot_core.reporter import generate_pdf_report
+    db.ensure_db()
+    output = generate_pdf_report(output_path=args.output, project_name=args.project)
+    _cprint(f"✅ Report generated: [bold]{output}[/bold]" if HAS_RICH else f"Report saved: {output}")
+    _cprint("   Open in browser → Ctrl+P → Save as PDF")
+    return 0
+
+
+def cmd_hook(args) -> int:
+    from debtpilot_core.hooks import install_hook, uninstall_hook, hook_status
+    project = str(Path(".").resolve())
+
+    if args.install:
+        result = install_hook(project, threshold=args.threshold)
+        if result["success"]:
+            _cprint(f"✅ {result['message']}")
+        else:
+            _cprint(f"❌ {result['error']}")
+        return 0 if result["success"] else 1
+
+    if args.uninstall:
+        result = uninstall_hook(project)
+        _cprint(f"✅ {result.get('message','Done')}" if result["success"] else f"❌ {result['error']}")
+        return 0 if result["success"] else 1
+
+    if args.status:
+        status = hook_status(project)
+        if status["installed"]:
+            _cprint(f"✅ Hook installed — blocks commits with score > {status['threshold']}")
+        else:
+            _cprint("❌ Hook not installed. Run: debtpilot hook --install")
+        return 0
+
+    _cprint("Use --install, --uninstall, or --status")
+    return 0
+
+
+def cmd_config(args) -> int:
+    from debtpilot_core.ai_advisor import save_api_key
+    from debtpilot_core.digest import save_email_config, get_email_config
+
+    if args.gemini_key:
+        save_api_key(args.gemini_key)
+        _cprint("✅ Gemini API key saved.")
+
+    if args.gmail and args.gmail_password:
+        recipients = [r.strip() for r in args.recipients.split(",")] if args.recipients else []
+        save_email_config(args.gmail, args.gmail_password, recipients)
+        _cprint("✅ Gmail config saved.")
+    elif args.gmail or args.gmail_password:
+        _cprint("Provide both --gmail and --gmail-password together.")
+        return 1
+
+    if not any([args.gemini_key, args.gmail, args.gmail_password]):
+        config = get_email_config()
+        _cprint("\n[bold]Current Config:[/bold]" if HAS_RICH else "\nCurrent Config:")
+        _cprint(f"  Gemini key : {'✅ set' if config.get('gemini_api_key') else '❌ not set'}")
+        _cprint(f"  Gmail      : {config.get('gmail_address', '❌ not set')}")
+        _cprint(f"  Recipients : {', '.join(config.get('digest_recipients', [])) or '❌ not set'}")
+        _cprint("\nTo set:")
+        _cprint("  debtpilot config --gemini-key YOUR_KEY")
+        _cprint("  debtpilot config --gmail you@gmail.com --gmail-password YOUR_APP_PASSWORD --recipients team@company.com")
+
+    return 0
+
+def cmd_autostart(args) -> int:
+    from debtpilot_core.autostart import install_autostart, uninstall_autostart, autostart_status
+
+    if args.install:
+        project = str(Path(args.dir or ".").resolve())
+        result = install_autostart(project_dir=project, port=args.port)
+        _cprint(result["message"] if result["success"] else f"❌ {result['error']}")
+        return 0 if result["success"] else 1
+
+    if args.uninstall:
+        result = uninstall_autostart()
+        _cprint(result.get("message", "") if result["success"] else f"❌ {result['error']}")
+        return 0 if result["success"] else 1
+
+    if args.status:
+        status = autostart_status()
+        if status["installed"]:
+            _cprint("✅ Autostart installed")
+            _cprint(f"   Watching : {status.get('project_dir')}")
+            _cprint(f"   Port     : {status.get('port')}")
+            _cprint(f"   Next run : {status.get('next_run')}")
+        else:
+            _cprint("❌ Autostart not installed")
+            _cprint("   Run: debtpilot autostart --install")
+        return 0
+
+    _cprint("Use --install, --uninstall, or --status")
+    return 0
+
+
+def cmd_status(args) -> int:
+    from debtpilot_core.autostart import autostart_status
+    from debtpilot_core.hooks import hook_status
+    from debtpilot_core.ai_advisor import get_api_key
+    from debtpilot_core.digest import get_email_config
+    import socket
+
+    db.ensure_db()
+    stats = db.get_stats()
+    project = str(Path(".").resolve())
+
+    # Check if daemon is running
+    daemon_running = False
+    try:
+        s = socket.create_connection(("127.0.0.1", 57017), timeout=1)
+        s.close()
+        daemon_running = True
+    except Exception:
+        pass
+
+    auto = autostart_status()
+    hook = hook_status(project)
+    api_key = get_api_key()
+    email_config = get_email_config()
+
+    if HAS_RICH:
+        from rich.panel import Panel
+        from rich.table import Table
+        from rich import box
+
+        table = Table(box=box.SIMPLE, show_header=False, padding=(0, 2))
+        table.add_column("Item", style="bold")
+        table.add_column("Status")
+        table.add_column("Info", style="dim")
+
+        table.add_row(
+            "Daemon",
+            "[green]● Running[/green]" if daemon_running else "[red]● Stopped[/red]",
+            "ws://127.0.0.1:57017" if daemon_running else "Run: debtpilot start"
+        )
+        table.add_row(
+            "Autostart",
+            "[green]✅ Enabled[/green]" if auto.get("installed") else "[yellow]❌ Disabled[/yellow]",
+            auto.get("project_dir", "Run: debtpilot autostart --install")
+        )
+        table.add_row(
+            "Git Hook",
+            "[green]✅ Installed[/green]" if hook.get("installed") else "[yellow]❌ Not installed[/yellow]",
+            f"Threshold: {hook.get('threshold', 'N/A')}" if hook.get("installed") else "Run: debtpilot hook --install"
+        )
+        table.add_row(
+            "AI Advisor",
+            "[green]✅ Configured[/green]" if api_key else "[yellow]❌ Not configured[/yellow]",
+            "Gemini API key set" if api_key else "Run: debtpilot config --gemini-key KEY"
+        )
+        table.add_row(
+            "Email Digest",
+            "[green]✅ Configured[/green]" if email_config.get("gmail_address") else "[yellow]❌ Not configured[/yellow]",
+            email_config.get("gmail_address", "Run: debtpilot config --gmail")
+        )
+        table.add_row(
+            "Files Tracked",
+            f"[cyan]{stats['files_tracked']}[/cyan]",
+            f"avg score {stats['avg_debt_score']:.1f}"
+        )
+        table.add_row(
+            "Active Alerts",
+            f"[{'red' if stats['active_alerts'] > 0 else 'green'}]{stats['active_alerts']}[/{'red' if stats['active_alerts'] > 0 else 'green'}]",
+            "Run: debtpilot alerts" if stats["active_alerts"] > 0 else "All clear"
+        )
+        table.add_row(
+            "Stale TODOs",
+            f"[{'orange3' if stats['stale_todos'] > 0 else 'green'}]{stats['stale_todos']}[/{'orange3' if stats['stale_todos'] > 0 else 'green'}]",
+            "Run: debtpilot todos --min-age 30" if stats["stale_todos"] > 0 else "All clear"
+        )
+
+        console.print(Panel(table, title="⚡ DebtPilot Status", border_style="blue"))
+    else:
+        print("\n⚡ DebtPilot Status")
+        print("─" * 45)
+        print(f"  Daemon      : {'● Running' if daemon_running else '● Stopped'}")
+        print(f"  Autostart   : {'✅ Enabled' if auto.get('installed') else '❌ Disabled'}")
+        print(f"  Git Hook    : {'✅ Installed' if hook.get('installed') else '❌ Not installed'}")
+        print(f"  AI Advisor  : {'✅ Configured' if api_key else '❌ Not configured'}")
+        print(f"  Email       : {'✅ Configured' if email_config.get('gmail_address') else '❌ Not configured'}")
+        print(f"  Files       : {stats['files_tracked']}  (avg score {stats['avg_debt_score']:.1f})")
+        print(f"  Alerts      : {stats['active_alerts']}")
+        print(f"  Stale TODOs : {stats['stale_todos']}\n")
+    return 0
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="debtpilot",
+        description="DebtPilot — track technical debt before it blows up in production",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    p_scan = sub.add_parser("scan")
+    p_scan.add_argument("path", nargs="?", default=".")
+
+    p_report = sub.add_parser("report")
+    p_report.add_argument("--limit", "-n", type=int, default=20)
+    p_report.add_argument("--min-score", type=float, default=0)
+
+    p_file = sub.add_parser("file")
+    p_file.add_argument("filepath")
+
+    sub.add_parser("alerts")
+
+    p_dismiss = sub.add_parser("dismiss")
+    p_dismiss.add_argument("alert_id", type=int)
+
+    p_todos = sub.add_parser("todos")
+    p_todos.add_argument("--min-age", type=int, default=0)
+
+    p_start = sub.add_parser("start")
+    p_start.add_argument("--dir", default=".")
+    p_start.add_argument("--port", type=int, default=57017)
+
+    p_clean = sub.add_parser("clean")
+    p_clean.add_argument("--days", type=int, default=90)
+    # dashboard
+    p_dash = sub.add_parser("dashboard", help="Generate HTML dashboard")
+    p_dash.add_argument("--output", default="debtpilot_dashboard.html")
+
+    # ai
+    p_ai = sub.add_parser("ai", help="AI fix suggestions for a file")
+    p_ai.add_argument("filepath")
+
+    # predict
+    p_predict = sub.add_parser("predict", help="Bug prediction for all files")
+    p_predict.add_argument("--limit", type=int, default=10)
+
+    # digest
+    p_digest = sub.add_parser("digest", help="Weekly email digest")
+    p_digest.add_argument("--send", action="store_true")
+    p_digest.add_argument("--preview", action="store_true")
+    p_digest.add_argument("--project", default="My Project")
+
+    # report
+    p_pdf = sub.add_parser("report-pdf", help="Generate PDF report")
+    p_pdf.add_argument("--output", default="debtpilot_report.html")
+    p_pdf.add_argument("--project", default="My Project")
+
+    # hook
+    p_hook = sub.add_parser("hook", help="Install git pre-commit hook")
+    p_hook.add_argument("--install", action="store_true")
+    p_hook.add_argument("--uninstall", action="store_true")
+    p_hook.add_argument("--status", action="store_true")
+    p_hook.add_argument("--threshold", type=int, default=70)
+
+    # config
+    p_config = sub.add_parser("config", help="Configure API keys and email")
+    p_config.add_argument("--gemini-key", type=str)
+    p_config.add_argument("--gmail", type=str)
+    p_config.add_argument("--gmail-password", type=str)
+    p_config.add_argument("--recipients", type=str, help="Comma-separated emails")
+
+    # autostart
+    p_auto = sub.add_parser("autostart", help="Auto-start daemon on login")
+    p_auto.add_argument("--install", action="store_true")
+    p_auto.add_argument("--uninstall", action="store_true")
+    p_auto.add_argument("--status", action="store_true")
+    p_auto.add_argument("--dir", default=None)
+    p_auto.add_argument("--port", type=int, default=57017)
+
+    # status
+    sub.add_parser("status", help="Full health check of DebtPilot")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+
+    handlers = {
+        "scan": cmd_scan, "report": cmd_report, "file": cmd_file,
+        "alerts": cmd_alerts, "dismiss": cmd_dismiss, "todos": cmd_todos,
+        "start": cmd_start, "clean": cmd_clean,
+        "dashboard": cmd_dashboard, "ai": cmd_ai, "predict": cmd_predict,
+        "digest": cmd_digest, "report-pdf": cmd_report_pdf,
+        "hook": cmd_hook, "config": cmd_config,
+        "autostart": cmd_autostart,
+        "status": cmd_status,
+    }
+    fn = handlers.get(args.command)
+    if fn:
+        sys.exit(fn(args))
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()