vicpropertycheck 0.1.1__tar.gz

vicpropertycheck-0.1.1/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: vicpropertycheck
+Version: 0.1.1
+Summary: Victorian property due diligence — MCP server, CLI, and skill backend (planning, bushfire, crime, housing, facilities)
+Author-email: Roger Liu <zichengliu0226@gmail.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.13.2
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.25.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: shapely>=2.0.6
+Requires-Dist: pyproj>=3.7.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: structlog>=24.4.0
+Requires-Dist: aiosqlite>=0.20.0
+Requires-Dist: tenacity>=9.0.0
+Requires-Dist: typing-extensions>=4.12.2
+Requires-Dist: email-validator>=2.2.0
+Requires-Dist: uvicorn>=0.40.0
+Requires-Dist: starlette>=0.50.0
+Requires-Dist: sse-starlette>=2.1.0
+Provides-Extra: dev
+Requires-Dist: pytest<8.3,>=8.2.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
+Requires-Dist: pytest-cov>=6.0.0; extra == "dev"
+Requires-Dist: black>=24.10.0; extra == "dev"
+Requires-Dist: isort>=5.13.2; extra == "dev"
+Requires-Dist: flake8>=7.1.1; extra == "dev"
+Requires-Dist: mypy>=1.13.0; extra == "dev"
+Requires-Dist: pylint>=3.3.2; extra == "dev"
+Requires-Dist: pylint-pydantic>=0.3.2; extra == "dev"
+Requires-Dist: pylint-pytest>=1.1.8; extra == "dev"
+Requires-Dist: pre-commit>=4.0.1; extra == "dev"
+
+# vicpropertycheck
+
+Victorian (Australia) property due diligence — three things in one Python package:
+
+1. **MCP server** (`vic-property-mcp`) — exposes property tools to MCP-aware clients.
+2. **CLI** (`vic-property`) — same tools as subcommands, for shell/script use.
+3. **Skill backend** — drives the `vic-property-check` Claude Code skill (see `skill/SKILL.md`).
+
+All three share the same providers, cache, and config:
+
+- VicMap Planning ArcGIS (zones + overlays)
+- VicMap Bushfire ArcGIS (BMO, prone areas)
+- OpenStats (suburb crime + housing)
+- Google Maps (geocoding + nearby places) — direct API key or hosted proxy with Firebase sign-in
+
+## Install
+
+```bash
+pipx install vicpropertycheck
+```
+
+This puts `vic-property-mcp` (server) and `vic-property` (CLI) on your `PATH`.
+
+## CLI quick start
+
+```bash
+# VIC government APIs need no auth — these work out of the box:
+vic-property planning  --lat -37.8113 --lon 144.9737
+vic-property bushfire  --lat -37.8113 --lon 144.9737
+vic-property crime     --suburb "Melbourne"
+
+# Google-backed commands need either:
+#   (a) export GOOGLE_MAPS_API_KEY=...     (self-hosted)
+#   (b) vic-property login                 (paste blob from vicpropertycheck.com.au/skill-auth)
+vic-property summarize --address "1 Spring St, Melbourne VIC 3000" --pretty
+```
+
+Every subcommand emits one JSON object on stdout. Errors come back as
+`{"error": "...", "code": "..."}` with a non-zero exit code.
+
+## MCP server
+
+```bash
+vic-property-mcp                            # stdio transport (default)
+VIC_PROPERTY_TRANSPORT__MODE=http vic-property-mcp   # HTTP on :8080
+```
+
+Configuration uses the `VIC_PROPERTY_` env-var prefix; see `.env.example`.
+
+## Skill
+
+Drop `skill/` into `~/.claude/skills/vic-property-check/`. See `skill/INSTALL.md` for the
+full install + auth walkthrough.
+
+## License
+
+MIT.

vicpropertycheck-0.1.1/README.md

