huitzo-cli 0.0.0__py3-none-any.whl

huitzo_cli/config.py

@@ -0,0 +1,219 @@
+"""
+Module: config
+Description: Configuration management with hierarchy support
+
+Implements:
+    - docs/guides/developer-environment.md#configuration
+    - docs/cli/reference.md#huitzo-config
+
+See Also:
+    - docs/cli/reference.md (for configuration schema)
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+from pydantic import BaseModel, ConfigDict
+
+
+class AuthConfig(BaseModel):
+    """Authentication configuration."""
+
+    model_config = ConfigDict(extra="allow")
+
+    token: Optional[str] = None
+    token_file: Optional[str] = None
+
+
+class DevConfig(BaseModel):
+    """Development configuration."""
+
+    model_config = ConfigDict(extra="allow")
+
+    port: int = 8080
+    verbose: bool = False
+    auto_reload: bool = True
+    persist_sandbox: bool = False
+
+
+class CLIConfig(BaseModel):
+    """Main CLI configuration."""
+
+    model_config = ConfigDict(extra="allow")
+
+    api_url: str = "https://api.huitzo.dev"
+    auth: AuthConfig = AuthConfig()
+    dev: DevConfig = DevConfig()
+
+
+class ConfigManager:
+    """Manages CLI configuration with hierarchy support.
+
+    Configuration hierarchy (highest to lowest priority):
+    1. Environment variables (HUITZO_*)
+    2. Command-line options passed to ConfigManager
+    3. User config (~/.config/huitzo/config.yaml)
+    4. Project config (./huitzo.yaml)
+    5. Defaults (built-in)
+    """
+
+    def __init__(self, project_root: Optional[Path] = None) -> None:
+        """Initialize configuration manager.
+
+        Args:
+            project_root: Root directory for project config. If None, uses current directory.
+        """
+        self.project_root = project_root or Path.cwd()
+        self._config = self._load_config()
+
+    @staticmethod
+    def _get_config_dir() -> Path:
+        """Get platform-specific config directory."""
+        if os.name == "nt":  # Windows
+            base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+            return base / "huitzo"
+        else:  # Unix-like
+            xdg_config = os.environ.get("XDG_CONFIG_HOME")
+            if xdg_config:
+                return Path(xdg_config) / "huitzo"
+            return Path.home() / ".config" / "huitzo"
+
+    @staticmethod
+    def _get_token_file() -> 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 _load_from_env(self) -> Dict[str, Any]:
+        """Load configuration from environment variables."""
+        config: Dict[str, Any] = {}
+
+        if api_url := os.environ.get("HUITZO_API_URL"):
+            config["api_url"] = api_url
+
+        if token := os.environ.get("HUITZO_TOKEN"):
+            config.setdefault("auth", {})
+            config["auth"]["token"] = token
+
+        if dev_port := os.environ.get("HUITZO_DEV_PORT"):
+            config.setdefault("dev", {})
+            config["dev"]["port"] = int(dev_port)
+
+        return config
+
+    def _load_from_yaml(self, path: Path) -> Dict[str, Any]:
+        """Load configuration from YAML file."""
+        if not path.exists():
+            return {}
+
+        try:
+            with open(path) as f:
+                data = yaml.safe_load(f)
+                return data or {}
+        except (OSError, yaml.YAMLError):
+            return {}
+
+    def _load_config(self) -> CLIConfig:
+        """Load and merge configuration from all sources."""
+        config_dict: Dict[str, Any] = {}
+
+        # 1. Project config (lowest priority)
+        project_config_path = self.project_root / "huitzo.yaml"
+        project_config = self._load_from_yaml(project_config_path)
+        config_dict.update(project_config)
+
+        # 2. User config
+        user_config_path = self._get_config_dir() / "config.yaml"
+        user_config = self._load_from_yaml(user_config_path)
+        config_dict.update(user_config)
+
+        # 3. Environment variables (highest priority)
+        env_config = self._load_from_env()
+        config_dict.update(env_config)
+
+        # Parse into CLIConfig model
+        return CLIConfig(**config_dict)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get configuration value by dot-notation key.
+
+        Examples:
+            - "api_url"
+            - "auth.token"
+            - "dev.port"
+        """
+        parts = key.split(".")
+        value: Any = self._config
+
+        for part in parts:
+            if isinstance(value, dict):
+                value = value.get(part)
+            elif hasattr(value, part):
+                value = getattr(value, part)
+            else:
+                return default
+
+            if value is None:
+                return default
+
+        return value
+
+    def set(self, key: str, value: Any, scope: str = "user") -> None:
+        """Set configuration value and save to file.
+
+        Args:
+            key: Configuration key (e.g., "auth.token")
+            value: Value to set
+            scope: Where to save ("user" or "project")
+        """
+        if scope == "user":
+            config_path = self._get_config_dir() / "config.yaml"
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+            # Set restrictive permissions on parent directory
+            config_path.parent.chmod(0o700)
+        else:
+            config_path = self.project_root / "huitzo.yaml"
+
+        # Load existing config
+        existing = self._load_from_yaml(config_path) if config_path.exists() else {}
+
+        # Update nested value
+        parts = key.split(".")
+        current = existing
+        for part in parts[:-1]:
+            if part not in current:
+                current[part] = {}
+            current = current[part]
+        current[parts[-1]] = value
+
+        # Save to file
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(config_path, "w") as f:
+            yaml.dump(existing, f, default_flow_style=False)
+
+        # Set restrictive permissions on config file (Unix-like only)
+        if os.name != "nt":
+            config_path.chmod(0o600)
+
+        # Reload configuration
+        self._config = self._load_config()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Get configuration as dictionary."""
+        return self._config.model_dump()
+
+    def get_config_path(self, scope: str = "user") -> Path:
+        """Get the path to the config file.
+
+        Args:
+            scope: "user" or "project"
+        """
+        if scope == "user":
+            return self._get_config_dir() / "config.yaml"
+        else:
+            return self.project_root / "huitzo.yaml"

huitzo_cli/docs_server/__init__.py

@@ -0,0 +1 @@
+"""Local documentation server."""

huitzo_cli/docs_server/server.py

@@ -0,0 +1,128 @@
+"""
+Module: server
+Description: Local documentation server with MCP endpoint
+
+Implements:
+    - docs/guides/developer-environment.md#documentation-server
+"""
+
+import subprocess
+from pathlib import Path
+from typing import Any, Optional
+
+
+class DocsServer:
+    """Local documentation server.
+
+    Serves docs from github.com/Huitzo-Inc/docs at localhost:8124
+    Provides MCP endpoint for AI agents.
+    """
+
+    def __init__(self, docs_dir: Optional[Path] = None, port: int = 8124) -> None:
+        """Initialize docs server.
+
+        Args:
+            docs_dir: Directory containing docs (default: cloned from GitHub)
+            port: Port to serve docs on
+        """
+        self.port = port
+        self.docs_dir = docs_dir or Path.home() / ".huitzo" / "docs"
+        self.process: Optional[subprocess.Popen[bytes]] = None
+
+    def ensure_docs(self) -> Path:
+        """Ensure docs are available locally.
+
+        Clones from GitHub if not already present.
+
+        Returns:
+            Path to docs directory
+        """
+        if not self.docs_dir.exists():
+            self.docs_dir.parent.mkdir(parents=True, exist_ok=True)
+
+            try:
+                subprocess.run(
+                    [
+                        "git",
+                        "clone",
+                        "https://github.com/Huitzo-Inc/docs.git",
+                        str(self.docs_dir),
+                    ],
+                    check=True,
+                    capture_output=True,
+                )
+            except subprocess.CalledProcessError as e:
+                raise RuntimeError(f"Failed to clone docs: {e}")
+        else:
+            # Update existing docs
+            try:
+                subprocess.run(
+                    ["git", "-C", str(self.docs_dir), "pull"],
+                    check=False,
+                    capture_output=True,
+                )
+            except subprocess.CalledProcessError:
+                pass  # Ignore update failures
+
+        return self.docs_dir
+
+    def start(self) -> None:
+        """Start docs server.
+
+        Raises:
+            RuntimeError: If server fails to start
+        """
+        docs_dir = self.ensure_docs()
+
+        try:
+            # Start simple HTTP server
+            self.process = subprocess.Popen(
+                [
+                    "python",
+                    "-m",
+                    "http.server",
+                    str(self.port),
+                    "--directory",
+                    str(docs_dir),
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+        except FileNotFoundError as e:
+            raise RuntimeError(f"Failed to start server: {e}")
+
+    def stop(self) -> None:
+        """Stop docs server."""
+        if self.process:
+            self.process.terminate()
+            try:
+                self.process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.process.kill()
+            self.process = None
+
+    def get_mcp_manifest(self) -> dict[str, Any]:
+        """Get MCP manifest for AI integration.
+
+        Returns:
+            MCP manifest for documentation access
+        """
+        return {
+            "name": "Huitzo Documentation Server",
+            "version": "1.0",
+            "url": f"http://localhost:{self.port}",
+            "endpoints": {
+                "files": f"http://localhost:{self.port}/files",
+                "search": f"http://localhost:{self.port}/search",
+            },
+        }
+
+    def is_running(self) -> bool:
+        """Check if server is running.
+
+        Returns:
+            True if server is running, False otherwise
+        """
+        if self.process is None:
+            return False
+        return self.process.poll() is None

huitzo_cli/main.py

@@ -0,0 +1,72 @@
+"""
+Module: main
+Description: Main CLI entry point for Huitzo
+
+Implements:
+    - docs/cli/reference.md
+    - docs/guides/developer-environment.md#cli-interface
+
+See Also:
+    - docs/architecture/overview.md (for platform architecture)
+"""
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from huitzo_cli.commands.auth import auth_app
+from huitzo_cli.commands.build import build_app
+from huitzo_cli.commands.config_cmd import config_app
+from huitzo_cli.commands.dashboard import dashboard_app
+from huitzo_cli.commands.dev import dev_app
+from huitzo_cli.commands.init import init_app
+from huitzo_cli.commands.registry import registry_app
+from huitzo_cli.commands.secrets import secrets_app
+from huitzo_cli.commands.test import test_app
+from huitzo_cli.commands.validate import validate_app
+from huitzo_cli.version import get_version
+
+console = Console()
+app = typer.Typer(help="Huitzo CLI for developing Intelligence Packs")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", help="Show version and exit"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose output"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Suppress output"),
+    config: Optional[str] = typer.Option(None, "--config", help="Path to config file"),
+) -> None:
+    """Huitzo CLI for developing Intelligence Packs."""
+    if version:
+        console.print(f"huitzo-cli {get_version()}")
+        raise typer.Exit(0)
+
+    # Store options in context for subcommands
+    ctx.obj = {
+        "verbose": verbose,
+        "quiet": quiet,
+        "config": config,
+    }
+
+    if ctx.invoked_subcommand is None and not version:
+        console.print(ctx.get_help())
+
+
+# Register command groups
+app.add_typer(auth_app, name="auth", help="Authentication commands")
+app.add_typer(init_app, name="init", help="Initialize a new Intelligence Pack")
+app.add_typer(validate_app, name="validate", help="Validate pack structure")
+app.add_typer(test_app, name="test", help="Run pack tests")
+app.add_typer(build_app, name="build", help="Build pack")
+app.add_typer(dev_app, name="dev", help="Start development session")
+app.add_typer(registry_app, name="registry", help="Registry operations")
+app.add_typer(config_app, name="config", help="Manage configuration")
+app.add_typer(secrets_app, name="secrets", help="Manage secrets")
+app.add_typer(dashboard_app, name="dashboard", help="Dashboard operations")
+
+
+if __name__ == "__main__":
+    app()

huitzo_cli/sandbox/__init__.py

@@ -0,0 +1 @@
+"""Cloud sandbox integration."""

huitzo_cli/sandbox/proxy.py

@@ -0,0 +1,75 @@
+"""
+Module: proxy
+Description: Local proxy to cloud sandbox (STUBBED - cloud not yet available)
+
+Implements:
+    - docs/guides/developer-environment.md#development-session-flow
+"""
+
+from typing import Optional
+
+
+class SandboxProxy:
+    """Local proxy for cloud sandbox.
+
+    Note: Huitzo Cloud is not yet available. This is a placeholder implementation.
+    Future implementation will:
+    - Upload pack to cloud sandbox
+    - Provide localhost proxy for development
+    - Handle file watching and auto-reload
+    """
+
+    def __init__(self, api_url: str = "https://api.huitzo.dev") -> None:
+        """Initialize sandbox proxy.
+
+        Args:
+            api_url: URL of Huitzo Cloud API
+        """
+        self.api_url = api_url
+        self.proxy_url = "http://localhost:8080"
+
+    def start(self, pack_path: str, port: int = 8080) -> None:
+        """Start local proxy to sandbox.
+
+        Args:
+            pack_path: Path to pack to upload
+            port: Local port for proxy
+
+        Raises:
+            RuntimeError: If cloud is not available
+        """
+        raise RuntimeError("Huitzo Cloud is not yet available")
+
+    def stop(self) -> None:
+        """Stop local proxy."""
+        pass
+
+    def upload_pack(self, pack_path: str) -> Optional[str]:
+        """Upload pack to sandbox.
+
+        Args:
+            pack_path: Path to pack to upload
+
+        Returns:
+            Sandbox ID if successful, None otherwise
+
+        Raises:
+            RuntimeError: If cloud is not available
+        """
+        raise RuntimeError("Huitzo Cloud is not yet available")
+
+    def watch_files(self, pack_path: str) -> None:
+        """Watch pack files for changes and auto-reload.
+
+        Args:
+            pack_path: Path to pack to watch
+        """
+        pass
+
+    def cleanup(self, sandbox_id: str) -> None:
+        """Clean up cloud sandbox.
+
+        Args:
+            sandbox_id: ID of sandbox to clean up
+        """
+        pass

huitzo_cli/templates/dashboard/App.css.j2

@@ -0,0 +1,19 @@
+.container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+  margin-bottom: 1rem;
+}
+
+code {
+  background-color: #1a1a1a;
+  padding: 2px 6px;
+  border-radius: 3px;
+  font-family: 'Courier New', monospace;
+}

huitzo_cli/templates/dashboard/App.tsx.j2

@@ -0,0 +1,21 @@
+import { useState } from 'react'
+import './App.css'
+
+export default function App() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <div className="container">
+      <h1>{{ dashboard_name }}</h1>
+      <p>A Huitzo Dashboard</p>
+
+      <button onClick={() => setCount(count + 1)}>
+        Count: {count}
+      </button>
+
+      <p>
+        Edit <code>src/App.tsx</code> to start building your dashboard.
+      </p>
+    </div>
+  )
+}

huitzo_cli/templates/dashboard/index.css.j2

@@ -0,0 +1,58 @@
+:root {
+  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+
+a:hover {
+  color: #535bf2;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+
+button:hover {
+  border-color: #646cff;
+}
+
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}

huitzo_cli/templates/dashboard/index.html.j2

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{ dashboard_name }}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

huitzo_cli/templates/dashboard/main.tsx.j2

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App.tsx'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

huitzo_cli/templates/dashboard/package.json.j2

@@ -0,0 +1,19 @@
+{
+  "name": "{{ dashboard_name }}",
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.2",
+    "react-dom": "^19.2"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.0",
+    "vite": "^5.0",
+    "typescript": "^5.3"
+  }
+}

huitzo_cli/templates/dashboard/tsconfig.json.j2

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "outDir": "./dist",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

huitzo_cli/templates/dashboard/tsconfig.node.json.j2

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}