xgic-dev-cli 0.2.0__py3-none-any.whl

xgic/cli/dev/__init__.py

@@ -0,0 +1,10 @@
+"""XGIC CLI Dev Container module (``xgic.cli.dev``)."""
+
+from xgic.cli.dev.docker import DockerComposeController
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "DockerComposeController",
+    "__version__",
+]

xgic/cli/dev/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command handlers for ``xgic.cli.dev``."""

xgic/cli/dev/commands/check.py

@@ -0,0 +1,49 @@
+"""Health check command (product-agnostic)."""
+
+from __future__ import annotations
+
+import json
+
+from xgic.cli.app import CommandContext
+from xgic.cli.dev.context import make_docker
+from xgic.cli.utils.output import print_info, print_success, print_warning
+
+
+def run_check(ctx: CommandContext) -> int:
+    """Lightweight compose + environment health check."""
+    docker = make_docker(ctx.env, ctx.args)
+    services_ok = docker.services_running()
+    use_json = bool(getattr(ctx.args, "json", False))
+
+    if use_json:
+        result = {
+            "services_running": services_ok,
+            "compose_file": docker.compose_file,
+            "project_name": docker.project_name,
+            "primary_service": docker.primary_service,
+            "environment": ctx.env.describe(),
+            "overall_ok": services_ok,
+        }
+        print(json.dumps(result, indent=2))
+        return 0 if services_ok else 1
+
+    print_info("Running environment health checks...")
+
+    if services_ok:
+        print_success("Docker Compose services: running")
+    else:
+        print_warning(
+            "Docker Compose services: not all services appear to be running"
+        )
+        print_info("Suggestion: Run `xgic up` to start services.")
+
+    print_info(f"Compose file: {docker.compose_file}")
+    print_info(f"Project: {docker.project_name}")
+    if docker.primary_service:
+        print_info(f"Primary service: {docker.primary_service}")
+    print_info("Environment context: " + ctx.env.describe())
+
+    if services_ok:
+        print_success("Basic environment check passed")
+        return 0
+    return 1

xgic/cli/dev/commands/env_cmd.py

@@ -0,0 +1,53 @@
+"""Environment status command (product-agnostic; no product secrets)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from xgic.cli.app import CommandContext
+from xgic.cli.dev.context import make_docker
+from xgic.cli.utils.output import print_info, print_success
+
+ENV_FILE = Path(".devcontainer/.env")
+
+
+def run_env(ctx: CommandContext) -> int:
+    """Inspect development environment status (no regenerate in this module)."""
+    docker = make_docker(ctx.env, ctx.args)
+    env_file_exists = ENV_FILE.exists()
+    services_ok = docker.services_running()
+    use_json = bool(getattr(ctx.args, "json", False))
+
+    if use_json:
+        print(
+            json.dumps(
+                {
+                    "env_file_exists": env_file_exists,
+                    "env_file": str(ENV_FILE),
+                    "services_running": services_ok,
+                    "compose_file": docker.compose_file,
+                    "project_name": docker.project_name,
+                    "primary_service": docker.primary_service,
+                    "environment": ctx.env.describe(),
+                },
+                indent=2,
+            )
+        )
+        return 0
+
+    print_info("Development environment status:")
+    if env_file_exists:
+        print_success(f".env file exists at {ENV_FILE}")
+    else:
+        print_info(f".env file not found at {ENV_FILE}")
+
+    if services_ok:
+        print_success("Compose services: appear to be running")
+    else:
+        print_info("Compose services: not detected as running")
+
+    print_info(f"Compose file: {docker.compose_file}")
+    print_info(f"Project: {docker.project_name}")
+    print_info("Environment context: " + ctx.env.describe())
+    return 0

xgic/cli/dev/commands/lifecycle.py

