PyPI - pawpy-cli - Versions diffs - 1.0.0b0__py3-none-any.whl - Mend

pawpy-cli 1.0.0b0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

pawpy/__init__.py +8 -0
pawpy/__main__.py +6 -0
pawpy/api/__init__.py +1 -0
pawpy/api/dashboard.py +183 -0
pawpy/api/rest.py +145 -0
pawpy/cli.py +341 -0
pawpy/config.py +60 -0
pawpy/data/__init__.py +6 -0
pawpy/data/common_passwords.py +139 -0
pawpy/data/updater.py +49 -0
pawpy/filters/__init__.py +1 -0
pawpy/filters/policy.py +59 -0
pawpy/generator/__init__.py +5 -0
pawpy/generator/core.py +314 -0
pawpy/generator/gpu.py +64 -0
pawpy/generator/hybrid.py +99 -0
pawpy/generator/sorter.py +136 -0
pawpy/mutations/__init__.py +20 -0
pawpy/mutations/dates.py +72 -0
pawpy/mutations/keyboard.py +99 -0
pawpy/mutations/leet.py +65 -0
pawpy/mutations/mangle.py +238 -0
pawpy/mutations/markov.py +125 -0
pawpy/mutations/templates.py +131 -0
pawpy/profile/__init__.py +5 -0
pawpy/profile/base.py +161 -0
pawpy/profile/multi.py +93 -0
pawpy/profile/plugins/__init__.py +55 -0
pawpy/profile/plugins/example.py +22 -0
pawpy/scoring/__init__.py +1 -0
pawpy/scoring/scorer.py +66 -0
pawpy/utils.py +135 -0
pawpy_cli-1.0.0b0.dist-info/METADATA +721 -0
pawpy_cli-1.0.0b0.dist-info/RECORD +37 -0
pawpy_cli-1.0.0b0.dist-info/WHEEL +5 -0
pawpy_cli-1.0.0b0.dist-info/entry_points.txt +2 -0
pawpy_cli-1.0.0b0.dist-info/top_level.txt +1 -0

pawpy/__init__.py ADDED Viewed

@@ -0,0 +1,8 @@
+"""Pawpy – The Most Powerful Educational Wordlist Generator.
+An open-source, terminal-based wordlist generator designed for
+authorised security testing, password audits, and educational purposes.
+"""
+__version__ = "1.0.0"
+__author__ = "Pawpy Dev"

pawpy/__main__.py ADDED Viewed

@@ -0,0 +1,6 @@
+"""Allow running as ``python -m pawpy``."""
+from pawpy.cli import main
+if __name__ == "__main__":
+    main()

pawpy/api/__init__.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ """API and web dashboard subsystem."""

pawpy/api/dashboard.py ADDED Viewed

