pywire-cli 0.2.0__py3-none-any.whl

pywire_cli/__init__.py

@@ -0,0 +1,3 @@
+"""PyWire CLI — dev, build, deploy, and check tools for PyWire projects."""
+
+__version__ = "0.2.0"

pywire_cli/check.py

@@ -0,0 +1,117 @@
+"""`pywire check` — static analysis for a PyWire project.
+
+Thin CLI layer over :mod:`pywire_parser.analysis`. Supports rich output by
+default and a ruff-style ``--plain`` format for CI / greppable logs. Exits
+1 on any ERROR-severity diagnostic.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, List, Optional, Sequence
+
+from pywire_parser.analysis import Diagnostic, Severity, analyze_files
+from pywire_parser.analysis.registry import all_rule_codes
+from pywire_parser.parser import PyWireParser
+
+
+@dataclass(frozen=True)
+class CheckSummary:
+    errors: int
+    warnings: int
+    infos: int
+    exit_code: int
+
+    @property
+    def total(self) -> int:
+        return self.errors + self.warnings + self.infos
+
+
+def collect_diagnostics(
+    pages_dir: Path,
+    *,
+    rule_codes: Optional[Sequence[str]] = None,
+) -> List[Diagnostic]:
+    """Parse every ``.wire`` under ``pages_dir`` and run the analysis engine."""
+    parser = PyWireParser()
+    items = []
+    if not pages_dir.exists():
+        return []
+    for wire_file in sorted(pages_dir.rglob("*.wire")):
+        try:
+            parsed = parser.parse_file(wire_file)
+        except Exception as e:  # noqa: BLE001 — surface parse errors as diags
+            items.append(_parse_error_diag(wire_file, e))
+            continue
+        items.append((parsed, wire_file))
+    # Split: tuples go to engine; parse-error diagnostics are already Diagnostic
+    parsed_items = [x for x in items if isinstance(x, tuple)]
+    parse_error_diags = [x for x in items if not isinstance(x, tuple)]
+    engine_diags = analyze_files(parsed_items, codes=rule_codes)
+    return parse_error_diags + engine_diags
+
+
+def _parse_error_diag(path: Path, err: Exception) -> Diagnostic:
+    from pywire_parser.analysis.diagnostics import Span
+
+    return Diagnostic(
+        code="PW000",
+        severity=Severity.ERROR,
+        message=f"parse error: {err}",
+        file_path=str(path),
+        span=Span(line=1, column=0),
+    )
+
+
+def format_plain(diags: Iterable[Diagnostic]) -> str:
+    lines = []
+    for d in diags:
+        lines.append(
+            f"{d.file_path}:{d.line}:{d.column}: {d.severity.value} [{d.code}] {d.message}"
+        )
+    return "\n".join(lines)
+
+
+def format_rich(diags: Iterable[Diagnostic], console) -> None:
+    """Render diagnostics with rich markup. ``console`` is a rich Console."""
+    current_file: Optional[str] = None
+    sev_style = {
+        Severity.ERROR: "bold red",
+        Severity.WARNING: "yellow",
+        Severity.INFO: "cyan",
+    }
+    for d in diags:
+        if d.file_path != current_file:
+            console.print(f"\n[bold]{d.file_path}[/]")
+            current_file = d.file_path
+        style = sev_style[d.severity]
+        console.print(
+            f"  [dim]{d.line}:{d.column}[/]  "
+            f"[{style}]{d.severity.value}[/]  "
+            f"[bold]{d.code}[/]  {d.message}"
+        )
+        if d.hint:
+            console.print(f"    [dim]→ {d.hint}[/]")
+
+
+def summarize(diags: Iterable[Diagnostic], *, strict: bool = False) -> CheckSummary:
+    errors = sum(1 for d in diags if d.severity == Severity.ERROR)
+    warnings = sum(1 for d in diags if d.severity == Severity.WARNING)
+    infos = sum(1 for d in diags if d.severity == Severity.INFO)
+    exit_code = 0
+    if errors > 0:
+        exit_code = 1
+    elif strict and (warnings > 0 or infos > 0):
+        exit_code = 1
+    return CheckSummary(errors, warnings, infos, exit_code)
+
+
+__all__ = [
+    "CheckSummary",
+    "collect_diagnostics",
+    "format_plain",
+    "format_rich",
+    "summarize",
+    "all_rule_codes",
+]

pywire_cli/config.py

@@ -0,0 +1,144 @@
+"""Persistent CLI settings stored in .pywire/settings.toml."""
+
+import tomllib
+from pathlib import Path
+from typing import Any, Optional
+
+try:
+    import rich_click as click
+    from rich.console import Console
+except ImportError:
+    import sys
+
+    print(
+        "Error: pywire CLI requires additional dependencies.\n"
+        "Install them with: uv add pywire[cli]  (or: pip install pywire[cli])",
+        file=sys.stderr,
+    )
+    sys.exit(1)
+
+console = Console()
+
+SETTINGS_DIR = Path(".pywire")
+SETTINGS_FILE = SETTINGS_DIR / "settings.toml"
+
+# Valid setting keys and their accepted values
+VALID_SETTINGS: dict[str, dict[str, Any]] = {
+    "tui": {
+        "type": "bool",
+        "on_values": {"on", "true", "1", "yes"},
+        "off_values": {"off", "false", "0", "no"},
+        "description": "Enable TUI dashboard for dev server",
+    },
+    "port": {
+        "type": "int",
+        "description": "Default port for dev server (default: 3000)",
+    },
+}
+
+
+def _read_settings() -> dict[str, Any]:
+    """Read settings from .pywire/settings.toml, returning empty dict if missing."""
+    if not SETTINGS_FILE.exists():
+        return {}
+    with open(SETTINGS_FILE, "rb") as f:
+        data = tomllib.load(f)
+    return data.get("cli", {})
+
+
+def _write_settings(settings: dict[str, Any]) -> None:
+    """Write settings to .pywire/settings.toml using simple TOML formatting."""
+    SETTINGS_DIR.mkdir(parents=True, exist_ok=True)
+    lines = ["[cli]"]
+    for key, value in sorted(settings.items()):
+        if isinstance(value, bool):
+            lines.append(f"{key} = {'true' if value else 'false'}")
+        elif isinstance(value, str):
+            lines.append(f'{key} = "{value}"')
+        else:
+            lines.append(f"{key} = {value}")
+    SETTINGS_FILE.write_text("\n".join(lines) + "\n")
+
+
+def get_setting(key: str) -> Optional[Any]:
+    """Get a single setting value, or None if not set."""
+    return _read_settings().get(key)
+
+
+def _parse_bool_value(key: str, value: str) -> bool:
+    """Parse a string value into a boolean for the given setting key."""
+    meta = VALID_SETTINGS[key]
+    lower = value.lower()
+    if lower in meta["on_values"]:
+        return True
+    if lower in meta["off_values"]:
+        return False
+    on = ", ".join(sorted(meta["on_values"]))
+    off = ", ".join(sorted(meta["off_values"]))
+    raise click.BadParameter(
+        f"Invalid value '{value}' for '{key}'. Use one of: {on} (enable) or {off} (disable)."
+    )
+
+
+@click.command(name="config")
+@click.argument("key", required=False)
+@click.argument("value", required=False)
+def config_command(key: Optional[str], value: Optional[str]) -> None:
+    """View or update persistent CLI settings (.pywire/settings.toml).
+
+    \b
+    Examples:
+      pywire config          Show all settings
+      pywire config tui      Show TUI setting
+      pywire config tui on   Enable TUI by default
+      pywire config tui off  Disable TUI by default
+    """
+    if key is None:
+        # Show all settings
+        settings = _read_settings()
+        if not settings:
+            console.print("[dim]No settings configured yet.[/]")
+            console.print(
+                "[dim]Available settings:[/] "
+                + ", ".join(f"[cyan]{k}[/]" for k in sorted(VALID_SETTINGS))
+            )
+            return
+        for k, v in sorted(settings.items()):
+            console.print(f"[cyan]{k}[/] = [bold]{v}[/]")
+        return
+
+    if key not in VALID_SETTINGS:
+        valid = ", ".join(sorted(VALID_SETTINGS))
+        raise click.BadParameter(
+            f"Unknown setting '{key}'. Valid settings: {valid}",
+            param_hint="KEY",
+        )
+
+    if value is None:
+        # Show single setting
+        current = get_setting(key)
+        if current is None:
+            console.print(f"[cyan]{key}[/] = [dim]<not set>[/]")
+        else:
+            console.print(f"[cyan]{key}[/] = [bold]{current}[/]")
+        return
+
+    # Set value
+    meta = VALID_SETTINGS[key]
+    if meta["type"] == "bool":
+        parsed = _parse_bool_value(key, value)
+    elif meta["type"] == "int":
+        try:
+            parsed = int(value)
+        except ValueError:
+            raise click.BadParameter(
+                f"Invalid value '{value}' for '{key}'. Must be an integer.",
+                param_hint="VALUE",
+            )
+    else:
+        parsed = value
+
+    settings = _read_settings()
+    settings[key] = parsed
+    _write_settings(settings)
+    console.print(f"[cyan]{key}[/] = [bold]{parsed}[/]")

pywire_cli/deploy.py

@@ -0,0 +1,90 @@
+"""Deployment configuration generators for PyWire apps.
+
+Templates live in the ``pywire-templates`` package so ``create-pywire-app``
+and ``pywire deploy`` stay in sync. This module is a thin rendering layer
+that feeds the right context variables to each template.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pywire_templates import render_deploy_template
+
+
+def _parse_app_string(app_string: str) -> tuple[str, str]:
+    """Parse ``'src.main:app'`` into ``('src.main', 'app')``."""
+    if ":" in app_string:
+        app_module, app_attr = app_string.rsplit(":", 1)
+    else:
+        app_module, app_attr = app_string, "app"
+    return app_module, app_attr
+
+
+def generate_dockerfile(project_root: Path, workers: int = 1) -> str:
+    """Generate Dockerfile content for a PyWire project."""
+    return render_deploy_template("Dockerfile.j2", workers=workers)
+
+
+def generate_render_yaml(
+    project_root: Path, project_name: str, redis: bool = False
+) -> str:
+    """Generate render.yaml content for a PyWire project."""
+    return render_deploy_template(
+        "render.yaml.j2",
+        project_name=project_name,
+        redis_enabled=redis,
+    )
+
+
+def generate_fly_toml(project_root: Path, project_name: str) -> str:
+    """Generate fly.toml content for a PyWire project."""
+    return render_deploy_template("fly.toml.j2", project_name=project_name)
+
+
+def generate_railway_json(project_root: Path) -> str:
+    """Generate railway.json content for a PyWire project."""
+    return render_deploy_template("railway.json.j2")
+
+
+def generate_wrangler_toml(project_root: Path, project_name: str) -> str:
+    """Generate wrangler.toml content for Cloudflare Workers with Durable Objects."""
+    return render_deploy_template("wrangler.toml.j2", project_name=project_name)
+
+
+def generate_cf_entry(project_root: Path, app_string: str = "main:app") -> str:
+    """Generate entry.py for Cloudflare Workers with Durable Object routing."""
+    app_module, app_attr = _parse_app_string(app_string)
+    return render_deploy_template(
+        "entry.py.j2", app_module=app_module, app_attr=app_attr
+    )
+
+
+def generate_cf_durable_object(project_root: Path, app_string: str = "main:app") -> str:
+    """Generate pywire_do.py — the Durable Object class for PyWire sessions."""
+    app_module, app_attr = _parse_app_string(app_string)
+    return render_deploy_template(
+        "pywire_do.py.j2", app_module=app_module, app_attr=app_attr
+    )
+
+
+def validate_deploy_config(platform: str, project_root: Path) -> list[str]:
+    """Check what's missing for deployment on the given platform.
+
+    Returns a list of warning/error messages. An empty list means
+    everything looks good.
+    """
+    issues: list[str] = []
+
+    if not (project_root / "pyproject.toml").exists():
+        issues.append("Missing pyproject.toml — required for dependency installation.")
+
+    if (
+        platform in ("docker", "fly", "render", "railway")
+        and not (project_root / "uv.lock").exists()
+    ):
+        issues.append(
+            "Missing uv.lock — run 'uv lock' to generate a lock file for reproducible builds."
+        )
+
+    return issues