noswag-cli 0.1.0__py3-none-any.whl

noswag/__init__.py

@@ -0,0 +1,3 @@
+"""NoSwag public Python client."""
+
+__version__ = "0.1.0"

noswag/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

noswag/api.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any
+
+from .errors import ApiError, ValidationError
+
+
+class NoSwagClient:
+    def __init__(
+        self,
+        base_url: str,
+        token: str | None = None,
+        workspace_id: str | None = None,
+        timeout: float = 30,
+    ) -> None:
+        if not base_url.startswith(("http://", "https://")):
+            raise ValidationError("API URL must use HTTP or HTTPS")
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self.workspace_id = workspace_id
+        self.timeout = timeout
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None = None,
+        *,
+        idempotency_key: str | None = None,
+        authenticated: bool = True,
+    ) -> dict[str, Any]:
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "noswag-python/0.1.0",
+        }
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+        if authenticated:
+            if not self.token:
+                raise ValidationError("No authentication token is configured")
+            headers["Authorization"] = f"Bearer {self.token}"
+        if self.workspace_id:
+            headers["X-Workspace-Id"] = self.workspace_id
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+        request = urllib.request.Request(
+            f"{self.base_url}{path}",
+            data=(
+                json.dumps(body, separators=(",", ":")).encode()
+                if body is not None
+                else None
+            ),
+            headers=headers,
+            method=method,
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                payload = json.loads(response.read().decode())
+        except urllib.error.HTTPError as error:
+            try:
+                payload = json.loads(error.read().decode())
+                detail = payload.get("error", {})
+            except (json.JSONDecodeError, UnicodeDecodeError):
+                detail = {}
+            raise ApiError(
+                error.code,
+                str(detail.get("code", "http_error")),
+                str(detail.get("message", f"NoSwag API returned HTTP {error.code}")),
+            ) from None
+        except urllib.error.URLError as error:
+            raise ApiError(0, "network_error", f"Could not reach NoSwag API: {error.reason}") from None
+        if not isinstance(payload, dict) or payload.get("success") is not True:
+            raise ApiError(0, "invalid_response", "NoSwag API returned an invalid response")
+        data = payload.get("data")
+        if not isinstance(data, dict):
+            raise ApiError(0, "invalid_response", "NoSwag API response has no data object")
+        return data
+
+    def issue_device_code(self) -> dict[str, Any]:
+        return self.request(
+            "POST",
+            "/v1/auth/device/code",
+            {
+                "client_name": "NoSwag Python CLI",
+                "scopes": [
+                    "repository:read",
+                    "repository:write",
+                    "generation:create",
+                    "generation:read",
+                    "usage:read",
+                ],
+            },
+            authenticated=False,
+        )
+
+    def exchange_device_code(self, device_code: str) -> dict[str, Any]:
+        return self.request(
+            "POST",
+            "/v1/auth/device/token",
+            {"device_code": device_code},
+            authenticated=False,
+        )
+
+    def refresh_access_token(self, refresh_token: str) -> dict[str, Any]:
+        return self.request(
+            "POST",
+            "/v1/auth/token/refresh",
+            {"refresh_token": refresh_token},
+            authenticated=False,
+        )
+
+    def revoke_refresh_token(self, refresh_token: str) -> dict[str, Any]:
+        return self.request(
+            "POST",
+            "/v1/auth/token/revoke",
+            {"refresh_token": refresh_token},
+            authenticated=False,
+        )
+
+    def get(self, path: str) -> dict[str, Any]:
+        return self.request("GET", path)
+
+    def post(
+        self,
+        path: str,
+        body: dict[str, Any],
+        *,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        return self.request("POST", path, body, idempotency_key=idempotency_key)

noswag/cli.py

@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+import webbrowser
+from pathlib import Path
+from typing import Any, cast
+
+from . import __version__
+from .api import NoSwagClient
+from .config import DEFAULT_CONFIG, load_config
+from .credentials import Credential, KeyringCredentialStore
+from .errors import ApiError, GenerationError, NoSwagError, ValidationError
+from .repository import (
+    build_context,
+    config_hash,
+    find_git_root,
+    idempotency_key,
+    repository_identity,
+)
+from .writer import apply_artifact
+from .verification import plan_verification, run_verification
+
+DEFAULT_API_URL = "https://api.noswag.io"
+TERMINAL = {"completed", "failed", "cancelled", "timed_out"}
+
+
+def _api_url(args: argparse.Namespace) -> str:
+    return str(args.api_url or os.environ.get("NOSWAG_API_URL", DEFAULT_API_URL)).rstrip("/")
+
+
+def _client(args: argparse.Namespace) -> NoSwagClient:
+    url = _api_url(args)
+    configured_token = (
+        args.api_key
+        or os.environ.get("NOSWAG_API_KEY")
+        or os.environ.get("NOSWAG_TOKEN")
+    )
+    store = KeyringCredentialStore()
+    credential = None if configured_token else store.load(url)
+    if (
+        credential
+        and credential.refresh_token
+        and credential.expires_at
+        and credential.expires_at <= time.time() + 30
+        and not configured_token
+    ):
+        result = NoSwagClient(url).refresh_access_token(
+            credential.refresh_token
+        )
+        credential = Credential(
+            token=str(result["access_token"]),
+            workspace_id=str(result["workspace_id"]),
+            refresh_token=str(result["refresh_token"]),
+            expires_at=time.time() + int(result["expires_in"]),
+        )
+        store.save(url, credential)
+    token = configured_token or (credential.token if credential else None)
+    workspace = os.environ.get("NOSWAG_WORKSPACE_ID") or (
+        credential.workspace_id if credential else None
+    )
+    if not token or (not workspace and not token.startswith("nsw_")):
+        raise ValidationError("Not authenticated; run `noswag auth login` or set NOSWAG_API_KEY (platform keys do not need NOSWAG_WORKSPACE_ID)")
+    return NoSwagClient(url, token, workspace)
+
+
+def _emit(value: Any, json_output: bool) -> None:
+    if json_output:
+        print(json.dumps(value, separators=(",", ":"), sort_keys=True))
+    elif isinstance(value, str):
+        print(value)
+    else:
+        print(json.dumps(value, indent=2, sort_keys=True))
+
+
+def auth_login(args: argparse.Namespace) -> dict[str, Any]:
+    url = _api_url(args)
+    client = NoSwagClient(url)
+    issued = client.issue_device_code()
+    print(f"Enter code {issued['user_code']} at {issued['verification_uri']}", file=sys.stderr)
+    if not args.no_browser:
+        webbrowser.open(str(issued.get("verification_uri_complete") or issued["verification_uri"]))
+    deadline = time.monotonic() + int(issued["expires_in"])
+    interval = max(1, int(issued["interval"]))
+    while time.monotonic() < deadline:
+        time.sleep(interval)
+        try:
+            result = client.exchange_device_code(str(issued["device_code"]))
+        except ApiError as error:
+            if error.code == "authorization_pending":
+                continue
+            if error.code == "slow_down":
+                interval += 5
+                continue
+            raise
+        credential = Credential(
+            token=str(result["access_token"]),
+            workspace_id=str(result["workspace_id"]),
+            refresh_token=str(result["refresh_token"]),
+            expires_at=time.time() + int(result["expires_in"]),
+        )
+        KeyringCredentialStore().save(url, credential)
+        return {"authenticated": True, "workspace_id": credential.workspace_id}
+    raise ValidationError("Device authorization expired")
+
+
+def auth_status(args: argparse.Namespace) -> dict[str, Any]:
+    return _client(args).get("/v1/me")
+
+
+def auth_logout(args: argparse.Namespace) -> dict[str, Any]:
+    url = _api_url(args)
+    store = KeyringCredentialStore()
+    credential = store.load(url)
+    if credential and credential.refresh_token:
+        try:
+            NoSwagClient(url).revoke_refresh_token(
+                credential.refresh_token
+            )
+        except ApiError:
+            pass
+    store.delete(url)
+    return {"authenticated": False}
+
+
+def init_repo(args: argparse.Namespace) -> dict[str, Any]:
+    root = find_git_root()
+    target = root / ".noswag.yml"
+    if target.exists() and not args.force:
+        raise ValidationError(".noswag.yml already exists; use --force to replace it")
+    target.write_text(DEFAULT_CONFIG)
+    return {"repository_root": str(root), "config": str(target)}
+
+
+def doctor(args: argparse.Namespace) -> dict[str, Any]:
+    root = find_git_root()
+    config = load_config(root, args.config)
+    client = _client(args)
+    me = client.get("/v1/me")
+    context = build_context(root, config, args.base, args.head)
+    return {
+        "ok": True,
+        "repository_root": str(root),
+        "workspace_id": client.workspace_id,
+        "principal": me.get("principal"),
+        "context_files": len(context.files),
+        "changed_files": len(context.changed_files),
+        "head_sha": context.head_sha,
+    }
+
+
+def _repository(client: NoSwagClient, root: Path, config: Any) -> dict[str, Any]:
+    owner, name = repository_identity(root)
+    listed = client.get("/v1/repositories").get("repositories", [])
+    if not isinstance(listed, list):
+        raise ValidationError("Repository list response is invalid")
+    for value in listed:
+        if not isinstance(value, dict):
+            continue
+        repository = cast(dict[str, Any], value)
+        if repository.get("owner") == owner and repository.get("name") == name:
+            return repository
+    created = client.post(
+        "/v1/repositories",
+        {
+            "provider": "local",
+            "owner": owner,
+            "name": name,
+            "default_branch": "main",
+            "policy": {
+                "mode": config.scope,
+                "languages": list(config.languages),
+                "frameworks": list(config.frameworks),
+                "max_files": config.limits.max_generated_files,
+                "allow_new_dependencies": config.allow_new_dependencies,
+            },
+        },
+    )
+    created_repository = created.get("repository")
+    if not isinstance(created_repository, dict):
+        raise ValidationError("Repository response is invalid")
+    return created_repository
+
+
+def gentest(args: argparse.Namespace) -> dict[str, Any]:
+    root = find_git_root()
+    config = load_config(root, args.config)
+    verification_commands = plan_verification(
+        configured=config.verify_enabled,
+        requested=bool(args.verify),
+        write=bool(args.write),
+        commands=config.verify_commands,
+    )
+    context = build_context(root, config, args.base, args.head, args.spec)
+    client = _client(args)
+    repository = _repository(client, root, config)
+    write = bool(args.write)
+    key = idempotency_key(root, context, config, "py")
+    created = client.post(
+        "/v1/generations",
+        {
+            "repository_id": repository["id"],
+            "trigger_type": "cli_python",
+            "client_version": __version__,
+            "base_sha": context.base_sha,
+            "head_sha": context.head_sha,
+            "policy_config_hash": repository.get("policy", {}).get("config_hash") or config_hash(config),
+            "delivery_mode": "commit" if write else "preview",
+        },
+        idempotency_key=key,
+    )
+    run_id = created["generation"]["id"]
+    client.post(
+        f"/v1/generations/{run_id}/context",
+        {
+            "files": context.files,
+            "change": {"files": context.changed_files, "diff": context.diff},
+        },
+    )
+    deadline = time.monotonic() + args.timeout
+    generation: dict[str, Any] = {}
+    while time.monotonic() < deadline:
+        generation = client.get(f"/v1/generations/{run_id}")["generation"]
+        if generation["status"] in TERMINAL:
+            break
+        time.sleep(args.poll_interval)
+    if generation.get("status") != "completed":
+        raise GenerationError(
+            f"Generation {run_id} ended with status {generation.get('status', 'timeout')}"
+        )
+    artifact = client.get(f"/v1/generations/{run_id}/artifact")["artifact"]
+    report = apply_artifact(root, artifact, write)
+    verification = run_verification(root, verification_commands)
+    if not args.json and report.diff:
+        print(report.diff)
+    return {
+        "run_id": run_id,
+        "status": generation["status"],
+        "mode": "write" if write else "dry-run",
+        "repository_root": str(root),
+        "generated": report.generated,
+        "modified": report.modified,
+        "skipped": report.skipped,
+        "conflicted": report.conflicted,
+        "verification": verification,
+        "diff": report.diff if args.json else None,
+    }
+
+
+def status(args: argparse.Namespace) -> dict[str, Any]:
+    return _client(args).get(f"/v1/generations/{args.run_id}")
+
+
+def usage(args: argparse.Namespace) -> dict[str, Any]:
+    return _client(args).get("/v1/usage")
+
+
+def parser() -> argparse.ArgumentParser:
+    root = argparse.ArgumentParser(prog="noswag")
+    root.add_argument("--api-url")
+    root.add_argument("--api-key")
+    root.add_argument("--json", action="store_true")
+    root.add_argument("--version", action="version", version=__version__)
+    commands = root.add_subparsers(dest="command", required=True)
+    auth = commands.add_parser("auth")
+    auth_commands = auth.add_subparsers(dest="auth_command", required=True)
+    login = auth_commands.add_parser("login")
+    login.add_argument("--no-browser", action="store_true")
+    login.set_defaults(handler=auth_login)
+    auth_commands.add_parser("status").set_defaults(handler=auth_status)
+    auth_commands.add_parser("logout").set_defaults(handler=auth_logout)
+    init = commands.add_parser("init")
+    init.add_argument("--force", action="store_true")
+    init.set_defaults(handler=init_repo)
+    doctor_command = commands.add_parser("doctor")
+    doctor_command.add_argument("--config", default=".noswag.yml")
+    doctor_command.add_argument("--base")
+    doctor_command.add_argument("--head", default="HEAD")
+    doctor_command.set_defaults(handler=doctor)
+    generate = commands.add_parser("gentest")
+    generate.add_argument("--config", default=".noswag.yml")
+    generate.add_argument("--spec", help="Generate contract tests from a repository-relative OpenAPI/Swagger file")
+    generate.add_argument("--base")
+    generate.add_argument("--head", default="HEAD")
+    generate.add_argument("--dry-run", action="store_true")
+    generate.add_argument("--write", action="store_true")
+    generate.add_argument("--verify", action="store_true")
+    generate.add_argument("--timeout", type=float, default=300)
+    generate.add_argument("--poll-interval", type=float, default=2)
+    generate.set_defaults(handler=gentest)
+    status_command = commands.add_parser("status")
+    status_command.add_argument("run_id")
+    status_command.set_defaults(handler=status)
+    commands.add_parser("usage").set_defaults(handler=usage)
+    return root
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parser().parse_args(argv)
+    try:
+        result = args.handler(args)
+        _emit(result, args.json)
+        return 0
+    except NoSwagError as error:
+        if args.json:
+            _emit({"error": {"message": str(error), "type": type(error).__name__}}, True)
+        else:
+            print(f"error: {error}", file=sys.stderr)
+        return error.exit_code

noswag/config.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from .errors import ValidationError
+
+
+@dataclass(frozen=True)
+class Limits:
+    max_changed_files: int = 50
+    max_context_files: int = 100
+    max_file_bytes: int = 128_000
+    max_total_bytes: int = 1_500_000
+    max_generated_files: int = 10
+
+
+@dataclass(frozen=True)
+class Config:
+    include: tuple[str, ...] = ("src/**", "app/**", "apps/**", "packages/**", "tests/**")
+    exclude: tuple[str, ...] = (
+        "node_modules/**",
+        "dist/**",
+        "build/**",
+        "vendor/**",
+        ".git/**",
+        "**/*.generated.*",
+    )
+    languages: tuple[str, ...] = ()
+    frameworks: tuple[str, ...] = ()
+    scope: str = "changed"
+    allow_new_dependencies: bool = False
+    write_mode: str = "dry-run"
+    protect_existing: bool = True
+    verify_enabled: bool = False
+    verify_commands: tuple[str, ...] = ()
+    limits: Limits = field(default_factory=Limits)
+
+
+def _mapping(value: Any, name: str) -> dict[str, Any]:
+    if value is None:
+        return {}
+    if not isinstance(value, dict):
+        raise ValidationError(f"{name} must be a mapping")
+    return value
+
+
+def _strings(value: Any, name: str, default: tuple[str, ...]) -> tuple[str, ...]:
+    if value is None:
+        return default
+    if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
+        raise ValidationError(f"{name} must be a string array")
+    return tuple(value)
+
+
+def _positive(value: Any, name: str, default: int, maximum: int) -> int:
+    if value is None:
+        return default
+    if not isinstance(value, int) or isinstance(value, bool) or value < 1 or value > maximum:
+        raise ValidationError(f"{name} must be an integer between 1 and {maximum}")
+    return value
+
+
+def load_config(root: Path, config_path: str = ".noswag.yml") -> Config:
+    path = (root / config_path).resolve()
+    if root.resolve() not in (path, *path.parents):
+        raise ValidationError("Configuration path escapes the repository")
+    if not path.exists():
+        return Config()
+    try:
+        import yaml
+    except ImportError as error:
+        raise ValidationError("PyYAML is required to read .noswag.yml") from error
+    data = yaml.safe_load(path.read_text()) or {}
+    if not isinstance(data, dict):
+        raise ValidationError(".noswag.yml must contain a mapping")
+    if data.get("version") != 1:
+        raise ValidationError(".noswag.yml version must be 1")
+    generation = _mapping(data.get("generation"), "generation")
+    paths = _mapping(data.get("paths"), "paths")
+    limits = _mapping(data.get("limits"), "limits")
+    write = _mapping(data.get("write"), "write")
+    verify = _mapping(data.get("verify"), "verify")
+    scope = generation.get("scope", "changed")
+    if scope not in {"changed", "full"}:
+        raise ValidationError("generation.scope must be changed or full")
+    mode = write.get("mode", "dry-run")
+    if mode not in {"dry-run", "write"}:
+        raise ValidationError("write.mode must be dry-run or write")
+    if "enabled" in verify and not isinstance(verify["enabled"], bool):
+        raise ValidationError("verify.enabled must be a boolean")
+    defaults = Limits()
+    return Config(
+        include=_strings(paths.get("include"), "paths.include", Config.include),
+        exclude=_strings(paths.get("exclude"), "paths.exclude", Config.exclude),
+        languages=_strings(generation.get("languages"), "generation.languages", ()),
+        frameworks=_strings(generation.get("frameworks"), "generation.frameworks", ()),
+        scope=scope,
+        allow_new_dependencies=bool(generation.get("allow_new_dependencies", False)),
+        write_mode=mode,
+        protect_existing=bool(write.get("protect_existing", True)),
+        verify_enabled=verify.get("enabled", False) is True,
+        verify_commands=_strings(verify.get("commands"), "verify.commands", ()),
+        limits=Limits(
+            max_changed_files=_positive(limits.get("max_changed_files"), "limits.max_changed_files", defaults.max_changed_files, 100),
+            max_context_files=_positive(limits.get("max_context_files"), "limits.max_context_files", defaults.max_context_files, 200),
+            max_file_bytes=_positive(limits.get("max_file_bytes"), "limits.max_file_bytes", defaults.max_file_bytes, 1_000_000),
+            max_total_bytes=_positive(limits.get("max_total_bytes"), "limits.max_total_bytes", defaults.max_total_bytes, 10_000_000),
+            max_generated_files=_positive(limits.get("max_generated_files"), "limits.max_generated_files", defaults.max_generated_files, 50),
+        ),
+    )
+
+
+DEFAULT_CONFIG = """version: 1
+
+generation:
+  scope: changed
+  languages: []
+  frameworks: []
+  allow_new_dependencies: false
+
+paths:
+  include: ["src/**", "app/**", "apps/**", "packages/**", "tests/**"]
+  exclude: ["node_modules/**", "dist/**", "build/**", "vendor/**", "**/*.generated.*"]
+
+limits:
+  max_changed_files: 50
+  max_context_files: 100
+  max_file_bytes: 128000
+  max_total_bytes: 1500000
+  max_generated_files: 10
+
+write:
+  mode: dry-run
+  protect_existing: true
+
+verify:
+  enabled: false
+  commands: []
+"""

noswag/credentials.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from typing import Any, Protocol
+
+from .errors import AuthenticationError
+
+
+@dataclass(frozen=True)
+class Credential:
+    token: str
+    workspace_id: str | None = None
+    refresh_token: str | None = None
+    expires_at: float | None = None
+
+
+class CredentialStore(Protocol):
+    def load(self, api_url: str) -> Credential | None: ...
+    def save(self, api_url: str, credential: Credential) -> None: ...
+    def delete(self, api_url: str) -> None: ...
+
+
+class KeyringCredentialStore:
+    service = "io.noswag.cli"
+
+    @staticmethod
+    def _key(api_url: str) -> str:
+        return api_url.rstrip("/")
+
+    @staticmethod
+    def _keyring() -> Any:
+        try:
+            import keyring
+        except ImportError as error:
+            raise AuthenticationError(
+                "OS credential storage is unavailable; install the package with keyring support"
+            ) from error
+        return keyring
+
+    def load(self, api_url: str) -> Credential | None:
+        value = self._keyring().get_password(self.service, self._key(api_url))
+        if not value:
+            return None
+        try:
+            data: Any = json.loads(value)
+            if not isinstance(data, dict):
+                raise TypeError("credential must be an object")
+            token = data.get("token")
+            workspace_id = data.get("workspace_id")
+            refresh_token = data.get("refresh_token")
+            expires_at = data.get("expires_at")
+            if (
+                not isinstance(token, str)
+                or (
+                    workspace_id is not None
+                    and not isinstance(workspace_id, str)
+                )
+                or (
+                    refresh_token is not None
+                    and not isinstance(refresh_token, str)
+                )
+                or (
+                    expires_at is not None
+                    and not isinstance(expires_at, (int, float))
+                )
+            ):
+                raise TypeError("credential fields are invalid")
+            return Credential(
+                token=token,
+                workspace_id=workspace_id,
+                refresh_token=refresh_token,
+                expires_at=float(expires_at) if expires_at is not None else None,
+            )
+        except (KeyError, TypeError, json.JSONDecodeError) as error:
+            raise AuthenticationError("Stored NoSwag credential is invalid; run auth logout") from error
+
+    def save(self, api_url: str, credential: Credential) -> None:
+        self._keyring().set_password(
+            self.service,
+            self._key(api_url),
+            json.dumps(asdict(credential), separators=(",", ":")),
+        )
+
+    def delete(self, api_url: str) -> None:
+        keyring = self._keyring()
+        try:
+            keyring.delete_password(self.service, self._key(api_url))
+        except keyring.errors.PasswordDeleteError:
+            return