@@ -0,0 +1,97 @@
+"""Lifecycle commands: up, down, build, logs, shell, clean."""
+
+from __future__ import annotations
+
+import contextlib
+from pathlib import Path
+
+from xgic.cli.app import CommandContext
+from xgic.cli.dev.context import make_docker, resolve_profile
+from xgic.cli.utils.output import print_info, print_success, print_warning
+
+ENV_FILE = Path(".devcontainer/.env")
+
+
+def run_up(ctx: CommandContext) -> int:
+    """Start compose services in detached mode."""
+    docker = make_docker(ctx.env, ctx.args)
+    profile = resolve_profile(ctx.args)
+    print_info("Starting services...")
+    docker.up(profile=profile)
+    print_success("Services are up (detached)")
+    return 0
+
+
+def run_down(ctx: CommandContext) -> int:
+    """Stop services (volumes preserved)."""
+    docker = make_docker(ctx.env, ctx.args)
+    print_info("Stopping services...")
+    docker.down()
+    print_success("Services stopped (volumes preserved)")
+    return 0
+
+
+def run_build(ctx: CommandContext) -> int:
+    """Build compose images."""
+    docker = make_docker(ctx.env, ctx.args)
+    no_cache = bool(getattr(ctx.args, "no_cache", False))
+    print_info("Building services" + (" (no cache)" if no_cache else "") + "...")
+    docker.build(no_cache=no_cache)
+    print_success("Build complete")
+    return 0
+
+
+def run_logs(ctx: CommandContext) -> int:
+    """Follow logs for all services (blocks until interrupted)."""
+    docker = make_docker(ctx.env, ctx.args)
+    print_info("Following logs (press Ctrl+C to exit)...")
+    docker.logs(follow=True)
+    return 0
+
+
+def run_shell(ctx: CommandContext) -> int:
+    """Open an interactive shell in the primary service."""
+    docker = make_docker(ctx.env, ctx.args)
+    service = docker.primary_service
+    if not service:
+        print_warning(
+            "No primary service set. Pass --service NAME or set "
+            "XGIC_PRIMARY_SERVICE."
+        )
+        return 1
+    print_info(f"Opening shell in service {service!r} (type 'exit' to leave)...")
+    try:
+        docker.exec(service, "bash")
+    except Exception:
+        print_info("Shell session ended or failed to attach.")
+    return 0
+
+
+def run_clean(ctx: CommandContext) -> int:
+    """Full environment cleanup (volumes + .env). Extremely destructive."""
+    docker = make_docker(ctx.env, ctx.args)
+    yes = bool(getattr(ctx.args, "yes", False))
+
+    print_warning(
+        "This will delete Docker volumes AND the generated .env file "
+        f"(if present at {ENV_FILE})."
+    )
+    if not yes:
+        print_warning("Re-run with --yes only if you are absolutely sure.")
+        return 1
+
+    print_info("Performing full cleanup...")
+    try:
+        docker.down(remove_volumes=True)
+    except Exception:
+        with contextlib.suppress(Exception):
+            docker.down()
+
+    if ENV_FILE.exists():
+        ENV_FILE.unlink()
+        print_success(f"Removed {ENV_FILE}")
+
+    print_success(
+        "Full cleanup complete. You will need to re-initialize the environment."
+    )
+    return 0

xgic/cli/dev/context.py

