huitzo-cli 0.0.0__py3-none-any.whl

huitzo_cli/__init__.py

@@ -0,0 +1,14 @@
+"""
+Module: huitzo_cli
+Description: CLI for developing Intelligence Packs on Huitzo
+
+Implements:
+    - docs/cli/reference.md
+    - docs/guides/developer-environment.md
+
+See Also:
+    - docs/architecture/overview.md (for platform architecture)
+    - docs/sdk/commands.md (for Intelligence Pack command patterns)
+"""
+
+__version__ = "0.0.0"

huitzo_cli/auth.py

@@ -0,0 +1,146 @@
+"""
+Module: auth
+Description: Authentication client and token storage
+
+Implements:
+    - docs/cli/reference.md#huitzo-login
+    - docs/guides/developer-environment.md#authentication
+
+See Also:
+    - docs/reference/secrets.md (for secure storage patterns)
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+from huitzo_cli.config import ConfigManager
+
+
+class TokenStore:
+    """Manages authentication tokens securely."""
+
+    def __init__(self) -> None:
+        """Initialize token store."""
+        self.token_path = self._get_token_path()
+
+    @staticmethod
+    def _get_token_path() -> Path:
+        """Get platform-specific token file path."""
+        if os.name == "nt":  # Windows
+            base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+            return base / "huitzo" / "token"
+        else:  # Unix-like
+            return Path.home() / ".huitzo" / "token"
+
+    def save(self, token: str) -> None:
+        """Save token to secure storage.
+
+        Args:
+            token: Authentication token to save
+        """
+        self.token_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Save token
+        with open(self.token_path, "w") as f:
+            f.write(token)
+
+        # Set restrictive permissions (Unix-like only)
+        if os.name != "nt":
+            self.token_path.chmod(0o600)
+            self.token_path.parent.chmod(0o700)
+
+    def load(self) -> Optional[str]:
+        """Load token from secure storage.
+
+        Returns:
+            Token if it exists, None otherwise
+        """
+        if not self.token_path.exists():
+            return None
+
+        try:
+            with open(self.token_path) as f:
+                return f.read().strip()
+        except OSError:
+            return None
+
+    def delete(self) -> None:
+        """Delete stored token."""
+        if self.token_path.exists():
+            try:
+                self.token_path.unlink()
+            except OSError:
+                pass
+
+
+class AuthClient:
+    """Client for handling authentication with Huitzo Cloud.
+
+    Note: Huitzo Cloud is not yet available. This is a placeholder implementation.
+    """
+
+    def __init__(self, config_manager: ConfigManager) -> None:
+        """Initialize auth client.
+
+        Args:
+            config_manager: Configuration manager instance
+        """
+        self.config = config_manager
+        self.token_store = TokenStore()
+
+    def login(self, token: Optional[str] = None) -> None:
+        """Login to Huitzo Cloud.
+
+        Args:
+            token: Optional token for testing. If None, will attempt cloud auth (not yet available).
+        """
+        if token:
+            # Save token for testing
+            self.token_store.save(token)
+            self.config.set("auth.token", token, scope="user")
+        else:
+            # Cloud authentication would happen here
+            raise RuntimeError("Huitzo Cloud is not yet available")
+
+    def logout(self) -> None:
+        """Logout and remove stored token."""
+        self.token_store.delete()
+        self.config.set("auth.token", None, scope="user")
+
+    def get_token(self) -> Optional[str]:
+        """Get current authentication token.
+
+        Returns:
+            Token if authenticated, None otherwise
+        """
+        # Try config first
+        config_token = self.config.get("auth.token")
+        if config_token is not None and isinstance(config_token, str):
+            return str(config_token)
+
+        # Try token file
+        token = self.token_store.load()
+        if token:
+            return token
+
+        return None
+
+    def is_authenticated(self) -> bool:
+        """Check if user is authenticated.
+
+        Returns:
+            True if authenticated, False otherwise
+        """
+        return self.get_token() is not None
+
+    def get_current_user(self) -> Optional[dict[str, Any]]:
+        """Get current authenticated user info.
+
+        Note: Returns None until cloud is available.
+
+        Returns:
+            User info dict if authenticated, None otherwise
+        """
+        # Cloud API would be called here
+        return None

huitzo_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands for Huitzo."""