@@ -0,0 +1,183 @@
+"""Web dashboard with WebSocket real-time logging.
+Provides a simple browser-based interface to trigger wordlist generation
+and watch progress in real time.
+"""
+from __future__ import annotations
+import json
+import logging
+from typing import Set
+logger = logging.getLogger("pawpy.dashboard")
+_connections: Set = set()
+# Minimal HTML for the dashboard
+_DASHBOARD_HTML = """<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Pawpy Dashboard</title>
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: #0d1117; color: #c9d1d9;
+            display: flex; min-height: 100vh;
+        }
+        .sidebar {
+            width: 280px; background: #161b22; padding: 20px;
+            border-right: 1px solid #30363d;
+        }
+        .sidebar h1 { color: #58a6ff; font-size: 1.5rem; margin-bottom: 20px; }
+        .sidebar label { display: block; color: #8b949e; margin: 12px 0 4px; font-size: 0.85rem; }
+        .sidebar input[type="file"], .sidebar input[type="text"],
+        .sidebar select { width: 100%; padding: 8px; background: #0d1117;
+            border: 1px solid #30363d; border-radius: 6px; color: #c9d1d9; }
+        .sidebar button { width: 100%; padding: 10px; margin-top: 16px;
+            background: #238636; color: #fff; border: none; border-radius: 6px;
+            cursor: pointer; font-size: 1rem; font-weight: bold; }
+        .sidebar button:hover { background: #2ea043; }
+        .sidebar .checkbox { display: flex; align-items: center; gap: 8px; margin: 6px 0; }
+        .sidebar .checkbox input { width: auto; }
+        .main { flex: 1; display: flex; flex-direction: column; }
+        .header { padding: 16px 20px; background: #161b22;
+            border-bottom: 1px solid #30363d; font-size: 1.1rem; }
+        .log-area { flex: 1; padding: 16px; overflow-y: auto; font-family: 'Fira Code', monospace;
+            font-size: 0.85rem; line-height: 1.6; }
+        .log-line { padding: 2px 0; }
+        .log-line.info { color: #58a6ff; }
+        .log-line.success { color: #3fb950; }
+        .log-line.warning { color: #d29922; }
+        .log-line.error { color: #f85149; }
+        .stats { padding: 12px 20px; background: #161b22;
+            border-top: 1px solid #30363d; display: flex; gap: 24px; }
+        .stat-item span.label { color: #8b949e; font-size: 0.8rem; }
+        .stat-item span.value { color: #58a6ff; font-size: 1.2rem; font-weight: bold; }
+    </style>
+</head>
+<body>
+    <div class="sidebar">
+        <h1>Pawpy</h1>
+        <label>Profile JSON</label>
+        <input type="file" id="profileFile" accept=".json">
+        <label>Output File</label>
+        <input type="text" id="outputFile" placeholder="pawpy_wordlist.txt">
+        <label>Mode</label>
+        <select id="mode">
+            <option value="normal">Normal</option>
+            <option value="lite">Lite (fast)</option>
+            <option value="extreme">Extreme (all mutations)</option>
+        </select>
+        <div class="checkbox"><input type="checkbox" id="markov"> <label for="markov" style="margin:0">Markov Blending</label></div>
+        <div class="checkbox"><input type="checkbox" id="scoring"> <label for="scoring" style="margin:0">zxcvbn Scoring</label></div>
+        <button onclick="startGeneration()">Generate Wordlist</button>
+    </div>
+    <div class="main">
+        <div class="header">Generation Log</div>
+        <div class="log-area" id="logArea"></div>
+        <div class="stats">
+            <div class="stat-item"><span class="label">Candidates</span><br><span class="value" id="statCandidates">0</span></div>
+            <div class="stat-item"><span class="label">Output Size</span><br><span class="value" id="statSize">0 B</span></div>
+            <div class="stat-item"><span class="label">Status</span><br><span class="value" id="statStatus">Idle</span></div>
+        </div>
+    </div>
+    <script>
+        const ws = new WebSocket(`ws://${window.location.host}/ws`);
+        ws.onmessage = (e) => {
+            const msg = JSON.parse(e.data);
+            const logArea = document.getElementById('logArea');
+            const line = document.createElement('div');
+            line.className = `log-line ${msg.level || 'info'}`;
+            line.textContent = msg.text;
+            logArea.appendChild(line);
+            logArea.scrollTop = logArea.scrollHeight;
+            if (msg.candidates) document.getElementById('statCandidates').textContent = Number(msg.candidates).toLocaleString();
+            if (msg.size) document.getElementById('statSize').textContent = (msg.size / (1024*1024)).toFixed(2) + ' MB';
+            if (msg.status) document.getElementById('statStatus').textContent = msg.status;
+        };
+        ws.onclose = () => { addLog('WebSocket disconnected', 'error'); };
+        function addLog(text, level) {
+            const logArea = document.getElementById('logArea');
+            const line = document.createElement('div');
+            line.className = `log-line ${level}`;
+            line.textContent = text;
+            logArea.appendChild(line);
+        }
+        async function startGeneration() {
+            const fileInput = document.getElementById('profileFile');
+            if (!fileInput.files.length) { addLog('Please select a profile JSON file.', 'warning'); return; }
+            const formData = new FormData();
+            formData.append('profile', fileInput.files[0]);
+            formData.append('output', document.getElementById('outputFile').value || 'pawpy_wordlist.txt');
+            const mode = document.getElementById('mode').value;
+            formData.append('lite', mode === 'lite');
+            formData.append('extreme', mode === 'extreme');
+            formData.append('markov', document.getElementById('markov').checked);
+            formData.append('min_strength', document.getElementById('scoring').checked ? '2' : '');
+            addLog('Starting generation...', 'info');
+            try {
+                const resp = await fetch('/generate', { method: 'POST', body: formData });
+                const data = await resp.json();
+                if (data.download_url) {
+                    addLog('Done! Download: ' + data.download_url, 'success');
+                } else {
+                    addLog('Error: ' + (data.message || 'Unknown'), 'error');
+                }
+            } catch (err) { addLog('Fetch error: ' + err.message, 'error'); }
+        }
+    </script>
+</body>
+</html>
+"""
+async def _websocket_handler(websocket):
+    """Handle a single WebSocket connection for real-time logging."""
+    _connections.add(websocket)
+    try:
+        async for message in websocket:
+            pass  # Dashboard only receives; no client commands over WS
+    finally:
+        _connections.discard(websocket)
+async def broadcast_log(text: str, level: str = "info", **extra):
+    """Broadcast a log message to all connected WebSocket clients."""
+    msg = json.dumps({"text": text, "level": level, **extra})
+    for ws in list(_connections):
+        try:
+            await ws.send_text(msg)
+        except Exception:
+            _connections.discard(ws)
+def run_dashboard(host: str = "127.0.0.1", port: int = 8080):
+    """Launch the web dashboard with both HTTP and WebSocket support."""
+    try:
+        import uvicorn
+        from fastapi import FastAPI, WebSocket
+        from fastapi.responses import HTMLResponse
+    except ImportError:
+        raise ImportError(
+            "FastAPI and uvicorn are required for dashboard mode. "
+            "Install them with: pip install fastapi uvicorn websockets"
+        )
+    app = FastAPI(title="Pawpy Dashboard")
+    @app.get("/", response_class=HTMLResponse)
+    async def dashboard_page():
+        return _DASHBOARD_HTML
+    @app.websocket("/ws")
+    async def websocket_endpoint(websocket: WebSocket):
+        await websocket.accept()
+        await _websocket_handler(websocket)
+    logger.info("Starting Pawpy Dashboard on http://%s:%d", host, port)
+    uvicorn.run(app, host=host, port=port)