@@ -0,0 +1,54 @@
+"""Build a DockerComposeController from CLI args / environment."""
+
+from __future__ import annotations
+
+import argparse
+import os
+
+from xgic.cli.core.environment import EnvironmentContext
+from xgic.cli.dev.docker import (
+    DEFAULT_COMPOSE_FILE,
+    DEFAULT_PROJECT_NAME,
+    DockerComposeController,
+)
+
+ENV_COMPOSE_FILE = "XGIC_COMPOSE_FILE"
+ENV_COMPOSE_PROJECT = "XGIC_COMPOSE_PROJECT"
+ENV_PRIMARY_SERVICE = "XGIC_PRIMARY_SERVICE"
+ENV_COMPOSE_PROFILE = "XGIC_COMPOSE_PROFILE"
+
+
+def resolve_compose_file(args: argparse.Namespace) -> str:
+    return (
+        getattr(args, "compose_file", None)
+        or os.environ.get(ENV_COMPOSE_FILE)
+        or DEFAULT_COMPOSE_FILE
+    )
+
+
+def resolve_project_name(args: argparse.Namespace) -> str:
+    return (
+        getattr(args, "project", None)
+        or os.environ.get(ENV_COMPOSE_PROJECT)
+        or DEFAULT_PROJECT_NAME
+    )
+
+
+def resolve_primary_service(args: argparse.Namespace) -> str | None:
+    return getattr(args, "service", None) or os.environ.get(ENV_PRIMARY_SERVICE)
+
+
+def resolve_profile(args: argparse.Namespace) -> str | None:
+    return getattr(args, "profile", None) or os.environ.get(ENV_COMPOSE_PROFILE)
+
+
+def make_docker(
+    env: EnvironmentContext, args: argparse.Namespace
+) -> DockerComposeController:
+    """Construct a controller from CommandContext-compatible args."""
+    return DockerComposeController(
+        env=env,
+        compose_file=resolve_compose_file(args),
+        project_name=resolve_project_name(args),
+        primary_service=resolve_primary_service(args),
+    )

xgic/cli/dev/docker.py

