10xgraph-api 0.7.0__py3-none-any.whl

tenxgraph_api/cli/commands/build.py

@@ -0,0 +1,305 @@
+"""Build command implementation."""
+
+from pathlib import Path
+from typing import Any
+
+from tenxgraph_api.cli.commands import BaseCommand
+from tenxgraph_api.cli.constants import DEFAULT_PORT, DEFAULT_PYTHON_VERSION, DEFAULT_SERVICE_NAME
+from tenxgraph_api.cli.core.validation import Validator
+from tenxgraph_api.cli.exceptions import DockerError, FileOperationError, ValidationError
+from tenxgraph_api.cli.templates.defaults import (
+    generate_docker_compose_content,
+    generate_dockerfile_content,
+    generate_dockerignore_content,
+    generate_k8s_manifest_content,
+)
+
+
+class BuildCommand(BaseCommand):
+    """Command to generate Dockerfile and docker-compose.yml for the application."""
+
+    def execute(  # noqa: PLR0915
+        self,
+        output_file: str = "Dockerfile",
+        force: bool = False,
+        python_version: str = DEFAULT_PYTHON_VERSION,
+        port: int = DEFAULT_PORT,
+        docker_compose: bool = False,
+        k8s: bool = False,
+        service_name: str = DEFAULT_SERVICE_NAME,
+        **kwargs: Any,
+    ) -> int:
+        """Execute the build command.
+
+        Args:
+            output_file: Output Dockerfile path
+            force: Overwrite existing files
+            python_version: Python version to use
+            port: Port to expose
+            docker_compose: Generate docker-compose.yml
+            k8s: Generate a Kubernetes manifest (Deployment + Service)
+            service_name: Service name for docker-compose
+            **kwargs: Additional arguments
+
+        Returns:
+            Exit code
+        """
+        try:
+            self.output.command_header(
+                "build",
+                "Generate Dockerfile (and optional docker-compose.yml) for production image",
+                color="yellow",
+            )
+
+            steps: list[tuple[str, str]] = [
+                ("validate", "Validating build options"),
+                ("sources", "Discovering project sources"),
+                ("dockerfile", "Generating Dockerfile"),
+                ("dockerignore", "Generating .dockerignore"),
+            ]
+            if docker_compose:
+                steps.append(("compose", "Generating docker-compose.yml"))
+            if k8s:
+                steps.append(("k8s", "Generating k8s.yaml"))
+
+            generated = ["Dockerfile", ".dockerignore"]
+            timeline = self.output.timeline("Assembling deployment assets", steps=tuple(steps))
+            with timeline:
+                with timeline.step("validate") as step:
+                    validated_port = Validator.validate_port(port)
+                    validated_python_version = Validator.validate_python_version(python_version)
+                    validated_service_name = Validator.validate_service_name(service_name)
+                    output_path = Validator.validate_path(output_file)
+                    if output_path.exists() and not force:
+                        raise FileOperationError(
+                            f"Dockerfile already exists at {output_path}. "
+                            "Use --force to overwrite.",
+                            file_path=str(output_path),
+                        )
+                    step.detail(
+                        f"python {validated_python_version} · port {validated_port} · "
+                        f"service {validated_service_name}"
+                    )
+
+                with timeline.step("sources") as step:
+                    requirements_files, requirements_file = self._discover_requirements(Path.cwd())
+                    has_pyproject = (Path.cwd() / "pyproject.toml").is_file()
+                    if requirements_files:
+                        step.detail(f"requirements: {requirements_files[0]}")
+                    elif has_pyproject:
+                        step.detail("dependencies: pyproject.toml")
+                    else:
+                        step.detail(
+                            "no requirements.txt or pyproject.toml; installing "
+                            "10xgraph-api from PyPI"
+                        )
+
+                with timeline.step("dockerfile") as step:
+                    dockerfile_content = generate_dockerfile_content(
+                        python_version=validated_python_version,
+                        port=validated_port,
+                        requirements_file=requirements_file,
+                        has_requirements=bool(requirements_files),
+                        omit_cmd=docker_compose,
+                        has_pyproject=has_pyproject,
+                    )
+                    self._write_dockerfile(output_path, dockerfile_content)
+                    step.detail(str(output_path))
+
+                dockerignore_path = output_path.parent / ".dockerignore"
+                with timeline.step("dockerignore") as step:
+                    if dockerignore_path.exists() and not force:
+                        step.skip(f"{dockerignore_path} already exists")
+                    else:
+                        dockerignore_path.write_text(
+                            generate_dockerignore_content(), encoding="utf-8"
+                        )
+                        step.detail(str(dockerignore_path))
+
+                if docker_compose:
+                    with timeline.step("compose") as step:
+                        self._write_docker_compose(
+                            force=force,
+                            service_name=validated_service_name,
+                            port=validated_port,
+                        )
+                        generated.append("docker-compose.yml")
+                        step.detail("docker-compose.yml")
+
+                if k8s:
+                    with timeline.step("k8s") as step:
+                        self._write_k8s_manifest(
+                            force=force,
+                            service_name=validated_service_name,
+                            port=validated_port,
+                        )
+                        generated.append("k8s.yaml")
+                        step.detail("k8s.yaml")
+
+            self.output.completion_screen(
+                "Build assets ready",
+                "Deployment files generated successfully",
+                details={
+                    "Files": ", ".join(generated),
+                    "Service": validated_service_name,
+                    "Port": validated_port,
+                },
+                next_steps=(
+                    ["docker compose up --build"]
+                    if docker_compose
+                    else [f"docker build -t {validated_service_name} ."]
+                ),
+            )
+
+            return 0
+
+        except (ValidationError, DockerError, FileOperationError) as e:
+            return self.handle_error(e)
+        except Exception as e:
+            docker_error = DockerError(f"Failed to generate Docker files: {e}")
+            return self.handle_error(docker_error)
+
+    def _discover_requirements(self, current_dir: Path) -> tuple[list[Path], str]:
+        """Discover requirements files in the project.
+
+        Args:
+            current_dir: Current directory to search in
+
+        Returns:
+            Tuple of (found_files_list, chosen_filename_str)
+        """
+        requirements_files = []
+        requirements_paths = [
+            current_dir / "requirements.txt",
+            current_dir / "requirements" / "requirements.txt",
+            current_dir / "requirements" / "base.txt",
+            current_dir / "requirements" / "production.txt",
+        ]
+
+        for req_path in requirements_paths:
+            if req_path.exists():
+                requirements_files.append(req_path)
+
+        if not requirements_files:
+            self.logger.warning("No requirements.txt file found in common locations")
+
+        requirements_file = "requirements.txt"
+        if requirements_files:
+            requirements_file = requirements_files[0].name
+            if len(requirements_files) > 1:
+                self.logger.info(f"Found multiple requirements files, using: {requirements_file}")
+
+        return requirements_files, requirements_file
+
+    def _write_dockerfile(self, output_path: Path, content: str) -> None:
+        """Write Dockerfile content to file.
+
+        Args:
+            output_path: Path to write to
+            content: Dockerfile content
+
+        Raises:
+            FileOperationError: If writing fails
+        """
+        try:
+            output_path.write_text(content, encoding="utf-8")
+        except OSError as e:
+            raise FileOperationError(
+                f"Failed to write Dockerfile: {e}", file_path=str(output_path)
+            ) from e
+
+    def _write_k8s_manifest(self, force: bool, service_name: str, port: int) -> None:
+        """Write k8s.yaml (Deployment + Service).
+
+        No manifest was generated before, so users hand-rolled one -- usually with
+        the default 30s termination grace period, which SIGKILLs an agent run
+        mid-LLM-call on every rolling deploy. The generated one sets a grace period
+        that matches how long a run can actually take, plus a preStop hook.
+
+        Raises:
+            FileOperationError: If writing fails
+        """
+        manifest_path = Path("k8s.yaml")
+
+        if manifest_path.exists() and not force:
+            raise FileOperationError(
+                f"k8s.yaml already exists at {manifest_path}. Use --force to overwrite.",
+                file_path=str(manifest_path),
+            )
+
+        content = generate_k8s_manifest_content(service_name, port)
+
+        try:
+            manifest_path.write_text(content, encoding="utf-8")
+        except OSError as e:
+            raise FileOperationError(
+                f"Failed to write k8s.yaml: {e}", file_path=str(manifest_path)
+            ) from e
+
+    def _write_docker_compose(self, force: bool, service_name: str, port: int) -> None:
+        """Write docker-compose.yml file.
+
+        Args:
+            force: Overwrite existing file
+            service_name: Service name to use
+            port: Port to expose
+
+        Raises:
+            FileOperationError: If writing fails
+        """
+        compose_path = Path("docker-compose.yml")
+
+        if compose_path.exists() and not force:
+            raise FileOperationError(
+                f"docker-compose.yml already exists at {compose_path}. Use --force to overwrite.",
+                file_path=str(compose_path),
+            )
+
+        compose_content = generate_docker_compose_content(service_name, port)
+
+        try:
+            compose_path.write_text(compose_content, encoding="utf-8")
+        except OSError as e:
+            raise FileOperationError(
+                f"Failed to write docker-compose.yml: {e}", file_path=str(compose_path)
+            ) from e
+
+    def _show_next_steps(self, docker_compose: bool) -> None:
+        """Show next steps to the user.
+
+        Args:
+            docker_compose: Whether docker-compose was generated
+        """
+        if docker_compose:
+            steps = [
+                "Review the generated Dockerfile and docker-compose.yml",
+                "Build and run with: docker compose up --build",
+                "Or build separately: docker build -t 10xgraph-api .",
+                "Access your API at: http://localhost:8000",
+            ]
+        else:
+            steps = [
+                "Review the generated Dockerfile",
+                "Build the image: docker build -t 10xgraph-api .",
+                "Run the container: docker run -p 8000:8000 10xgraph-api",
+                "Access your API at: http://localhost:8000",
+            ]
+
+        self.output.print_list(
+            [f"{index}. {step}" for index, step in enumerate(steps, 1)],
+            title="Next steps",
+            bullet="→",
+        )
+
+        production_tips = [
+            "Using a multi-stage build to reduce image size",
+            "Setting up proper environment variables",
+            "Configuring health checks and resource limits",
+            "Using a reverse proxy like nginx",
+        ]
+
+        self.output.print_list(
+            production_tips,
+            title="Production considerations",
+            bullet="•",
+        )