pawpy/api/rest.py ADDED Viewed

@@ -0,0 +1,145 @@
+"""FastAPI REST endpoints for Pawpy."""
+from __future__ import annotations
+import logging
+import os
+import tempfile
+import uuid
+from typing import Any, Dict, Optional
+logger = logging.getLogger("pawpy.api")
+_app = None
+def get_app():
+    """Lazily create and return the FastAPI app."""
+    global _app
+    if _app is not None:
+        return _app
+    try:
+        from fastapi import FastAPI, File, Form, UploadFile
+        from fastapi.responses import FileResponse, JSONResponse
+    except ImportError:
+        raise ImportError(
+            "FastAPI is required for API mode. "
+            "Install it with: pip install fastapi uvicorn"
+        )
+    app = FastAPI(
+        title="Pawpy API",
+        description="Educational Wordlist Generator – REST API",
+        version="1.0.0",
+    )
+    # In-memory job store (simple; production would use a database)
+    _jobs: Dict[str, Dict[str, Any]] = {}
+    @app.get("/")
+    async def root():
+        return {"name": "Pawpy API", "version": "1.0.0", "status": "running"}
+    @app.post("/generate")
+    async def generate_wordlist(
+        profile: UploadFile = File(...),
+        output: Optional[str] = Form(None),
+        lite: bool = Form(False),
+        extreme: bool = Form(False),
+        min_length: Optional[int] = Form(None),
+        min_strength: Optional[int] = Form(None),
+        markov: bool = Form(False),
+    ):
+        """Generate a wordlist from an uploaded profile JSON file."""
+        job_id = str(uuid.uuid4())[:8]
+        out_file = output or f"pawpy_{job_id}.txt"
+        # Save uploaded profile to temp file
+        tmp_profile = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".json", delete=False, prefix="pawpy_profile_"
+        )
+        content = await profile.read()
+        tmp_profile.write(content.decode("utf-8", errors="ignore"))
+        tmp_profile.close()
+        try:
+            from pawpy.config import PawpyConfig
+            from pawpy.generator.core import PipelineOrchestrator
+            from pawpy.profile.base import ProfileCollector
+            config = PawpyConfig(
+                output_file=out_file,
+                profile_json=tmp_profile.name,
+                lite=lite,
+                extreme=extreme,
+                min_length=min_length,
+                min_strength=min_strength,
+                markov=markov,
+            )
+            collector = ProfileCollector()
+            prof = collector.run(config)
+            orchestrator = PipelineOrchestrator(config, prof)
+            result_path = orchestrator.run()
+            _jobs[job_id] = {
+                "status": "completed",
+                "output": result_path,
+                "size": os.path.getsize(result_path),
+            }
+            return JSONResponse(
+                content={
+                    "job_id": job_id,
+                    "status": "completed",
+                    "download_url": f"/download/{job_id}",
+                }
+            )
+        except Exception as e:
+            logger.exception("Generation failed")
+            return JSONResponse(
+                status_code=500,
+                content={"job_id": job_id, "status": "error", "message": str(e)},
+            )
+        finally:
+            try:
+                os.unlink(tmp_profile.name)
+            except Exception:
+                pass
+    @app.get("/download/{job_id}")
+    async def download_wordlist(job_id: str):
+        """Download a generated wordlist by job ID."""
+        job = _jobs.get(job_id)
+        if not job or job["status"] != "completed":
+            return JSONResponse(
+                status_code=404, content={"error": "Job not found or not completed"}
+            )
+        return FileResponse(
+            job["output"],
+            media_type="text/plain",
+            filename=os.path.basename(job["output"]),
+        )
+    @app.get("/jobs")
+    async def list_jobs():
+        """List all generation jobs."""
+        return {"jobs": _jobs}
+    _app = app
+    return app
+def run_api(host: str = "127.0.0.1", port: int = 8000):
+    """Start the API server using uvicorn."""
+    app = get_app()
+    try:
+        import uvicorn
+    except ImportError:
+        raise ImportError(
+            "uvicorn is required for API mode. " "Install it with: pip install uvicorn"
+        )
+    logger.info("Starting Pawpy API on %s:%d", host, port)
+    uvicorn.run(app, host=host, port=port)