@@ -0,0 +1,150 @@
+"""Docker Compose orchestration for Dev Container environments.
+
+Product-agnostic Compose controller. Callers inject compose file, project
+name, primary service, and optional profile. Payload CMS–specific defaults
+and config readers live in ``xgic.cli.payload`` (xgic/payload-cms-cli).
+"""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+
+from xgic.cli.core.environment import EnvironmentContext
+
+DEFAULT_COMPOSE_FILE = ".devcontainer/docker-compose.yml"
+DEFAULT_PROJECT_NAME = "xgic-dev"
+
+
+@dataclass
+class DockerComposeController:
+    """Controls Docker Compose services for a dev environment."""
+
+    env: EnvironmentContext
+    compose_file: str = DEFAULT_COMPOSE_FILE
+    project_name: str = DEFAULT_PROJECT_NAME
+    primary_service: str | None = None
+
+    def _run_compose(
+        self,
+        *args: str,
+        check: bool = True,
+        capture_output: bool = False,
+    ) -> subprocess.CompletedProcess[str]:
+        """Run a docker compose command with consistent flags."""
+        cmd = [
+            "docker",
+            "compose",
+            "-f",
+            self.compose_file,
+            "-p",
+            self.project_name,
+            *args,
+        ]
+        return subprocess.run(
+            cmd,
+            check=check,
+            capture_output=capture_output,
+            text=True,
+        )
+
+    def services_running(self, service: str | None = None) -> bool:
+        """Return True if a target service (or any) appears to be up."""
+        target = service or self.primary_service
+        try:
+            result = self._run_compose(
+                "ps",
+                "--services",
+                "--filter",
+                "status=running",
+                capture_output=True,
+            )
+            running = {s.strip() for s in result.stdout.splitlines() if s.strip()}
+            if not running:
+                return False
+            if target is None:
+                return True
+            return target in running
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def up(
+        self,
+        *,
+        build: bool = False,
+        services: list[str] | None = None,
+        profile: str | None = None,
+    ) -> None:
+        """Start services in detached mode."""
+        args: list[str] = []
+        if profile:
+            args.extend(["--profile", profile])
+        args.extend(["up", "-d"])
+        if build:
+            args.append("--build")
+        if services:
+            args.extend(services)
+        self._run_compose(*args)
+
+    def down(self, *, remove_volumes: bool = False) -> None:
+        """Stop services. Optionally remove named volumes (destructive)."""
+        if remove_volumes:
+            self._run_compose("down", "-v")
+        else:
+            self._run_compose("down")
+
+    def rm_service(
+        self,
+        service: str,
+        *,
+        force: bool = True,
+        stop: bool = True,
+        remove_volumes: bool = False,
+    ) -> None:
+        """Best-effort compose rm for a single service."""
+        args = ["rm"]
+        if force:
+            args.append("-f")
+        if stop:
+            args.append("-s")
+        if remove_volumes:
+            args.append("-v")
+        args.append(service)
+        self._run_compose(*args, check=False)
+
+    def build(self, *, no_cache: bool = False) -> None:
+        """Build images."""
+        args = ["build"]
+        if no_cache:
+            args.append("--no-cache")
+        self._run_compose(*args)
+
+    def logs(self, follow: bool = True) -> None:
+        """Follow logs (this blocks)."""
+        args = ["logs"]
+        if follow:
+            args.append("-f")
+        self._run_compose(*args, check=False)
+
+    def exec(
+        self, service: str, *cmd: str, check: bool = True
+    ) -> subprocess.CompletedProcess[str]:
+        """Run a command inside a service container."""
+        return self._run_compose("exec", service, *cmd, check=check)
+
+    def remove_volume(self, volume_name: str) -> bool:
+        """Attempt to remove a Docker volume via top-level docker CLI."""
+        try:
+            result = subprocess.run(
+                ["docker", "volume", "rm", "-f", volume_name],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+    def db_volume_name(self, service: str) -> str:
+        """Return the conventional named volume for a DB service."""
+        return f"{self.project_name}-{service}-data"

xgic/cli/dev/plugin.py

@@ -0,0 +1,124 @@
+"""Register ``xgic.cli.dev`` subcommands on the core ``xgic`` CLI."""
+
+from __future__ import annotations
+
+import argparse
+
+from xgic.cli.dev.commands.check import run_check
+from xgic.cli.dev.commands.env_cmd import run_env
+from xgic.cli.dev.commands.lifecycle import (
+    run_build,
+    run_clean,
+    run_down,
+    run_logs,
+    run_shell,
+    run_up,
+)
+
+
+def _common_parent() -> argparse.ArgumentParser:
+    parent = argparse.ArgumentParser(add_help=False)
+    parent.add_argument(
+        "--compose-file",
+        metavar="PATH",
+        help="Compose file path (or XGIC_COMPOSE_FILE)",
+    )
+    parent.add_argument(
+        "--project",
+        metavar="NAME",
+        help="Compose project name (or XGIC_COMPOSE_PROJECT)",
+    )
+    parent.add_argument(
+        "--service",
+        metavar="NAME",
+        help="Primary compose service (or XGIC_PRIMARY_SERVICE)",
+    )
+    parent.add_argument(
+        "--profile",
+        metavar="NAME",
+        help="Compose profile for up (or XGIC_COMPOSE_PROFILE)",
+    )
+    return parent
+
+
+def register(
+    subparsers: argparse._SubParsersAction[argparse.ArgumentParser],
+) -> None:
+    """Entry point: ``xgic.cli.commands`` → register Dev Container commands."""
+    parent = _common_parent()
+
+    up = subparsers.add_parser(
+        "up",
+        parents=[parent],
+        help="Start Docker Compose services (detached)",
+    )
+    up.set_defaults(func=run_up)
+
+    down = subparsers.add_parser(
+        "down",
+        parents=[parent],
+        help="Stop Docker Compose services (volumes preserved)",
+    )
+    down.set_defaults(func=run_down)
+
+    build = subparsers.add_parser(
+        "build",
+        parents=[parent],
+        help="Build or rebuild compose services",
+    )
+    build.add_argument(
+        "--no-cache",
+        action="store_true",
+        help="Build without cache",
+    )
+    build.set_defaults(func=run_build)
+
+    logs = subparsers.add_parser(
+        "logs",
+        parents=[parent],
+        help="Follow logs for compose services",
+    )
+    logs.set_defaults(func=run_logs)
+
+    shell = subparsers.add_parser(
+        "shell",
+        parents=[parent],
+        help="Open a shell in the primary service",
+    )
+    shell.set_defaults(func=run_shell)
+
+    clean = subparsers.add_parser(
+        "clean",
+        parents=[parent],
+        help="[DANGER] Full cleanup (volumes + .devcontainer/.env)",
+    )
+    clean.add_argument(
+        "--yes",
+        action="store_true",
+        help="Skip confirmation and proceed",
+    )
+    clean.set_defaults(func=run_clean)
+
+    check = subparsers.add_parser(
+        "check",
+        parents=[parent],
+        help="Diagnostic: compose services + environment context",
+    )
+    check.add_argument(
+        "--json",
+        action="store_true",
+        help="Output results as JSON",
+    )
+    check.set_defaults(func=run_check)
+
+    env_p = subparsers.add_parser(
+        "env",
+        parents=[parent],
+        help="Inspect development environment status",
+    )
+    env_p.add_argument(
+        "--json",
+        action="store_true",
+        help="Output results as JSON",
+    )
+    env_p.set_defaults(func=run_env)

xgic_dev_cli-0.2.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: xgic-dev-cli
+Version: 0.2.0
+Summary: XGIC CLI Dev Container module - Docker Compose orchestration and xgic lifecycle commands (xgic.cli.dev).
+Project-URL: Homepage, https://github.com/xgic/dev-cli
+Project-URL: Repository, https://github.com/xgic/dev-cli
+Project-URL: Issues, https://github.com/xgic/dev-cli/issues
+Project-URL: Documentation, https://github.com/xgic/dev-cli#readme
+Project-URL: Changelog, https://github.com/xgic/dev-cli/releases
+Author: XGIC
+License: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: cli,dev-containers,docker-compose,orchestration,xgic
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Requires-Dist: rich>=13.7
+Requires-Dist: xgic-cli>=0.2.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest>=8.0.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# XGIC Dev Container CLI
+
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+**XGIC Dev Container CLI** (`xgic.cli.dev`) provides Docker Compose orchestration and Dev Container–oriented **`xgic` subcommands** for the modular [XGIC CLI](https://github.com/xgic/cli).
+
+Architecture: [ADR-0005](https://github.com/xgic/ai/blob/main/docs/adr/0005-modular-xgic-cli-and-retirement-of-xde.md).
+
+**Publishing to PyPI:** [python-package-release.md](https://github.com/xgic/ai/blob/main/docs/python-package-release.md)  
+(publish **after** `xgic-cli` for stack releases). Tags: `vX.Y.ZrcN` → TestPyPI; `vX.Y.Z` → PyPI.
+
+| Package | Role |
+|---------|------|
+| [xgic/cli](https://github.com/xgic/cli) | Thin core framework (`xgic`) |
+| **This repo** | Dev Container / Compose + lifecycle commands (`xgic.cli.dev`) |
+| [xgic/payload-cms-cli](https://github.com/xgic/payload-cms-cli) | Payload CMS product module |
+
+## Status
+
+**0.2.0 — B3 lifecycle commands.** Product-agnostic Compose library + registered `xgic` subcommands. Payload CMS–specific env regenerate / setup remains in **payload-cms-cli**.
+
+## Requirements
+
+- Python **3.14+**
+- `xgic-cli` ≥ 0.2.0
+- Docker / Docker Compose on the host when running lifecycle commands
+
+## Install (development)
+
+```bash
+python -m pip install -e ../cli
+python -m pip install -e ".[dev]"
+xgic --help
+xgic up --help
+```
+
+## Console commands (via entry point)
+
+Installed with this package, registered on the core `xgic` entrypoint:
+
+| Command | Purpose |
+|---------|---------|
+| `xgic up` | Start compose services (detached) |
+| `xgic down` | Stop services (volumes preserved) |
+| `xgic build [--no-cache]` | Build images |
+| `xgic logs` | Follow logs |
+| `xgic shell` | Shell in primary service (`--service` required if not set) |
+| `xgic clean --yes` | Destructive: volumes + `.devcontainer/.env` |
+| `xgic check [--json]` | Services + environment diagnostic |
+| `xgic env [--json]` | Environment status (no secret regeneration) |
+
+Common flags (or env vars):
+
+| Flag | Env var | Default |
+|------|---------|---------|
+| `--compose-file` | `XGIC_COMPOSE_FILE` | `.devcontainer/docker-compose.yml` |
+| `--project` | `XGIC_COMPOSE_PROJECT` | `xgic-dev` |
+| `--service` | `XGIC_PRIMARY_SERVICE` | (none) |
+| `--profile` | `XGIC_COMPOSE_PROFILE` | (none; used by `up`) |
+
+## Library API
+
+```python
+from xgic.cli.core import EnvironmentContext
+from xgic.cli.dev import DockerComposeController
+
+env = EnvironmentContext.detect()
+docker = DockerComposeController(
+    env=env,
+    compose_file=".devcontainer/docker-compose.yml",
+    project_name="my-project",
+    primary_service="app",
+)
+docker.up(profile="postgres")
+```
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE) and [NOTICE](NOTICE).  
+Copyright form: `Copyright 2026 XGIC`.

xgic_dev_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+xgic/cli/dev/__init__.py,sha256=UG_9wgAH70pj0O4fblqblaaqvqryNyBWofTgJyx2MF0,201
+xgic/cli/dev/context.py,sha256=eB0i_JxK36KK7QXNWUzaW37x4ovjnDqGSu4iQxfWlqk,1559
+xgic/cli/dev/docker.py,sha256=Y7ItPX0y-NK5WeVfaTjM7Cr8lWeM9npKm_MyaEw0HPI,4601
+xgic/cli/dev/plugin.py,sha256=NMHjZMQE1AgcpaKaeE25IKnZep9mPqt-nPqNYL89bvM,3150
+xgic/cli/dev/commands/__init__.py,sha256=5lOhgVwx4xmVH3Dh3LVUyJRo32_5PvsGiYtpF5EvehA,49
+xgic/cli/dev/commands/check.py,sha256=90Y7tzLigattFYbPthUBIcqGLUxPPrQ_FjHIDIGgJrU,1608
+xgic/cli/dev/commands/env_cmd.py,sha256=tprO1TQZ6H8_lpf1JGgz0kafWpB4xYmWI7aHSkzM4n4,1725
+xgic/cli/dev/commands/lifecycle.py,sha256=5V-9xBDjYzErUGSJ8yV6UtToJ3ZkTAOA5KH3U6Ia4Es,2980
+xgic_dev_cli-0.2.0.dist-info/METADATA,sha256=SoqzdnnfUG09I4v1EKfTJH3owQq_zzb9pxiSAKXLUAw,4237
+xgic_dev_cli-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+xgic_dev_cli-0.2.0.dist-info/entry_points.txt,sha256=3EVsANu-jdvfn_Zq4CCNPcEBjF7cCzobGGofHDXobMc,55
+xgic_dev_cli-0.2.0.dist-info/licenses/LICENSE,sha256=zR7vJ5cGf_9LgWHYDAugptsXPsV0_78I9kvVnf7VRk0,11335
+xgic_dev_cli-0.2.0.dist-info/licenses/NOTICE,sha256=TPf1ugOAPqcue1tS2cRBATyLbw3XoQ2vm1MigrheSiU,214
+xgic_dev_cli-0.2.0.dist-info/RECORD,,

xgic_dev_cli-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

xgic_dev_cli-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[xgic.cli.commands]
+dev = xgic.cli.dev.plugin:register

xgic_dev_cli-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 XGIC
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

xgic_dev_cli-0.2.0.dist-info/licenses/NOTICE

@@ -0,0 +1,8 @@
+XGIC Dev Container CLI
+Copyright 2026 XGIC
+
+This product includes software and documentation developed at XGIC
+(https://xgic.net).
+
+Licensed under the Apache License, Version 2.0.
+See the LICENSE file for details.