@@ -0,0 +1,57 @@
+# vicpropertycheck
+
+Victorian (Australia) property due diligence — three things in one Python package:
+
+1. **MCP server** (`vic-property-mcp`) — exposes property tools to MCP-aware clients.
+2. **CLI** (`vic-property`) — same tools as subcommands, for shell/script use.
+3. **Skill backend** — drives the `vic-property-check` Claude Code skill (see `skill/SKILL.md`).
+
+All three share the same providers, cache, and config:
+
+- VicMap Planning ArcGIS (zones + overlays)
+- VicMap Bushfire ArcGIS (BMO, prone areas)
+- OpenStats (suburb crime + housing)
+- Google Maps (geocoding + nearby places) — direct API key or hosted proxy with Firebase sign-in
+
+## Install
+
+```bash
+pipx install vicpropertycheck
+```
+
+This puts `vic-property-mcp` (server) and `vic-property` (CLI) on your `PATH`.
+
+## CLI quick start
+
+```bash
+# VIC government APIs need no auth — these work out of the box:
+vic-property planning  --lat -37.8113 --lon 144.9737
+vic-property bushfire  --lat -37.8113 --lon 144.9737
+vic-property crime     --suburb "Melbourne"
+
+# Google-backed commands need either:
+#   (a) export GOOGLE_MAPS_API_KEY=...     (self-hosted)
+#   (b) vic-property login                 (paste blob from vicpropertycheck.com.au/skill-auth)
+vic-property summarize --address "1 Spring St, Melbourne VIC 3000" --pretty
+```
+
+Every subcommand emits one JSON object on stdout. Errors come back as
+`{"error": "...", "code": "..."}` with a non-zero exit code.
+
+## MCP server
+
+```bash
+vic-property-mcp                            # stdio transport (default)
+VIC_PROPERTY_TRANSPORT__MODE=http vic-property-mcp   # HTTP on :8080
+```
+
+Configuration uses the `VIC_PROPERTY_` env-var prefix; see `.env.example`.
+
+## Skill
+
+Drop `skill/` into `~/.claude/skills/vic-property-check/`. See `skill/INSTALL.md` for the
+full install + auth walkthrough.
+
+## License
+
+MIT.

vicpropertycheck-0.1.1/pyproject.toml

@@ -0,0 +1,84 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vicpropertycheck"
+version = "0.1.1"
+description = "Victorian property due diligence — MCP server, CLI, and skill backend (planning, bushfire, crime, housing, facilities)"
+authors = [{ name = "Roger Liu", email = "zichengliu0226@gmail.com" }]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.13.2"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+]
+
+dependencies = [
+    "mcp>=1.25.0",
+    "pydantic>=2.12.5",
+    "httpx>=0.28.1",
+    "shapely>=2.0.6",
+    "pyproj>=3.7.0",
+    "python-dotenv>=1.0.1",
+    "structlog>=24.4.0",
+    "aiosqlite>=0.20.0",
+    "tenacity>=9.0.0",
+    "typing-extensions>=4.12.2",
+    "email-validator>=2.2.0",
+    "uvicorn>=0.40.0",
+    "starlette>=0.50.0",
+    "sse-starlette>=2.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.2.0,<8.3",
+    "pytest-asyncio>=0.24.0",
+    "pytest-cov>=6.0.0",
+    "black>=24.10.0",
+    "isort>=5.13.2",
+    "flake8>=7.1.1",
+    "mypy>=1.13.0",
+    "pylint>=3.3.2",
+    "pylint-pydantic>=0.3.2",
+    "pylint-pytest>=1.1.8",
+    "pre-commit>=4.0.1",
+]
+
+[project.scripts]
+vic-property-mcp = "vic_property_mcp.server:main"
+vic-property = "vic_property_mcp.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.black]
+line-length = 88
+target-version = ['py313']
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+
+[tool.mypy]
+python_version = "3.13"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "--cov=src/vic_property_mcp --cov-report=html --cov-report=term-missing"
+
+# Pylint configuration
+[tool.pylint.main]
+load-plugins = ["pylint_pydantic", "pylint_pytest"]
+py-version = "3.13"

vicpropertycheck-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vicpropertycheck-0.1.1/src/vic_property_mcp/__init__.py

