huitzo-cli 0.0.0__py3-none-any.whl

huitzo_cli/commands/init.py

@@ -0,0 +1,142 @@
+"""
+Module: init_command
+Description: Pack initialization command with scaffolding
+
+Implements:
+    - docs/cli/reference.md#huitzo-init
+"""
+
+import re
+from pathlib import Path
+from typing import Optional
+
+import typer
+from jinja2 import Environment, PackageLoader
+from rich.console import Console
+
+console = Console()
+init_app = typer.Typer(help="Initialize a new Intelligence Pack")
+
+
+def validate_name(name: str) -> bool:
+    """Validate pack name (lowercase with hyphens only)."""
+    return bool(re.match(r"^[a-z0-9]([a-z0-9-]*[a-z0-9])?$", name))
+
+
+def validate_namespace(namespace: str) -> bool:
+    """Validate namespace (lowercase with hyphens only)."""
+    return bool(re.match(r"^[a-z0-9]([a-z0-9-]*[a-z0-9])?$", namespace))
+
+
+def name_to_module(name: str) -> str:
+    """Convert pack name to Python module name."""
+    return name.replace("-", "_")
+
+
+@init_app.command()
+def init(
+    name: Optional[str] = typer.Argument(None, help="Pack name (e.g., my-pack)"),
+    namespace: Optional[str] = typer.Option(None, "--namespace", help="Pack namespace"),
+    author: Optional[str] = typer.Option(None, "--author", help="Author name"),
+    author_email: Optional[str] = typer.Option(None, "--email", help="Author email"),
+    description: Optional[str] = typer.Option(None, "--description", help="Pack description"),
+) -> None:
+    """Initialize a new Intelligence Pack with scaffolding.
+
+    Creates a project structure with:
+    - pyproject.toml (package configuration)
+    - huitzo.yaml (pack manifest)
+    - Example command and tests
+    - README and gitignore
+    """
+    # Get pack name
+    if not name:
+        name = typer.prompt("Pack name (lowercase, hyphens OK)")
+
+    if not validate_name(name):
+        console.print(
+            "[red]❌ Invalid pack name. Use lowercase letters, numbers, and hyphens.[/red]"
+        )
+        raise typer.Exit(1)
+
+    # Get namespace
+    if not namespace:
+        namespace = typer.prompt("Namespace (lowercase, hyphens OK)", default=name)
+
+    if not validate_namespace(namespace):
+        console.print(
+            "[red]❌ Invalid namespace. Use lowercase letters, numbers, and hyphens.[/red]"
+        )
+        raise typer.Exit(1)
+
+    # Get author info
+    if not author:
+        author = typer.prompt("Author name", default="Developer")
+
+    if not author_email:
+        author_email = typer.prompt("Author email", default="dev@example.com")
+
+    # Get description
+    if not description:
+        description = typer.prompt("Description", default=f"Intelligence Pack: {name}")
+
+    # Create project directory
+    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)
+    module_name = name_to_module(name)
+
+    # Set up Jinja2 environment
+    env = Environment(loader=PackageLoader("huitzo_cli", "templates/pack"))
+
+    # Template context
+    context = {
+        "pack_name": name,
+        "namespace": namespace,
+        "module_name": module_name,
+        "author": author,
+        "author_email": author_email,
+        "description": description,
+    }
+
+    # Create directory structure
+    src_dir = project_root / "src" / module_name
+    src_dir.mkdir(parents=True, exist_ok=True)
+
+    commands_dir = src_dir / "commands"
+    commands_dir.mkdir(parents=True, exist_ok=True)
+
+    tests_dir = project_root / "tests"
+    tests_dir.mkdir(parents=True, exist_ok=True)
+
+    # Render templates
+    files_to_create = {
+        "pyproject.toml.j2": project_root / "pyproject.toml",
+        "huitzo.yaml.j2": project_root / "huitzo.yaml",
+        "README.md.j2": project_root / "README.md",
+        ".gitignore.j2": project_root / ".gitignore",
+        "__init__.py.j2": src_dir / "__init__.py",
+        "hello.py.j2": commands_dir / "hello.py",
+        "test_hello.py.j2": tests_dir / "test_hello.py",
+    }
+
+    for template_name, target_path in files_to_create.items():
+        template = env.get_template(template_name)
+        content = template.render(**context)
+        target_path.write_text(content)
+
+    # Create __init__.py for commands directory
+    (commands_dir / "__init__.py").write_text('"""Commands for this pack."""\n')
+
+    # Create __init__.py for tests directory
+    (tests_dir / "__init__.py").write_text('"""Tests for this pack."""\n')
+
+    console.print(f"\n[green]✅ Pack '{name}' initialized successfully![/green]")
+    console.print("\n[bold]Next steps:[/bold]")
+    console.print(f"  cd {name}")
+    console.print("  huitzo validate")
+    console.print("  huitzo test")
+    console.print("  huitzo dev")

