gobby 0.2.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

gobby/cli/skills.py

@@ -239,11 +239,15 @@ def install(ctx: click.Context, source: str, project: bool) -> None:
     """Install a skill from a source.
 
     SOURCE can be:
+    - A hub reference (e.g., clawdhub:commit-message, skillhub:code-review)
     - A local directory path (e.g., ./my-skill or /path/to/skill)
     - A path to a SKILL.md file (e.g., ./SKILL.md)
     - A GitHub URL (owner/repo, github:owner/repo, https://github.com/owner/repo)
     - A ZIP archive path (e.g., ./skills.zip)
 
+    Use 'gobby skills hub list' to see available hubs.
+    Use 'gobby skills search <query>' to find skills.
+
     Use --project to scope the skill to the current project.
 
     Requires daemon to be running.
@@ -856,3 +860,208 @@ def disable(ctx: click.Context, name: str) -> None:
         click.echo(f"Error disabling skill: {e}", err=True)
         sys.exit(1)
     click.echo(f"Disabled skill: {name}")
+
+
+@skills.command()
+@click.argument("query")
+@click.option("--hub", "-h", "hub_name", default=None, help="Search only in specific hub")
+@click.option("--limit", "-n", default=20, help="Maximum results to show")
+@click.option("--json", "json_output", is_flag=True, help="Output as JSON")
+@click.pass_context
+def search(
+    ctx: click.Context,
+    query: str,
+    hub_name: str | None,
+    limit: int,
+    json_output: bool,
+) -> None:
+    """Search for skills across configured hubs.
+
+    QUERY is the search term (e.g., 'commit message', 'code review').
+
+    Use --hub to search only in a specific hub.
+
+    Requires daemon to be running.
+    """
+    client = get_daemon_client(ctx)
+    if not check_daemon(client):
+        sys.exit(1)
+
+    arguments: dict[str, Any] = {"query": query, "limit": limit}
+    if hub_name:
+        arguments["hub_name"] = hub_name
+
+    result = call_skills_tool(client, "search_hub", arguments)
+
+    if result is None:
+        click.echo("Error: Failed to communicate with daemon", err=True)
+        sys.exit(1)
+    elif not result.get("success"):
+        click.echo(f"Error: {result.get('error', 'Unknown error')}", err=True)
+        sys.exit(1)
+
+    results_list = result.get("results", [])
+
+    if json_output:
+        click.echo(json.dumps(results_list, indent=2))
+        return
+
+    if not results_list:
+        click.echo("No skills found matching your query.")
+        return
+
+    click.echo(f"Found {len(results_list)} skill(s):\n")
+    for skill in results_list:
+        hub = skill.get("hub_name", "unknown")
+        slug = skill.get("slug", "unknown")
+        name = skill.get("display_name", slug)
+        desc = skill.get("description", "")[:60]
+        click.echo(f"  [{hub}] {name}")
+        if desc:
+            click.echo(f"          {desc}")
+        click.echo(f"          Install: gobby skills install {hub}:{slug}")
+        click.echo("")
+
+
+# Hub subcommand group
+@skills.group()
+def hub() -> None:
+    """Manage skill hubs (registries)."""
+    pass
+
+
+@hub.command("list")
+@click.option("--json", "json_output", is_flag=True, help="Output as JSON")
+@click.pass_context
+def hub_list(ctx: click.Context, json_output: bool) -> None:
+    """List configured skill hubs.
+
+    Shows all configured skill hubs with their type and status.
+
+    Requires daemon to be running.
+    """
+    client = get_daemon_client(ctx)
+    if not check_daemon(client):
+        sys.exit(1)
+
+    result = call_skills_tool(client, "list_hubs", {})
+
+    if result is None:
+        click.echo("Error: Failed to communicate with daemon", err=True)
+        sys.exit(1)
+    elif not result.get("success"):
+        click.echo(f"Error: {result.get('error', 'Unknown error')}", err=True)
+        sys.exit(1)
+
+    hubs_list = result.get("hubs", [])
+
+    if json_output:
+        click.echo(json.dumps(hubs_list, indent=2))
+        return
+
+    if not hubs_list:
+        click.echo("No hubs configured.")
+        click.echo("\nTo add hubs, update your config.yaml with a 'hubs' section.")
+        return
+
+    click.echo("Configured hubs:\n")
+    for h in hubs_list:
+        name = h.get("name", "unknown")
+        hub_type = h.get("type", "unknown")
+        base_url = h.get("base_url", "")
+        url_str = f" ({base_url})" if base_url else ""
+        click.echo(f"  {name} [{hub_type}]{url_str}")
+
+
+@hub.command("add")
+@click.argument("name")
+@click.option("--type", "hub_type", required=True, help="Hub type (clawdhub, skillhub, github)")
+@click.option("--url", "base_url", default=None, help="Base URL for skillhub type")
+@click.option("--repo", default=None, help="GitHub repo (owner/repo) for github type")
+@click.option("--branch", default=None, help="Branch for github type (default: main)")
+@click.option(
+    "--auth-key", "auth_key_name", default=None, help="Environment variable name for auth key"
+)
+@click.pass_context
+def hub_add(
+    ctx: click.Context,
+    name: str,
+    hub_type: str,
+    base_url: str | None,
+    repo: str | None,
+    branch: str | None,
+    auth_key_name: str | None,
+) -> None:
+    """Add a new skill hub.
+
+    NAME is the hub name (e.g., 'my-skills', 'company-hub').
+
+    Hub types:
+    - clawdhub: ClawdHub CLI-based hub
+    - skillhub: REST API-based skill hub (requires --url)
+    - github: GitHub repository collection (requires --repo)
+
+    Examples:
+        gobby skills hub add my-skillhub --type skillhub --url https://skillhub.example.com
+        gobby skills hub add company-skills --type github --repo myorg/skills
+    """
+    import yaml
+
+    # Validate hub type
+    valid_types = ["clawdhub", "skillhub", "github"]
+    if hub_type not in valid_types:
+        click.echo(
+            f"Error: Invalid hub type '{hub_type}'. Must be one of: {', '.join(valid_types)}",
+            err=True,
+        )
+        sys.exit(1)
+
+    # Validate required options for each type
+    if hub_type == "skillhub" and not base_url:
+        click.echo("Error: --url is required for skillhub type", err=True)
+        sys.exit(1)
+
+    if hub_type == "github" and not repo:
+        click.echo("Error: --repo is required for github type", err=True)
+        sys.exit(1)
+
+    # Build hub config
+    hub_config: dict[str, Any] = {"type": hub_type}
+    if base_url:
+        hub_config["base_url"] = base_url
+    if repo:
+        hub_config["repo"] = repo
+    if branch:
+        hub_config["branch"] = branch
+    if auth_key_name:
+        hub_config["auth_key_name"] = auth_key_name
+
+    # Load existing config
+    config_path = Path.home() / ".gobby" / "config.yaml"
+    if config_path.exists():
+        with open(config_path, encoding="utf-8") as f:
+            config = yaml.safe_load(f) or {}
+    else:
+        config = {}
+
+    # Ensure hubs section exists
+    if "hubs" not in config:
+        config["hubs"] = {}
+
+    # Check if hub already exists
+    if name in config["hubs"]:
+        click.echo(
+            f"Error: Hub '{name}' already exists. Use 'hub remove' first to replace it.", err=True
+        )
+        sys.exit(1)
+
+    # Add the hub
+    config["hubs"][name] = hub_config
+
+    # Write config
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(config_path, "w", encoding="utf-8") as f:
+        yaml.dump(config, f, default_flow_style=False)
+
+    click.echo(f"Added hub: {name} [{hub_type}]")
+    click.echo("\nRestart the daemon for changes to take effect: gobby restart")

gobby/cli/tasks/crud.py

@@ -26,7 +26,7 @@ from gobby.utils.project_context import get_project_context
 @click.option(
     "--status",
     "-s",
-    help="Filter by status (open, in_progress, review, closed, blocked). Comma-separated for multiple.",
+    help="Filter by status (open, in_progress, needs_review, closed, blocked). Comma-separated for multiple.",
 )
 @click.option(
     "--active",
@@ -266,7 +266,7 @@ def task_stats(project_ref: str | None, json_format: bool) -> None:
     # Get counts by status
     all_tasks = manager.list_tasks(project_id=project_id, limit=10000)
     total = len(all_tasks)
-    by_status = {"open": 0, "in_progress": 0, "review": 0, "closed": 0}
+    by_status = {"open": 0, "in_progress": 0, "needs_review": 0, "closed": 0}
     by_priority = {1: 0, 2: 0, 3: 0}
     by_type: dict[str, int] = {}
 
@@ -302,7 +302,7 @@ def task_stats(project_ref: str | None, json_format: bool) -> None:
     click.echo(f"  Total: {total}")
     click.echo(f"  Open: {by_status.get('open', 0)}")
     click.echo(f"  In Progress: {by_status.get('in_progress', 0)}")
-    click.echo(f"  Review: {by_status.get('review', 0)}")
+    click.echo(f"  Needs Review: {by_status.get('needs_review', 0)}")
     click.echo(f"  Closed: {by_status.get('closed', 0)}")
     click.echo(f"\n  Ready (no blockers): {ready_count}")
     click.echo(f"  Blocked: {blocked_count}")
@@ -547,9 +547,10 @@ def reopen_task_cmd(task_id: str, reason: str | None) -> None:
     # Use standardized ref for errors
     resolved_ref = f"#{resolved.seq_num}" if resolved.seq_num else resolved.id[:8]
 
-    if resolved.status not in ("closed", "review"):
+    if resolved.status not in ("closed", "needs_review"):
         click.echo(
-            f"Task {resolved_ref} is not closed or in review (status: {resolved.status})", err=True
+            f"Task {resolved_ref} is not closed or in needs_review (status: {resolved.status})",
+            err=True,
         )
         return
 

gobby/cli/tasks/search.py

@@ -18,7 +18,7 @@ from gobby.cli.utils import resolve_project_ref
 @click.option(
     "--status",
     "-s",
-    help="Filter by status (open, in_progress, review, closed). Comma-separated for multiple.",
+    help="Filter by status (open, in_progress, needs_review, closed). Comma-separated for multiple.",
 )
 @click.option(
     "--type",

gobby/cli/ui.py

@@ -0,0 +1,116 @@
+"""
+CLI commands for Gobby web UI development.
+"""
+
+import subprocess  # nosec B404 - subprocess needed for npm commands
+import sys
+from pathlib import Path
+
+import click
+
+# Path to web UI directory
+WEB_UI_DIR = Path(__file__).parent.parent / "ui" / "web"
+
+
+@click.group()
+def ui() -> None:
+    """Web UI development commands."""
+    pass
+
+
+@ui.command()
+@click.option("--port", "-p", default=5173, help="Dev server port")
+@click.option("--host", "-h", default="localhost", help="Dev server host")
+def dev(port: int, host: str) -> None:
+    """Start the web UI development server with hot-reload."""
+    if not WEB_UI_DIR.exists():
+        click.echo(f"Error: Web UI directory not found at {WEB_UI_DIR}", err=True)
+        sys.exit(1)
+
+    package_json = WEB_UI_DIR / "package.json"
+    if not package_json.exists():
+        click.echo(f"Error: package.json not found at {package_json}", err=True)
+        sys.exit(1)
+
+    node_modules = WEB_UI_DIR / "node_modules"
+    if not node_modules.exists():
+        click.echo("Installing dependencies...")
+        result = subprocess.run(  # nosec B603 B607
+            ["npm", "install"],
+            cwd=WEB_UI_DIR,
+            capture_output=False,
+        )
+        if result.returncode != 0:
+            click.echo("Failed to install dependencies", err=True)
+            sys.exit(1)
+
+    click.echo(f"Starting dev server at http://{host}:{port}")
+    click.echo("Press Ctrl+C to stop")
+    click.echo()
+
+    try:
+        subprocess.run(  # nosec B603 B607
+            ["npm", "run", "dev", "--", "--host", host, "--port", str(port)],
+            cwd=WEB_UI_DIR,
+            check=True,
+        )
+    except KeyboardInterrupt:
+        click.echo("\nDev server stopped")
+    except subprocess.CalledProcessError as e:
+        click.echo(f"Dev server failed with code {e.returncode}", err=True)
+        sys.exit(e.returncode)
+
+
+@ui.command()
+def build() -> None:
+    """Build the web UI for production."""
+    if not WEB_UI_DIR.exists():
+        click.echo(f"Error: Web UI directory not found at {WEB_UI_DIR}", err=True)
+        sys.exit(1)
+
+    node_modules = WEB_UI_DIR / "node_modules"
+    if not node_modules.exists():
+        click.echo("Installing dependencies...")
+        result = subprocess.run(  # nosec B603 B607
+            ["npm", "install"],
+            cwd=WEB_UI_DIR,
+            capture_output=False,
+        )
+        if result.returncode != 0:
+            click.echo("Failed to install dependencies", err=True)
+            sys.exit(1)
+
+    click.echo("Building web UI...")
+    result = subprocess.run(  # nosec B603 B607
+        ["npm", "run", "build"],
+        cwd=WEB_UI_DIR,
+        capture_output=False,
+    )
+
+    if result.returncode == 0:
+        dist_dir = WEB_UI_DIR / "dist"
+        click.echo(f"Build complete: {dist_dir}")
+    else:
+        click.echo("Build failed", err=True)
+        sys.exit(result.returncode)
+
+
+@ui.command()
+def install_deps() -> None:
+    """Install web UI dependencies."""
+    if not WEB_UI_DIR.exists():
+        click.echo(f"Error: Web UI directory not found at {WEB_UI_DIR}", err=True)
+        sys.exit(1)
+
+    click.echo("Installing dependencies...")
+    result = subprocess.run(  # nosec B603 B607
+        ["npm", "install"],
+        cwd=WEB_UI_DIR,
+        capture_output=False,
+    )
+
+    if result.returncode == 0:
+        click.echo("Dependencies installed")
+    else:
+        click.echo("Failed to install dependencies", err=True)
+        sys.exit(result.returncode)

gobby/cli/workflows.py

@@ -11,6 +11,7 @@ import yaml
 
 from gobby.cli.utils import resolve_session_id
 from gobby.storage.database import LocalDatabase
+from gobby.workflows.definitions import WorkflowDefinition
 from gobby.workflows.loader import WorkflowLoader
 from gobby.workflows.state_manager import WorkflowStateManager
 
@@ -151,23 +152,34 @@ def show_workflow(ctx: click.Context, name: str, json_format: bool) -> None:
 
     if definition.steps:
         click.echo(f"\nSteps ({len(definition.steps)}):")
-        for step in definition.steps:
-            click.echo(f"  - {step.name}")
-            if step.description:
-                click.echo(f"      {step.description}")
-            if step.allowed_tools:
-                if step.allowed_tools == "all":
-                    click.echo("      Allowed tools: all")
-                else:
-                    tools = step.allowed_tools[:5]
-                    more = (
-                        f" (+{len(step.allowed_tools) - 5})" if len(step.allowed_tools) > 5 else ""
-                    )
-                    click.echo(f"      Allowed tools: {', '.join(tools)}{more}")
-            if step.blocked_tools:
-                click.echo(f"      Blocked tools: {', '.join(step.blocked_tools[:5])}")
-
-    if definition.triggers:
+        if isinstance(definition, WorkflowDefinition):
+            for step in definition.steps:
+                click.echo(f"  - {step.name}")
+                if step.description:
+                    click.echo(f"      {step.description}")
+                if step.allowed_tools:
+                    if step.allowed_tools == "all":
+                        click.echo("      Allowed tools: all")
+                    else:
+                        tools = step.allowed_tools[:5]
+                        more = (
+                            f" (+{len(step.allowed_tools) - 5})"
+                            if len(step.allowed_tools) > 5
+                            else ""
+                        )
+                        click.echo(f"      Allowed tools: {', '.join(tools)}{more}")
+                if step.blocked_tools:
+                    click.echo(f"      Blocked tools: {', '.join(step.blocked_tools[:5])}")
+        else:
+            # PipelineDefinition
+            for pstep in definition.steps:
+                click.echo(f"  - {pstep.id}")
+                if pstep.exec:
+                    click.echo(f"      exec: {pstep.exec[:60]}...")
+                elif pstep.prompt:
+                    click.echo(f"      prompt: {pstep.prompt[:60]}...")
+
+    if isinstance(definition, WorkflowDefinition) and definition.triggers:
         click.echo("\nTriggers:")
         for trigger_name, actions in definition.triggers.items():
             click.echo(f"  {trigger_name}: {len(actions)} action(s)")
@@ -271,6 +283,11 @@ def set_workflow(
         click.echo("Use 'gobby workflows set' only for step-based workflows.", err=True)
         raise SystemExit(1)
 
+    if not isinstance(definition, WorkflowDefinition):
+        click.echo(f"'{name}' is a pipeline, not a step-based workflow.", err=True)
+        click.echo("Use 'gobby pipelines run' for pipelines.", err=True)
+        raise SystemExit(1)
+
     # Get session
     try:
         session_id = resolve_session_id(session_id)
@@ -374,6 +391,10 @@ def set_step(ctx: click.Context, step_name: str, session_id: str | None, force:
         click.echo(f"Workflow '{state.workflow_name}' not found.", err=True)
         raise SystemExit(1)
 
+    if not isinstance(definition, WorkflowDefinition):
+        click.echo(f"'{state.workflow_name}' is a pipeline, not a step-based workflow.", err=True)
+        raise SystemExit(1)
+
     if not any(s.name == step_name for s in definition.steps):
         click.echo(f"Step '{step_name}' not found in workflow.", err=True)
         click.echo(f"Available steps: {', '.join(s.name for s in definition.steps)}")

gobby/config/app.py

@@ -141,6 +141,11 @@ class DaemonConfig(BaseModel):
         default=60887,
         description="Port for daemon to listen on",
     )
+    bind_host: str = Field(
+        default="localhost",
+        description="Host/IP to bind servers to. Use 'localhost' for local-only access, "
+        "'0.0.0.0' for all interfaces, or a specific IP (e.g., Tailscale IP) for restricted access.",
+    )
     daemon_health_check_interval: float = Field(
         default=10.0,
         description="Daemon health check interval in seconds",

gobby/config/skills.py

@@ -16,9 +16,9 @@ class HubConfig(BaseModel):
     Configuration for a skill hub or collection.
     """
 