@@ -0,0 +1,16 @@
+"""VIC Property Due Diligence MCP Server."""
+
+from .config import get_settings
+from .server import mcp
+
+__version__ = "0.1.0"
+__title__ = "VIC Property Due Diligence MCP Server"
+__description__ = "MCP server for Victorian property due diligence research"
+
+__all__ = [
+    "mcp",
+    "get_settings",
+    "__version__",
+    "__title__",
+    "__description__",
+]

vicpropertycheck-0.1.1/src/vic_property_mcp/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running the VIC Property MCP Server as a module."""
+
+from .server import main
+
+if __name__ == "__main__":
+    main()

vicpropertycheck-0.1.1/src/vic_property_mcp/cli.py

@@ -0,0 +1,412 @@
+"""Command-line interface for VIC Property Due Diligence.
+
+Each subcommand maps 1:1 to one of the tools the MCP server exposes.
+The CLI shares the provider stack, cache, and configuration with the server,
+so behaviour is identical — only the transport differs.
+
+Designed to back a Claude Code skill: stable JSON on stdout, errors on
+stderr, non-zero exit on failure.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Optional
+
+from vic_property_mcp.config.settings import get_settings
+from vic_property_mcp.exceptions import ConfigurationError, PropertyMCPError
+from vic_property_mcp.providers.google_geocoding import GoogleGeocodingProvider
+from vic_property_mcp.providers.google_places_facilities import (
+    GooglePlacesFacilitiesProvider,
+)
+from vic_property_mcp.providers.google_places_nearby import GooglePlacesNearbyProvider
+from vic_property_mcp.providers.hosted_proxy import (
+    CREDENTIALS_FILE,
+    HostedProxyCredentials,
+    _exchange_custom_token_for_id_token,
+)
+from vic_property_mcp.providers.openstats_crime import OpenStatsCrimeProvider
+from vic_property_mcp.providers.openstats_housing import OpenStatsHousingProvider
+from vic_property_mcp.providers.vicmap_bushfire import VicMapBushfireProvider
+from vic_property_mcp.providers.vicmap_planning import VicMapPlanningProvider
+from vic_property_mcp.utils.cache import get_cache_manager
+from vic_property_mcp.utils.logging import configure_logging
+
+
+@dataclass
+class Providers:
+    """Bundle of initialised providers held for the lifetime of one CLI invocation."""
+
+    geocoding: GoogleGeocodingProvider
+    planning: VicMapPlanningProvider
+    bushfire: VicMapBushfireProvider
+    housing: OpenStatsHousingProvider
+    crime: OpenStatsCrimeProvider
+    places_nearby: GooglePlacesNearbyProvider
+    places_facilities: GooglePlacesFacilitiesProvider
+
+    async def close(self) -> None:
+        for provider in (
+            self.geocoding,
+            self.planning,
+            self.bushfire,
+            self.housing,
+            self.crime,
+            self.places_nearby,
+            self.places_facilities,
+        ):
+            try:
+                await provider.close()
+            except Exception:  # noqa: BLE001 — best-effort cleanup
+                pass
+
+
+def _build_providers() -> Providers:
+    settings = get_settings()
+    cache_manager = get_cache_manager()
+
+    if not settings.api.google_maps_api_key:
+        # Hosted-proxy fallback is wired in providers/google_*.py via the
+        # GOOGLE_MAPS_API_KEY-or-proxy mode switch; if neither is configured
+        # the providers themselves will raise a clear error at request time.
+        pass
+
+    return Providers(
+        geocoding=GoogleGeocodingProvider(
+            base_url=settings.api.google_maps_base_url,
+            api_key=settings.api.google_maps_api_key,
+            cache_manager=cache_manager,
+            timeout=settings.api.timeout,
+            cache_ttl=settings.cache.google_maps_geocoding_ttl,
+        ),
+        planning=VicMapPlanningProvider(
+            base_url=settings.api.vicmap_planning_base_url,
+            cache_manager=cache_manager,
+            timeout=settings.api.timeout,
+            cache_ttl=settings.cache.planning_ttl,
+        ),
+        bushfire=VicMapBushfireProvider(
+            base_url=settings.api.vicmap_planning_base_url,
+            cache_manager=cache_manager,
+            timeout=settings.api.timeout,
+            cache_ttl=settings.cache.bushfire_ttl,
+        ),
+        housing=OpenStatsHousingProvider(
+            base_url=settings.api.open_stats_base_url,
+            cache_manager=cache_manager,
+            timeout=settings.api.timeout,
+            cache_ttl=settings.cache.openstats_ttl,
+        ),
+        crime=OpenStatsCrimeProvider(
+            base_url=settings.api.open_stats_base_url,
+            cache_manager=cache_manager,
+            timeout=settings.api.timeout,
+            cache_ttl=settings.cache.openstats_ttl,
+        ),
+        places_nearby=GooglePlacesNearbyProvider(
+            api_key=settings.api.google_maps_api_key,
+            cache_manager=cache_manager,
+            timeout=settings.api.timeout,
+            cache_ttl=settings.cache.google_places_ttl,
+        ),
+        places_facilities=GooglePlacesFacilitiesProvider(
+            api_key=settings.api.google_maps_api_key,
+            cache_manager=cache_manager,
+            timeout=settings.api.timeout,
+            cache_ttl=settings.cache.google_places_ttl,
+        ),
+    )
+
+
+# -----------------------------------------------------------------------------
+# Command implementations
+# -----------------------------------------------------------------------------
+
+
+async def cmd_resolve_address(p: Providers, args: argparse.Namespace) -> dict[str, Any]:
+    result = await p.geocoding.geocode_address(args.address)
+    if result is None:
+        return {"error": "Address could not be geocoded", "code": "NOT_FOUND"}
+    return result.model_dump()
+
+
+async def cmd_planning(p: Providers, args: argparse.Namespace) -> dict[str, Any]:
+    result = await p.planning.get_planning_info(args.lat, args.lon)
+    return result.model_dump()
+
+
+async def cmd_bushfire(p: Providers, args: argparse.Namespace) -> dict[str, Any]:
+    result = await p.bushfire.get_bushfire_info(args.lat, args.lon)
+    return result.model_dump()
+
+
+async def cmd_housing(p: Providers, args: argparse.Namespace) -> dict[str, Any]:
+    result = await p.housing.get_suburb_housing_stats(args.suburb)
+    payload = result.model_dump()
+    if args.lat is not None and args.lon is not None:
+        try:
+            nearby = await p.places_nearby.search_nearby_public_housing(
+                args.lat, args.lon, max_results=5
+            )
+            payload["nearby_public_housing"] = nearby.model_dump()
+        except Exception as exc:  # noqa: BLE001
+            payload["nearby_public_housing_error"] = str(exc)
+    return payload
+
+
+async def cmd_crime(p: Providers, args: argparse.Namespace) -> dict[str, Any]:
+    result = await p.crime.get_suburb_crime_stats(args.suburb)
+    return result.model_dump()
+
+
+async def cmd_facilities(p: Providers, args: argparse.Namespace) -> dict[str, Any]:
+    result = await p.places_facilities.search_nearby_facilities(
+        args.lat,
+        args.lon,
+        radius_m=args.radius_m,
+        max_per_category=args.max_per_category,
+    )
+    return result.model_dump()
+
+
+async def cmd_login(_p: Providers, args: argparse.Namespace) -> dict[str, Any]:
+    """Persist hosted-proxy credentials minted by the web /skill-auth page.
+
+    The user pastes the JSON blob the web page printed. We validate it, exchange
+    the custom token for an ID + refresh token, and write everything to
+    ~/.config/vicpropertycheck/credentials.json (mode 0600).
+    """
+    raw = args.credentials
+    if raw == "-" or not raw:
+        raw = sys.stdin.read()
+
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        return {
+            "error": f"Could not parse credentials JSON: {exc}",
+            "code": "INVALID_INPUT",
+        }
+
+    required = ("customToken", "apiKey", "proxyBaseUrl")
+    missing = [key for key in required if not payload.get(key)]
+    if missing:
+        return {
+            "error": f"Missing required fields: {', '.join(missing)}",
+            "code": "INVALID_INPUT",
+        }
+
+    creds = HostedProxyCredentials(
+        custom_token=payload["customToken"],
+        api_key=payload["apiKey"],
+        proxy_base_url=str(payload["proxyBaseUrl"]).rstrip("/"),
+        uid=payload.get("uid"),
+        email=payload.get("email"),
+    )
+
+    # Verify the credentials work BEFORE writing them to disk so the user gets
+    # an immediate error if they pasted something stale.
+    import httpx as _httpx
+
+    async with _httpx.AsyncClient() as client:
+        await _exchange_custom_token_for_id_token(client, creds)
+
+    creds.save()
+    return {
+        "ok": True,
+        "credentials_file": str(CREDENTIALS_FILE),
+        "uid": creds.uid,
+        "email": creds.email,
+    }
+
+
+async def cmd_summarize(p: Providers, args: argparse.Namespace) -> dict[str, Any]:
+    geocoding = await p.geocoding.geocode_address(args.address)
+    if geocoding is None:
+        return {"error": "Address could not be geocoded", "code": "NOT_FOUND"}
+
+    planning = await p.planning.get_planning_info(geocoding.lat, geocoding.lon)
+    bushfire = await p.bushfire.get_bushfire_info(geocoding.lat, geocoding.lon)
+
+    suburb = geocoding.suburb
+    housing: dict[str, Any] = {}
+    if suburb:
+        housing = (await p.housing.get_suburb_housing_stats(suburb)).model_dump()
+
+    try:
+        nearby_housing = await p.places_nearby.search_nearby_public_housing(
+            geocoding.lat, geocoding.lon, max_results=5
+        )
+        housing["nearby_public_housing"] = nearby_housing.model_dump()
+    except Exception as exc:  # noqa: BLE001 — non-fatal
+        housing["nearby_public_housing_error"] = str(exc)
+
+    facilities_payload: dict[str, Any] | None
+    try:
+        facilities = await p.places_facilities.search_nearby_facilities(
+            geocoding.lat, geocoding.lon
+        )
+        facilities_payload = facilities.model_dump()
+    except Exception as exc:  # noqa: BLE001 — non-fatal
+        facilities_payload = {"error": str(exc)}
+
+    crime: dict[str, Any] = {}
+    if suburb:
+        crime = (await p.crime.get_suburb_crime_stats(suburb)).model_dump()
+
+    return {
+        "address": geocoding.model_dump(),
+        "planning": planning.model_dump(),
+        "bushfire": bushfire.model_dump(),
+        "housing": housing,
+        "facilities": facilities_payload,
+        "crime": crime,
+    }
+
+
+# -----------------------------------------------------------------------------
+# Argument parsing
+# -----------------------------------------------------------------------------
+
+
+CommandHandler = Callable[[Providers, argparse.Namespace], Awaitable[dict[str, Any]]]
+
+
+def _build_parser() -> tuple[argparse.ArgumentParser, dict[str, CommandHandler]]:
+    parser = argparse.ArgumentParser(
+        prog="vic-property",
+        description="Victorian property due-diligence CLI (planning, bushfire, "
+        "crime, housing, facilities). Backs the vic-property-check Claude skill.",
+    )
+    parser.add_argument(
+        "--pretty",
+        action="store_true",
+        help="Indent JSON output for readability.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True, metavar="<command>")
+
+    handlers: dict[str, CommandHandler] = {}
+
+    resolve = sub.add_parser(
+        "resolve-address",
+        help="Geocode a Victorian address to lat/lon plus suburb/postcode.",
+    )
+    resolve.add_argument("--address", required=True)
+    handlers["resolve-address"] = cmd_resolve_address
+
+    planning = sub.add_parser(
+        "planning", help="Planning zones and overlays at a coordinate."
+    )
+    planning.add_argument("--lat", type=float, required=True)
+    planning.add_argument("--lon", type=float, required=True)
+    handlers["planning"] = cmd_planning
+
+    bushfire = sub.add_parser(
+        "bushfire", help="Bushfire management overlays and prone areas."
+    )
+    bushfire.add_argument("--lat", type=float, required=True)
+    bushfire.add_argument("--lon", type=float, required=True)
+    handlers["bushfire"] = cmd_bushfire
+
+    housing = sub.add_parser(
+        "housing",
+        help="Housing stock breakdown for a suburb (private rental / owner / public).",
+    )
+    housing.add_argument("--suburb", required=True)
+    housing.add_argument("--lat", type=float, default=None)
+    housing.add_argument("--lon", type=float, default=None)
+    handlers["housing"] = cmd_housing
+
+    crime = sub.add_parser("crime", help="Crime statistics for a suburb.")
+    crime.add_argument("--suburb", required=True)
+    handlers["crime"] = cmd_crime
+
+    facilities = sub.add_parser(
+        "facilities", help="Transport, shops, and schools near a coordinate."
+    )
+    facilities.add_argument("--lat", type=float, required=True)
+    facilities.add_argument("--lon", type=float, required=True)
+    facilities.add_argument("--radius-m", dest="radius_m", type=int, default=2000)
+    facilities.add_argument(
+        "--max-per-category", dest="max_per_category", type=int, default=5
+    )
+    handlers["facilities"] = cmd_facilities
+
+    summarize = sub.add_parser(
+        "summarize",
+        help="Run every tool and return a combined property report (one address in, "
+        "one report out).",
+    )
+    summarize.add_argument("--address", required=True)
+    handlers["summarize"] = cmd_summarize
+
+    login = sub.add_parser(
+        "login",
+        help="Save hosted-proxy credentials. Paste the JSON blob the web "
+        "/skill-auth page generated, or pipe it via stdin.",
+    )
+    login.add_argument(
+        "--credentials",
+        default="-",
+        help="Credentials JSON (or '-' to read stdin, the default).",
+    )
+    handlers["login"] = cmd_login
+
+    return parser, handlers
+
+
+# -----------------------------------------------------------------------------
+# Entry point
+# -----------------------------------------------------------------------------
+
+
+async def _run(args: argparse.Namespace, handler: CommandHandler) -> int:
+    # `login` doesn't need the provider stack — it only writes the credentials
+    # file. Calling _build_providers() would fail in proxy-only mode where the
+    # user is precisely _trying_ to set up credentials.
+    providers: Optional[Providers] = None
+    if args.command != "login":
+        providers = _build_providers()
+    try:
+        payload = await handler(providers, args)  # type: ignore[arg-type]
+    except PropertyMCPError as exc:
+        json.dump({"error": str(exc), "code": exc.code.value}, sys.stdout)
+        sys.stdout.write("\n")
+        return 1
+    except ConfigurationError as exc:
+        print(f"Configuration error: {exc}", file=sys.stderr)
+        return 2
+    except Exception as exc:  # noqa: BLE001 — surface anything we missed
+        print(f"Unexpected error: {exc}", file=sys.stderr)
+        return 1
+    finally:
+        if providers is not None:
+            await providers.close()
+
+    indent = 2 if args.pretty else None
+    json.dump(payload, sys.stdout, indent=indent, default=str)
+    sys.stdout.write("\n")
+    return 0 if "error" not in payload else 1
+
+
+def main() -> None:
+    # Default the CLI to WARNING so the structured JSON output isn't drowned out by
+    # provider INFO logs. Users can opt back in via the existing
+    # VIC_PROPERTY_LOGGING__LEVEL env var.
+    import os
+
+    os.environ.setdefault("VIC_PROPERTY_LOGGING__LEVEL", "WARNING")
+    configure_logging()
+    parser, handlers = _build_parser()
+    args = parser.parse_args()
+    handler = handlers[args.command]
+    exit_code = asyncio.run(_run(args, handler))
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()