pawpy/cli.py ADDED Viewed

@@ -0,0 +1,341 @@
+"""Pawpy command-line interface.
+Parses all CLI options, displays the banner, orchestrates profile collection
+and the generation pipeline, and handles sub-commands (update-passwords,
+api, dashboard).
+"""
+from __future__ import annotations
+import argparse
+import logging
+import sys
+from pawpy import __version__
+from pawpy.config import PawpyConfig
+from pawpy.utils import confirm_ethical_use, console, print_banner, setup_logging
+logger = logging.getLogger("pawpy")
+def build_parser() -> argparse.ArgumentParser:
+    """Build and return the argument parser with all options."""
+    parser = argparse.ArgumentParser(
+        prog="pawpy",
+        description="Pawpy – The Most Powerful Educational Wordlist Generator",
+        epilog=(
+            "Examples:\n"
+            "  pawpy                                    # Interactive mode\n"
+            "  pawpy -j profile.json -o wordlist.txt   # From JSON profile\n"
+            "  pawpy --multi targets.json --extreme      # Multi-target extreme mode\n"
+            "  pawpy --rules best64.rule --markov       # Rules + Markov blending\n"
+            "  pawpy --hybrid-left ?l?d -o hybrid.txt   # Hybrid mask attack\n"
+            "  pawpy --min-length 8 --require-upper     # Policy-filtered output\n"
+            "  pawpy update-passwords                   # Download latest SecLists\n"
+            "  pawpy api                                # Start REST API\n"
+            "  pawpy dashboard                          # Launch web dashboard\n"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    # --- I/O ---
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="pawpy_wordlist.txt",
+        help="Output file path (default: pawpy_wordlist.txt)",
+    )
+    parser.add_argument(
+        "-j",
+        "--import-json",
+        dest="profile_json",
+        help="Import a single target profile from a JSON file",
+    )
+    parser.add_argument(
+        "--multi",
+        help="Import multiple profiles from a JSON array file",
+    )
+    parser.add_argument(
+        "--rules",
+        help="Load a hashcat/John-style .rule file",
+    )
+    parser.add_argument(
+        "--template",
+        action="append",
+        default=[],
+        dest="templates",
+        help="Custom pattern template, e.g. [FirstName][Year][!] (repeatable)",
+    )
+    # --- Hybrid masks ---
+    parser.add_argument(
+        "--hybrid-left",
+        help="Left mask for hybrid attack (hashcat -a 7), e.g. ?l?d",
+    )
+    parser.add_argument(
+        "--hybrid-right",
+        help="Right mask for hybrid attack (hashcat -a 6), e.g. ?d?d?d",
+    )
+    # --- Markov ---
+    parser.add_argument(
+        "--markov",
+        action="store_true",
+        help="Enable Markov chain blending",
+    )
+    parser.add_argument(
+        "--markov-order",
+        type=int,
+        default=2,
+        help="Markov chain order (default: 2)",
+    )
+    parser.add_argument(
+        "--markov-count",
+        type=int,
+        default=5000,
+        help="Number of Markov-generated words (default: 5000)",
+    )
+    # --- Scoring / filtering ---
+    parser.add_argument(
+        "--min-strength",
+        type=int,
+        choices=[0, 1, 2, 3, 4],
+        help="Minimum zxcvbn strength score (0-4). Requires zxcvbn installed.",
+    )
+    parser.add_argument(
+        "--min-length",
+        type=int,
+        help="Minimum password length",
+    )
+    parser.add_argument(
+        "--require-upper",
+        action="store_true",
+        help="Policy: require at least one uppercase letter",
+    )
+    parser.add_argument(
+        "--require-lower",
+        action="store_true",
+        help="Policy: require at least one lowercase letter",
+    )
+    parser.add_argument(
+        "--require-digit",
+        action="store_true",
+        help="Policy: require at least one digit",
+    )
+    parser.add_argument(
+        "--require-special",
+        action="store_true",
+        help="Policy: require at least one special character",
+    )
+    # --- Modes ---
+    mode_group = parser.add_mutually_exclusive_group()
+    mode_group.add_argument(
+        "--lite",
+        action="store_true",
+        help="Fast mode: skip heavy combinations (two-word, Markov, large hybrid)",
+    )
+    mode_group.add_argument(
+        "--extreme",
+        action="store_true",
+        help="Enable all heavy mutations (year blends, Markov, dynamic keyboard walks)",
+    )
+    # --- Performance ---
+    parser.add_argument(
+        "--gpu",
+        action="store_true",
+        help="Use GPU acceleration if CuPy is available",
+    )
+    parser.add_argument(
+        "-t",
+        "--threads",
+        type=int,
+        default=None,
+        help="Number of worker processes (default: CPU count)",
+    )
+    # --- Meta ---
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable verbose (debug) logging",
+    )
+    return parser
+def build_config(args: argparse.Namespace) -> PawpyConfig:
+    """Convert parsed arguments into a PawpyConfig object."""
+    import multiprocessing
+    config = PawpyConfig(
+        output_file=args.output,
+        profile_json=args.profile_json,
+        multi_json=args.multi,
+        rule_file=args.rules,
+        templates=args.templates,
+        hybrid_left=args.hybrid_left,
+        hybrid_right=args.hybrid_right,
+        markov=args.markov,
+        markov_order=args.markov_order,
+        markov_count=args.markov_count,
+        min_strength=args.min_strength,
+        min_length=args.min_length,
+        require_upper=args.require_upper,
+        require_lower=args.require_lower,
+        require_digit=args.require_digit,
+        require_special=args.require_special,
+        lite=args.lite,
+        extreme=args.extreme,
+        gpu=args.gpu,
+        threads=args.threads if args.threads else multiprocessing.cpu_count() or 4,
+    )
+    return config
+def handle_update_passwords() -> None:
+    """Handle the 'update-passwords' sub-command."""
+    from pawpy.data.updater import update_common_passwords
+    console.print("[cyan]Downloading latest common passwords from SecLists...[/cyan]")
+    try:
+        path = update_common_passwords()
+        console.print(f"[green]Updated common passwords saved to:[/green] {path}")
+    except Exception as e:
+        console.print(f"[red]Failed to update:[/red] {e}")
+        sys.exit(1)
+def handle_api() -> None:
+    """Handle the 'api' sub-command."""
+    from pawpy.api.rest import run_api
+    console.print("[cyan]Starting Pawpy REST API...[/cyan]")
+    try:
+        run_api()
+    except ImportError as e:
+        console.print(f"[red]Missing dependency:[/red] {e}")
+        sys.exit(1)
+def handle_dashboard() -> None:
+    """Handle the 'dashboard' sub-command."""
+    from pawpy.api.dashboard import run_dashboard
+    console.print("[cyan]Starting Pawpy Web Dashboard...[/cyan]")
+    try:
+        run_dashboard()
+    except ImportError as e:
+        console.print(f"[red]Missing dependency:[/red] {e}")
+        sys.exit(1)
+def main(argv: list = None) -> None:
+    """Main entry point for the Pawpy CLI."""
+    # Handle sub-commands first (they don't need the full parser)
+    if argv is None:
+        argv = sys.argv[1:]
+    if not argv:
+        # No args → show banner, then interactive mode
+        pass
+    elif argv[0] == "update-passwords":
+        handle_update_passwords()
+        return
+    elif argv[0] == "api":
+        handle_api()
+        return
+    elif argv[0] == "dashboard":
+        handle_dashboard()
+        return
+    # Parse arguments
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    setup_logging()
+    # Print banner and ethical warning
+    print_banner()
+    # For interactive mode, confirm ethical use
+    if not args.profile_json and not args.multi:
+        if not confirm_ethical_use():
+            console.print("[yellow]Authorisation not confirmed. Exiting.[/yellow]")
+            sys.exit(0)
+    else:
+        console.print(
+            "[dim]Note: Ensure you have explicit authorisation to test "
+            "target accounts.[/dim]\n"
+        )
+    # Build configuration
+    config = build_config(args)
+    # Collect profile
+    from pawpy.generator.core import PipelineOrchestrator
+    from pawpy.profile.base import ProfileCollector
+    from pawpy.profile.multi import (
+        extract_merged_base_words,
+        load_multi_profiles,
+        merge_profiles,
+    )
+    if config.multi_json:
+        console.print(
+            f"[cyan]Loading multi-target profiles from:[/cyan] {config.multi_json}"
+        )
+        profiles = load_multi_profiles(config.multi_json)
+        merged = merge_profiles(profiles)
+        profile = merged
+        base_words = extract_merged_base_words(merged)
+        console.print(
+            f"[green]Extracted {len(base_words)} unique base words from {len(profiles)} profiles.[/green]\n"
+        )
+    else:
+        collector = ProfileCollector()
+        profile = collector.run(config)
+        base_words = ProfileCollector.extract_base_words(profile)
+        if base_words:
+            console.print(
+                f"[green]Extracted {len(base_words)} base words from profile.[/green]\n"
+            )
+    # GPU availability check
+    if config.gpu:
+        from pawpy.generator.gpu import is_gpu_available
+        if is_gpu_available():
+            console.print("[green]GPU acceleration enabled (CuPy detected).[/green]\n")
+        else:
+            console.print(
+                "[yellow]CuPy not installed. GPU mode requested but falling back to CPU.[/yellow]\n"
+            )
+            console.print(
+                "[dim]Install CuPy for GPU support: pip install cupy-cuda11x (or cupy-cuda12x)[/dim]\n"
+            )
+    # Run the generation pipeline
+    try:
+        orchestrator = PipelineOrchestrator(config, profile)
+        output_path = orchestrator.run()
+        console.print(f"\n[bold green]Wordlist saved to: {output_path}[/bold green]")
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Generation interrupted by user.[/yellow]")
+        sys.exit(130)
+    except Exception as e:
+        logger.exception("Generation failed")
+        console.print(f"\n[bold red]Error:[/bold red] {e}")
+        sys.exit(1)
+if __name__ == "__main__":
+    main()