tenxgraph_api/cli/commands/config.py

@@ -0,0 +1,71 @@
+"""Config command implementation: a browser editor for ``10xgraph.json``."""
+
+import webbrowser
+from pathlib import Path
+from typing import Any
+
+from tenxgraph_api.cli.commands import BaseCommand
+from tenxgraph_api.cli.config_editor import ConfigEditorServer
+from tenxgraph_api.cli.constants import DEFAULT_CONFIG_FILE, LEGACY_CONFIG_FILE
+from tenxgraph_api.cli.exceptions import ServerError
+
+
+class ConfigCommand(BaseCommand):
+    """Serve the config editor until the user stops it with Ctrl+C."""
+
+    def execute(
+        self,
+        config: str = DEFAULT_CONFIG_FILE,
+        port: int = 0,
+        open_browser: bool = True,
+        **kwargs: Any,
+    ) -> int:
+        # The editor always writes 10xgraph.json. When only the legacy agentflow.json exists,
+        # it starts from that file's contents; the first save creates 10xgraph.json and
+        # leaves agentflow.json untouched.
+        config_path = Path(config).expanduser().resolve()
+        seed_path = None
+        if config == DEFAULT_CONFIG_FILE and not config_path.exists():
+            legacy = config_path.with_name(LEGACY_CONFIG_FILE)
+            seed_path = legacy if legacy.exists() else None
+        try:
+            server = ConfigEditorServer(config_path, port=port, seed_path=seed_path)
+        except OSError as exc:
+            return self.handle_error(
+                ServerError(
+                    f"Could not start the config editor: {exc}", host="127.0.0.1", port=port
+                )
+            )
+
+        self.output.command_header(
+            "config",
+            f"Edit {config_path.name} in your browser",
+            hint="Ctrl+C to stop the config editor",
+        )
+        self.output.completion_screen(
+            "Config editor running",
+            "Open the link below to edit, validate, and save your configuration.",
+            details={
+                "Editor": server.url,
+                "File": f"{config_path}{_file_note(config_path, server.store.seeded, seed_path)}",
+            },
+            next_steps=["Press Ctrl+C to stop the editor when you are done."],
+        )
+        if open_browser:
+            webbrowser.open_new_tab(server.url)
+
+        try:
+            server.serve_forever()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            server.shutdown()
+        return 0
+
+
+def _file_note(config_path: Path, seeded: bool, seed_path: Path | None) -> str:
+    if config_path.exists():
+        return ""
+    if seeded and seed_path is not None:
+        return f" (new, starts from {seed_path.name}; saving creates it)"
+    return " (new)"