huitzo_cli/commands/auth.py

@@ -0,0 +1,61 @@
+"""
+Module: auth_command
+Description: Login and logout commands
+
+Implements:
+    - docs/cli/reference.md#huitzo-login
+    - docs/guides/developer-environment.md#authentication
+"""
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from huitzo_cli.auth import AuthClient
+from huitzo_cli.config import ConfigManager
+
+console = Console()
+auth_app = typer.Typer(help="Authentication commands", invoke_without_command=True)
+
+
+@auth_app.command()
+def login(
+    token: Optional[str] = typer.Option(
+        None,
+        "--token",
+        help="Authentication token (for testing only)",
+    ),
+) -> None:
+    """Login to Huitzo Cloud.
+
+    Note: Huitzo Cloud is not yet available. Use --token for testing.
+    """
+    config = ConfigManager()
+    auth_client = AuthClient(config)
+
+    if not token:
+        console.print("[yellow]ℹ️  Huitzo Cloud is not yet available[/yellow]")
+        console.print("Use [bold]--token <value>[/bold] for testing")
+        raise typer.Exit(1)
+
+    try:
+        auth_client.login(token=token)
+        console.print("[green]✅ Logged in successfully[/green]")
+    except Exception as e:
+        console.print(f"[red]❌ Login failed: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@auth_app.command()
+def logout() -> None:
+    """Logout from Huitzo Cloud."""
+    config = ConfigManager()
+    auth_client = AuthClient(config)
+
+    try:
+        auth_client.logout()
+        console.print("[green]✅ Logged out successfully[/green]")
+    except Exception as e:
+        console.print(f"[red]❌ Logout failed: {e}[/red]")
+        raise typer.Exit(1)

huitzo_cli/commands/build.py

@@ -0,0 +1,81 @@
+"""
+Module: build_command
+Description: Pack building command
+
+Implements:
+    - docs/cli/reference.md#huitzo-build
+"""
+
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from huitzo_cli.validator import PackValidator
+
+console = Console()
+build_app = typer.Typer(help="Build pack")
+
+
+@build_app.command()
+def build(
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output directory"),
+    format_type: str = typer.Option(
+        "wheel", "--format", "-f", help="Build format (wheel or sdist)"
+    ),
+    sign: bool = typer.Option(False, "--sign", help="Sign the build"),
+) -> None:
+    """Build Intelligence Pack for distribution.
+
+    Validates pack first, then builds wheel or sdist using hatchling.
+
+    Options:
+    - --output: Output directory (default: dist/)
+    - --format: Build format (wheel or sdist)
+    - --sign: Sign the build artifacts (requires GPG)
+    """
+    # Validate pack first
+    validator = PackValidator()
+    result = validator.validate()
+
+    if not result.valid:
+        console.print("[red]❌ Pack validation failed[/red]")
+        for error in result.errors:
+            console.print(f"  • {error}")
+        raise typer.Exit(1)
+
+    # Set output directory
+    output_dir = output or Path("dist")
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    console.print("[bold]Building pack...[/bold]")
+
+    cmd = ["uv", "build"]
+
+    if format_type == "wheel":
+        cmd.append("--wheel")
+    elif format_type == "sdist":
+        cmd.append("--sdist")
+    else:
+        console.print(f"[red]❌ Unknown format: {format_type}[/red]")
+        raise typer.Exit(1)
+
+    if output:
+        cmd.extend(["-o", str(output_dir)])
+
+    try:
+        build_result = subprocess.run(cmd, check=False)
+        if build_result.returncode != 0:
+            raise typer.Exit(build_result.returncode)
+
+        console.print("[green]✅ Build successful[/green]")
+        console.print(f"Output: {output_dir}")
+
+        if sign:
+            console.print("[yellow]⚠️  Code signing not yet implemented[/yellow]")
+
+    except FileNotFoundError:
+        console.print("[red]❌ uv not found. Install from: https://docs.astral.sh/uv/[/red]")
+        raise typer.Exit(1)

huitzo_cli/commands/config_cmd.py

@@ -0,0 +1,98 @@
+"""
+Module: config_cmd
+Description: Configuration management commands
+
+Implements:
+    - docs/cli/reference.md#huitzo-config
+"""
+
+from typing import Any
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from huitzo_cli.config import ConfigManager
+
+console = Console()
+config_app = typer.Typer(help="Manage configuration")
+
+
+@config_app.command()
+def get(key: str) -> None:
+    """Get configuration value.
+
+    Args:
+        key: Configuration key (e.g., 'api_url' or 'auth.token')
+    """
+    config = ConfigManager()
+    value = config.get(key)
+
+    if value is None:
+        console.print(f"[yellow]⚠️  {key} not set[/yellow]")
+        raise typer.Exit(1)
+
+    console.print(f"{key} = {value}")
+
+
+@config_app.command()
+def set(
+    key: str,
+    value: str,
+    scope: str = typer.Option("user", "--scope", help="Config scope (user or project)"),
+) -> None:
+    """Set configuration value.
+
+    Args:
+        key: Configuration key (e.g., 'auth.token')
+        value: Value to set
+    """
+    config = ConfigManager()
+
+    try:
+        config.set(key, value, scope=scope)
+        console.print(f"[green]✅ {key} set to {value}[/green]")
+    except Exception as e:
+        console.print(f"[red]❌ Failed to set {key}: {e}[/red]")
+        raise typer.Exit(1)
+
+
+@config_app.command()
+def list_config() -> None:
+    """List all configuration values."""
+    config = ConfigManager()
+    config_dict = config.to_dict()
+
+    table = Table(title="Configuration")
+    table.add_column("Key", style="cyan")
+    table.add_column("Value", style="green")
+
+    def flatten_dict(d: dict[str, Any], parent_key: str = "") -> list[tuple[str, str]]:
+        items = []
+        for k, v in d.items():
+            new_key = f"{parent_key}.{k}" if parent_key else k
+            if isinstance(v, dict):
+                items.extend(flatten_dict(v, new_key))
+            else:
+                items.append((new_key, str(v)))
+        return items
+
+    for key, value in flatten_dict(config_dict):
+        table.add_row(key, value)
+
+    console.print(table)
+
+
+@config_app.command()
+def path(
+    scope: str = typer.Option("user", "--scope", help="Config scope (user or project)"),
+) -> None:
+    """Show configuration file path.
+
+    Args:
+        scope: Config scope (user or project)
+    """
+    config = ConfigManager()
+    config_path = config.get_config_path(scope=scope)
+    console.print(f"[cyan]{scope.capitalize()} config:[/cyan] {config_path}")
+    console.print(f"[yellow]Exists:[/yellow] {config_path.exists()}")

huitzo_cli/commands/dashboard.py

@@ -0,0 +1,145 @@
+"""
+Module: dashboard_command
+Description: Dashboard management commands
+
+Implements:
+    - docs/cli/reference.md#dashboard-commands
+"""
+
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import typer
+from jinja2 import Environment, PackageLoader
+from rich.console import Console
+
+console = Console()
+dashboard_app = typer.Typer(help="Dashboard operations")
+
+
+@dashboard_app.command()
+def new(
+    name: Optional[str] = typer.Argument(None, help="Dashboard name"),
+    author: Optional[str] = typer.Option(None, "--author", help="Author name"),
+) -> None:
+    """Create a new dashboard project.
+
+    Scaffolds a React + TypeScript dashboard using Vite.
+    """
+    if not name:
+        name = typer.prompt("Dashboard name")
+
+    project_root = Path.cwd() / name
+
+    if project_root.exists():
+        console.print(f"[red]❌ Directory '{name}' already exists[/red]")
+        raise typer.Exit(1)
+
+    project_root.mkdir(parents=True, exist_ok=True)
+    src_dir = project_root / "src"
+    src_dir.mkdir(parents=True, exist_ok=True)
+
+    # Set up Jinja2
+    env = Environment(loader=PackageLoader("huitzo_cli", "templates/dashboard"))
+
+    context = {"dashboard_name": name}
+
+    # Files to create
+    files = {
+        "package.json.j2": project_root / "package.json",
+        "vite.config.ts.j2": project_root / "vite.config.ts",
+        "index.html.j2": project_root / "index.html",
+        "tsconfig.json.j2": project_root / "tsconfig.json",
+        "tsconfig.node.json.j2": project_root / "tsconfig.node.json",
+        "main.tsx.j2": src_dir / "main.tsx",
+        "App.tsx.j2": src_dir / "App.tsx",
+        "index.css.j2": src_dir / "index.css",
+        "App.css.j2": src_dir / "App.css",
+    }
+
+    for template_name, target_path in files.items():
+        template = env.get_template(template_name)
+        content = template.render(**context)
+        target_path.write_text(content)
+
+    # Create .gitignore
+    (project_root / ".gitignore").write_text("node_modules/\n.env.local\ndist/\n.DS_Store\n")
+
+    console.print(f"\n[green]✅ Dashboard '{name}' created![/green]")
+    console.print("\n[bold]Next steps:[/bold]")
+    console.print(f"  cd {name}")
+    console.print("  npm install")
+    console.print("  npm run dev")
+
+
+@dashboard_app.command()
+def dev() -> None:
+    """Start dashboard development server.
+
+    Starts Vite dev server with hot module replacement.
+    """
+    console.print("[bold]Starting dashboard dev server...[/bold]")
+
+    try:
+        subprocess.run(["npm", "run", "dev"], check=False)
+    except FileNotFoundError:
+        console.print("[red]❌ npm not found. Install Node.js from nodejs.org[/red]")
+        raise typer.Exit(1)
+
+
+@dashboard_app.command()
+def build() -> None:
+    """Build dashboard for production.
+
+    Creates optimized production build in dist/ directory.
+    """
+    console.print("[bold]Building dashboard for production...[/bold]")
+
+    try:
+        result = subprocess.run(["npm", "run", "build"], check=False)
+        if result.returncode == 0:
+            console.print("[green]✅ Build successful. Output in dist/[/green]")
+        else:
+            raise typer.Exit(result.returncode)
+    except FileNotFoundError:
+        console.print("[red]❌ npm not found[/red]")
+        raise typer.Exit(1)
+
+
+@dashboard_app.command()
+def publish() -> None:
+    """Publish dashboard to Huitzo Hub.
+
+    Note: Requires Huitzo Cloud (not yet available).
+    """
+    console.print("[yellow]ℹ️  Huitzo Hub is not yet available[/yellow]")
+    console.print("This feature is coming soon!")
+    raise typer.Exit(1)
+
+
+@dashboard_app.command()
+def grant(
+    user: str = typer.Option(..., "--user", help="User email to grant access"),
+) -> None:
+    """Grant dashboard access to another user.
+
+    Note: Requires Huitzo Cloud (not yet available).
+
+    Args:
+        user: Email of user to grant access
+    """
+    console.print("[yellow]ℹ️  Huitzo Hub is not yet available[/yellow]")
+    console.print("This feature is coming soon!")
+    raise typer.Exit(1)
+
+
+@dashboard_app.command()
+def share() -> None:
+    """Share dashboard.
+
+    Note: Requires Huitzo Cloud (not yet available).
+    """
+    console.print("[yellow]ℹ️  Huitzo Hub is not yet available[/yellow]")
+    console.print("This feature is coming soon!")
+    raise typer.Exit(1)

huitzo_cli/commands/dev.py

@@ -0,0 +1,113 @@
+"""
+Module: dev_command
+Description: Development session command (STUBBED - cloud not yet available)
+
+Implements:
+    - docs/cli/reference.md#huitzo-dev
+    - docs/guides/developer-environment.md#development-session-flow
+"""
+
+import typer
+from rich.console import Console
+
+from huitzo_cli.validator import PackValidator
+
+console = Console()
+dev_app = typer.Typer(help="Start development session")
+
+
+@dev_app.command()
+def dev(
+    docs: bool = typer.Option(True, "--docs", help="Start docs server"),
+    port: int = typer.Option(8080, "--port", help="Proxy port"),
+    persist: bool = typer.Option(False, "--persist", help="Keep sandbox after exit"),
+) -> None:
+    """Start pack development session.
+
+    Note: Huitzo Cloud is not yet available. This command shows what will happen
+    when the cloud platform is ready.
+
+    When cloud becomes available, this will:
+    1. Validate your pack
+    2. Upload to cloud sandbox
+    3. Start local proxy at localhost:8080
+    4. Watch files for changes and auto-reload
+    5. Serve docs at localhost:8124
+
+    Args:
+        docs: Start local docs server (always available)
+        port: Local proxy port
+        persist: Keep sandbox after exiting (cloud only)
+    """
+    # Validate pack
+    console.print("[bold]Validating pack...[/bold]")
+    validator = PackValidator()
+    result = validator.validate()
+
+    if not result.valid:
+        console.print("[red]❌ Pack validation failed[/red]")
+        for error in result.errors:
+            console.print(f"  • {error}")
+        raise typer.Exit(1)
+
+    console.print("[green]✅ Pack validation passed[/green]")
+
+    # Show cloud status
+    console.print()
+    console.print("[yellow]ℹ️  Huitzo Cloud is not yet available[/yellow]")
+    console.print()
+    console.print("[bold]What will happen when cloud is ready:[/bold]")
+    console.print("  1. Upload pack to cloud sandbox")
+    console.print(f"  2. Start local proxy at http://localhost:{port}")
+    console.print("  3. Watch files for changes and auto-reload")
+    if docs:
+        console.print("  4. Serve docs at http://localhost:8124")
+    console.print()
+
+    # Show local alternatives
+    console.print("[bold]For local development now:[/bold]")
+    console.print("  • huitzo validate - Validate pack structure")
+    console.print("  • huitzo test - Run tests")
+    console.print("  • huitzo build - Build wheel")
+    console.print()
+    console.print("To test commands locally, see SDK documentation:")
+    console.print("  • docs/sdk/commands.md")
+    console.print("  • docs/sdk/context.md")
+
+    if docs:
+        console.print()
+        console.print("[bold]Starting documentation server...[/bold]")
+        try:
+            from huitzo_cli.docs_server.server import DocsServer
+
+            docs_server = DocsServer(port=8124)
+            docs_server.start()
+            console.print("[green]✅ Docs server running at http://localhost:8124[/green]")
+            console.print()
+            console.print("Press Ctrl+C to exit...")
+
+            try:
+                import signal
+
+                def signal_handler(sig, frame):  # type: ignore
+                    console.print("\n[yellow]Shutting down...[/yellow]")
+                    docs_server.stop()
+                    raise typer.Exit(0)
+
+                signal.signal(signal.SIGINT, signal_handler)
+
+                # Keep server running
+                while docs_server.is_running():
+                    import time
+
+                    time.sleep(1)
+
+            except KeyboardInterrupt:
+                docs_server.stop()
+
+        except Exception as e:
+            console.print(f"[yellow]⚠️  Could not start docs server: {e}[/yellow]")
+            console.print("Continuing without docs server...")
+
+    console.print()
+    console.print("[green]Development session ready[/green]")