-    type: Literal["clawdhub", "skillhub", "github-collection"] = Field(
+    type: Literal["clawdhub", "skillhub", "github-collection", "claude-plugins"] = Field(
         ...,
-        description="Type of the hub: 'clawdhub', 'skillhub', or 'github-collection'",
+        description="Type of the hub: 'clawdhub', 'skillhub', 'github-collection', or 'claude-plugins'",
     )
 
     base_url: str | None = Field(
@@ -36,6 +36,11 @@ class HubConfig(BaseModel):
         description="Git branch to use",
     )
 
+    path: str | None = Field(
+        default=None,
+        description="Subdirectory path within the repository where skills are located",
+    )
+
     auth_key_name: str | None = Field(
         default=None,
         description="Environment variable name for auth key",
@@ -64,6 +69,22 @@ class SkillsConfig(BaseModel):
         description="Format for skill injection: 'summary' (names only), 'full' (with content), 'none' (disabled)",
     )
 
+    hubs: dict[str, HubConfig] = Field(
+        default_factory=lambda: {
+            "anthropic-skills": HubConfig(
+                type="github-collection",
+                repo="anthropics/skills",
+                branch="main",
+                path="skills",
+            ),
+            "claude-plugins": HubConfig(
+                type="claude-plugins",
+                base_url="https://claude-plugins.dev",
+            ),
+        },
+        description="Configured skill hubs keyed by hub name",
+    )
+
     @field_validator("injection_format")
     @classmethod
     def validate_injection_format(cls, v: str) -> str:

gobby/hooks/broadcaster.py

@@ -117,6 +117,15 @@ class HookEventBroadcaster:
                 if "permission_type" not in raw_input:
                     raw_input["permission_type"] = "unknown"
 
+            # Ensure 'tool_name' has a default for before_tool_selection events
+            # These events fire before a specific tool is selected, so tool_name is not available
+            if (
+                enum_hook_type == HookType.PRE_TOOL_USE
+                and event.event_type.value == "before_tool_selection"
+            ):
+                if "tool_name" not in raw_input:
+                    raw_input["tool_name"] = "(tool_selection)"
+
             # Validate input data structure matches Pydantic model
             # Use construct/model_validate to avoid strict validation errors if possible,
             # or just try/except. Let's rely on standard validation.

gobby/hooks/event_handlers/_base.py

@@ -43,7 +43,11 @@ class EventHandlersBase:
     _handler_map: dict[HookEventType, Callable[[HookEvent], HookResponse]]
 
     def _auto_activate_workflow(
-        self, workflow_name: str, session_id: str, project_path: str | None
+        self,
+        workflow_name: str,
+        session_id: str,
+        project_path: str | None,
+        variables: dict[str, Any] | None = None,
     ) -> None:
         """Shared method for auto-activating workflows."""
         if not self._workflow_handler:
@@ -54,6 +58,7 @@ class EventHandlersBase:
                 workflow_name=workflow_name,
                 session_id=session_id,
                 project_path=project_path,
+                variables=variables,
             )
             if result.get("success"):
                 self.logger.info(