gobby 0.2.8__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/utils.py

@@ -394,23 +394,10 @@ def get_install_dir() -> Path:
     Returns:
         Path to the install directory
     """
-    import gobby
+    # Import from centralized paths module to avoid duplication
+    from gobby.paths import get_install_dir as _get_install_dir
 
-    package_install_dir = Path(gobby.__file__).parent / "install"
-
-    # Try to find source directory (project root)
-    current = Path(gobby.__file__).resolve()
-    source_install_dir = None
-
-    for parent in current.parents:
-        potential_source = parent / "src" / "gobby" / "install"
-        if potential_source.exists():
-            source_install_dir = potential_source
-            break
-
-    if source_install_dir and source_install_dir.exists():
-        return source_install_dir
-    return package_install_dir
+    return _get_install_dir()
 
 
 def _is_process_alive(pid: int) -> bool:
@@ -472,7 +459,8 @@ def stop_daemon(quiet: bool = False) -> bool:
             click.echo(f"Sent shutdown signal to Gobby daemon (PID {pid})")
 
         # Wait for graceful shutdown
-        max_wait = 5
+        # Match daemon's uvicorn timeout_graceful_shutdown (15s) + buffer
+        max_wait = 20
         for _ in range(max_wait * 10):
             time.sleep(0.1)
             if not _is_process_alive(pid):

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/features.py

@@ -23,7 +23,6 @@ __all__ = [
     "HookStageConfig",
     "HooksConfig",
     "TaskDescriptionConfig",
-    "DEFAULT_IMPORT_MCP_SERVER_PROMPT",
 ]
 
 
@@ -139,25 +138,6 @@ class RecommendToolsConfig(BaseModel):
     )
 
 
-DEFAULT_IMPORT_MCP_SERVER_PROMPT = """You are an MCP server configuration extractor. Given documentation for an MCP server, extract the configuration needed to connect to it.
-
-Return ONLY a valid JSON object (no markdown, no code blocks) with these fields:
-- name: Server name (lowercase, no spaces, use hyphens)
-- transport: "http", "stdio", or "websocket"
-- url: Server URL (required for http/websocket transports)
-- command: Command to run (required for stdio, e.g., "npx", "uv", "node")
-- args: Array of command arguments (for stdio)
-- env: Object of environment variables needed (use placeholder "<YOUR_KEY_NAME>" for secrets)
-- headers: Object of HTTP headers needed (use placeholder "<YOUR_KEY_NAME>" for secrets)
-- instructions: How to obtain any required API keys or setup steps
-
-Example stdio server:
-{"name": "filesystem", "transport": "stdio", "command": "npx", "args": ["-y", "@anthropic-ai/filesystem-mcp"], "env": {}, "instructions": "No setup required"}
-
-Example http server with API key:
-{"name": "exa", "transport": "http", "url": "https://mcp.exa.ai/mcp", "headers": {"EXA_API_KEY": "<YOUR_EXA_API_KEY>"}, "instructions": "Get your API key from https://exa.ai/dashboard"}"""
-
-
 class ImportMCPServerConfig(BaseModel):
     """MCP server import configuration."""
 

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/config/tasks.py

@@ -669,6 +669,10 @@ class WorkflowConfig(BaseModel):
         default_factory=lambda: ["Edit", "Write", "Update", "NotebookEdit"],
         description="Tools that require an active task when require_task_before_edit is enabled",
     )
+    debug_echo_context: bool = Field(
+        default=False,
+        description="Debug: echo additionalContext to system_message for terminal visibility",
+    )
 
     @field_validator("timeout")
     @classmethod

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.