tenxgraph_api/cli/commands/demo.py

@@ -0,0 +1,93 @@
+"""Safe interactive showcase for 10xGraph terminal motion."""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from tenxgraph_api.cli.commands import BaseCommand
+from tenxgraph_api.cli.exceptions import ValidationError
+
+
+class DemoCommand(BaseCommand):
+    """Preview command-specific animations without external side effects."""
+
+    _STYLES = ("typing", "network", "init", "build", "eval")
+    _ALIASES = {"play": "typing", "api": "network"}
+
+    _SUBTITLES = {
+        "typing": "Full-screen 10xGraph identity and workspace transition",
+        "network": "Live agent network and playground connection",
+        "init": "Project scaffold assembly",
+        "build": "Container delivery pipeline",
+        "eval": "Evaluation scan and completion states",
+    }
+    _COMMAND_NAMES = {
+        "typing": "typing",
+        "network": "api",
+        "init": "init",
+        "build": "build",
+        "eval": "eval",
+    }
+
+    def execute(self, style: str = "all", **kwargs: Any) -> int:
+        normalized = self._ALIASES.get(style.strip().lower(), style.strip().lower())
+        if normalized != "all" and normalized not in self._STYLES:
+            return self.handle_error(
+                ValidationError(
+                    f"Unknown animation style '{style}'. "
+                    f"Choose all, {', '.join(self._STYLES)}.",
+                    field="style",
+                )
+            )
+
+        selected = self._STYLES if normalized == "all" else (normalized,)
+        for theme in selected:
+            self.output.command_header(self._COMMAND_NAMES[theme], self._SUBTITLES[theme])
+
+        self._preview_timeline()
+        self._preview_progress()
+
+        self.output.completion_screen(
+            "Animation showcase",
+            "All preview states rendered successfully",
+            details={
+                "Themes": ", ".join(selected),
+                "Side effects": "none",
+                "Fallback": "automatic for CI, pipes, and JSON",
+            },
+            next_steps=[
+                "Run `10xgraph play` to see the network theme in a real workflow.",
+                "Use `10xgraph --no-animation COMMAND` for static accessible output.",
+                "Use `10xgraph --fullscreen COMMAND` to hold a dedicated screen.",
+            ],
+        )
+        return 0
+
+    def _preview_timeline(self) -> None:
+        stages = (
+            ("topology", "Resolving graph topology", "3 nodes, 2 edges"),
+            ("pipeline", "Assembling runtime pipeline", "checkpointer + store bound"),
+            ("experience", "Connecting developer experience", "playground reachable"),
+        )
+        timeline = self.output.timeline(
+            "Timeline preview",
+            steps=tuple((key, title) for key, title, _ in stages),
+        )
+        with timeline:
+            for key, _title, detail in stages:
+                with timeline.step(key) as step:
+                    time.sleep(0.35)
+                    step.detail(detail)
+
+    def _preview_progress(self) -> None:
+        samples = (
+            ("weather_eval::forecast_tokyo", "passed"),
+            ("weather_eval::forecast_oslo", "passed"),
+            ("weather_eval::unknown_city", "failed"),
+            ("weather_eval::rate_limited", "passed"),
+        )
+        with self.output.progress_run("Progress preview", total=len(samples)) as progress:
+            for label, status in samples:
+                time.sleep(0.18)
+                progress.record(label, status=status, detail="0.42s")