huitzo_cli/commands/registry.py

@@ -0,0 +1,105 @@
+"""
+Module: registry_command
+Description: Registry operations (publish, install, list, run)
+
+Implements:
+    - docs/cli/reference.md#huitzo-publish
+    - docs/cli/reference.md#huitzo-install
+    - docs/cli/reference.md#huitzo-list
+    - docs/cli/reference.md#huitzo-run
+"""
+
+import subprocess
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+console = Console()
+registry_app = typer.Typer(help="Registry operations")
+
+
+@registry_app.command()
+def publish() -> None:
+    """Publish pack to Huitzo Registry.
+
+    Note: Requires Huitzo Cloud (not yet available).
+    """
+    console.print("[yellow]ℹ️  Huitzo Cloud Registry is not yet available[/yellow]")
+    console.print("This feature is coming soon!")
+    raise typer.Exit(1)
+
+
+@registry_app.command()
+def install(
+    package: str = typer.Argument(..., help="Package name or path to .whl file"),
+) -> None:
+    """Install a pack from registry or local file.
+
+    Args:
+        package: Package name (from registry) or path to .whl file
+    """
+    # Check if it's a local file
+    if package.endswith(".whl"):
+        path = Path(package)
+        if not path.exists():
+            console.print(f"[red]❌ File not found: {package}[/red]")
+            raise typer.Exit(1)
+
+        console.print(f"[bold]Installing from: {package}[/bold]")
+        try:
+            result = subprocess.run(["pip", "install", str(path)], check=False)
+            if result.returncode != 0:
+                raise typer.Exit(result.returncode)
+            console.print("[green]✅ Installation successful[/green]")
+        except FileNotFoundError:
+            console.print("[red]❌ pip not found[/red]")
+            raise typer.Exit(1)
+    else:
+        # Try to install from registry
+        console.print(f"[bold]Installing: {package}[/bold]")
+        console.print("[yellow]ℹ️  Huitzo Cloud Registry is not yet available[/yellow]")
+        console.print("Use a local .whl file or install from PyPI")
+        raise typer.Exit(1)
+
+
+@registry_app.command()
+def list_packs() -> None:
+    """List installed packs."""
+    console.print("[bold]Installed Huitzo Packs:[/bold]")
+
+    try:
+        result = subprocess.run(
+            ["pip", "list", "--format", "json"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        import json
+
+        packages = json.loads(result.stdout)
+        huitzo_packs = [p for p in packages if "pack" in p["name"].lower()]
+
+        if huitzo_packs:
+            for pack in huitzo_packs:
+                console.print(f"  • {pack['name']} ({pack['version']})")
+        else:
+            console.print("  (none installed)")
+    except (FileNotFoundError, json.JSONDecodeError):
+        console.print("[yellow]⚠️  Could not list packages[/yellow]")
+
+
+@registry_app.command()
+def run(
+    pack_command: str = typer.Argument(..., help="Pack command (e.g., my-pack:hello)"),
+) -> None:
+    """Run a pack command.
+
+    Note: Requires Huitzo Cloud (not yet available).
+
+    Args:
+        pack_command: Pack and command name (format: pack-name:command-name)
+    """
+    console.print("[yellow]ℹ️  Cloud execution is not yet available[/yellow]")
+    console.print("This feature is coming soon!")
+    raise typer.Exit(1)

huitzo_cli/commands/secrets.py

@@ -0,0 +1,197 @@
+"""
+Module: secrets_command
+Description: Secrets management commands (local storage only)
+
+Implements:
+    - docs/cli/reference.md#huitzo-secrets
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+secrets_app = typer.Typer(help="Manage secrets")
+
+
+class SecretsStore:
+    """Local secrets storage."""
+
+    @staticmethod
+    def _get_secrets_dir() -> Path:
+        """Get platform-specific secrets directory."""
+        if os.name == "nt":  # Windows
+            base = Path(os.environ.get("APPDATA", Path.home() / "AppData" / "Roaming"))
+            return base / "huitzo" / "secrets"
+        else:  # Unix-like
+            return Path.home() / ".huitzo" / "secrets"
+
+    @classmethod
+    def _get_secrets_file(cls, pack_name: str = "default") -> Path:
+        """Get secrets file for pack."""
+        return cls._get_secrets_dir() / f"{pack_name}.json"
+
+    @classmethod
+    def set(cls, name: str, value: str, pack: str = "default") -> None:
+        """Store a secret."""
+        secrets_dir = cls._get_secrets_dir()
+        secrets_dir.mkdir(parents=True, exist_ok=True)
+
+        # Set restrictive permissions on directory
+        if os.name != "nt":
+            secrets_dir.chmod(0o700)
+
+        secrets_file = cls._get_secrets_file(pack)
+
+        # Load existing secrets
+        secrets = {}
+        if secrets_file.exists():
+            try:
+                with open(secrets_file) as f:
+                    secrets = json.load(f)
+            except (json.JSONDecodeError, OSError):
+                pass
+
+        # Add new secret
+        secrets[name] = value
+
+        # Save secrets
+        with open(secrets_file, "w") as f:
+            json.dump(secrets, f)
+
+        # Set restrictive permissions on file
+        if os.name != "nt":
+            secrets_file.chmod(0o600)
+
+    @classmethod
+    def get(cls, name: str, pack: str = "default") -> Optional[str]:
+        """Get a secret."""
+        secrets_file = cls._get_secrets_file(pack)
+
+        if not secrets_file.exists():
+            return None
+
+        try:
+            with open(secrets_file) as f:
+                secrets: dict[str, Any] = json.load(f)
+                value: str | None = secrets.get(name)
+                return value
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    @classmethod
+    def list_secrets(cls, pack: str = "default") -> dict[str, Any]:
+        """List all secrets for a pack."""
+        secrets_file = cls._get_secrets_file(pack)
+
+        if not secrets_file.exists():
+            return {}
+
+        try:
+            with open(secrets_file) as f:
+                result: dict[str, Any] = json.load(f)
+                return result
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    @classmethod
+    def remove(cls, name: str, pack: str = "default") -> None:
+        """Remove a secret."""
+        secrets_file = cls._get_secrets_file(pack)
+
+        if not secrets_file.exists():
+            return
+
+        try:
+            with open(secrets_file) as f:
+                secrets = json.load(f)
+
+            if name in secrets:
+                del secrets[name]
+
+            with open(secrets_file, "w") as f:
+                json.dump(secrets, f)
+
+        except (json.JSONDecodeError, OSError):
+            pass
+
+
+@secrets_app.command()
+def set(
+    name: str,
+    value: str,
+    pack: str = typer.Option("default", "--pack", help="Pack name"),
+) -> None:
+    """Set a secret.
+
+    Args:
+        name: Secret name
+        value: Secret value
+    """
+    console.print("[yellow]ℹ️  Secrets are stored locally only[/yellow]")
+    console.print("[yellow]Cloud sync is not yet available[/yellow]")
+    console.print()
+
+    SecretsStore.set(name, value, pack=pack)
+    console.print(f"[green]✅ Secret '{name}' set[/green]")
+
+
+@secrets_app.command()
+def list_secrets(pack: str = typer.Option("default", "--pack", help="Pack name")) -> None:
+    """List all secrets."""
+    console.print("[yellow]ℹ️  Secrets are stored locally only[/yellow]")
+    console.print()
+
+    secrets = SecretsStore.list_secrets(pack=pack)
+
+    if not secrets:
+        console.print(f"[yellow]No secrets for pack '{pack}'[/yellow]")
+        return
+
+    table = Table(title=f"Secrets (pack: {pack})")
+    table.add_column("Name", style="cyan")
+    table.add_column("Value", style="yellow")
+
+    for name, value in secrets.items():
+        masked_value = "*" * 8 if value else "(empty)"
+        table.add_row(name, masked_value)
+
+    console.print(table)
+
+
+@secrets_app.command()
+def remove(
+    name: str,
+    pack: str = typer.Option("default", "--pack", help="Pack name"),
+) -> None:
+    """Remove a secret.
+
+    Args:
+        name: Secret name
+    """
+    SecretsStore.remove(name, pack=pack)
+    console.print(f"[green]✅ Secret '{name}' removed[/green]")
+
+
+@secrets_app.command()
+def show(
+    name: str,
+    pack: str = typer.Option("default", "--pack", help="Pack name"),
+) -> None:
+    """Show secret value.
+
+    Args:
+        name: Secret name
+    """
+    value = SecretsStore.get(name, pack=pack)
+
+    if value is None:
+        console.print(f"[red]❌ Secret '{name}' not found[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"{name} = {value}")

huitzo_cli/commands/test.py

@@ -0,0 +1,56 @@
+"""
+Module: test_command
+Description: Test runner command
+
+Implements:
+    - docs/cli/reference.md#huitzo-test
+"""
+
+import subprocess
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+console = Console()
+test_app = typer.Typer(help="Run pack tests")
+
+
+@test_app.command()
+def test(
+    coverage: bool = typer.Option(False, "--coverage", help="Generate coverage report"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
+    parallel: bool = typer.Option(False, "--parallel", "-p", help="Run tests in parallel"),
+    filter_pattern: Optional[str] = typer.Option(
+        None, "--filter", "-k", help="Filter tests by pattern"
+    ),
+) -> None:
+    """Run pack tests using pytest.
+
+    Options:
+    - --coverage: Generate coverage report (requires pytest-cov)
+    - --verbose: Verbose test output
+    - --parallel: Run tests in parallel (requires pytest-xdist)
+    - --filter: Filter tests by pattern (pytest -k syntax)
+    """
+    cmd = ["pytest", "tests/"]
+
+    if verbose:
+        cmd.append("-v")
+
+    if coverage:
+        cmd.extend(["--cov=src", "--cov-report=term-missing"])
+
+    if parallel:
+        cmd.extend(["-n", "auto"])
+
+    if filter_pattern:
+        cmd.extend(["-k", filter_pattern])
+
+    try:
+        result = subprocess.run(cmd, check=False)
+        if result.returncode != 0:
+            raise typer.Exit(result.returncode)
+    except FileNotFoundError:
+        console.print("[red]❌ pytest not found. Install with: pip install pytest[/red]")
+        raise typer.Exit(1)

huitzo_cli/commands/validate.py

@@ -0,0 +1,64 @@
+"""
+Module: validate_command
+Description: Pack validation command
+
+Implements:
+    - docs/cli/reference.md#huitzo-validate
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from huitzo_cli.validator import PackValidator
+
+console = Console()
+validate_app = typer.Typer(help="Validate pack structure")
+
+
+@validate_app.command()
+def validate(
+    path: Optional[Path] = typer.Option(None, "--path", help="Path to pack root"),
+    strict: bool = typer.Option(False, "--strict", help="Treat warnings as errors"),
+) -> None:
+    """Validate Intelligence Pack structure.
+
+    Checks for:
+    - pyproject.toml with required fields
+    - huitzo.yaml manifest with required fields
+    - Source directory with Python package
+    - Test directory with tests
+    - README documentation
+    """
+    pack_root = path or Path.cwd()
+
+    if not pack_root.exists():
+        console.print(f"[red]❌ Pack path not found: {pack_root}[/red]")
+        raise typer.Exit(1)
+
+    validator = PackValidator(pack_root=pack_root)
+    result = validator.validate(strict=strict)
+
+    # Print results
+    console.print()
+    if result.valid:
+        console.print("[green]✅ Validation: PASSED[/green]")
+    else:
+        console.print("[red]❌ Validation: FAILED[/red]")
+
+    if result.errors:
+        console.print("\n[red]Errors:[/red]")
+        for error in result.errors:
+            console.print(f"  • {error}")
+
+    if result.warnings:
+        console.print("\n[yellow]Warnings:[/yellow]")
+        for warning in result.warnings:
+            console.print(f"  • {warning}")
+
+    console.print()
+
+    if not result.valid:
+        raise typer.Exit(1)