gobby 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

gobby/cli/conductor.py

@@ -0,0 +1,266 @@
+"""
+Conductor management CLI commands.
+
+Commands for managing the conductor loop:
+- start: Start the conductor loop
+- stop: Stop the conductor loop
+- restart: Restart the conductor loop
+- status: Show conductor status
+- chat: Send a message to the conductor
+"""
+
+import json
+
+import click
+import httpx
+
+
+def get_daemon_url() -> str:
+    """Get daemon URL from config."""
+    from gobby.config.app import load_config
+
+    config = load_config()
+    return f"http://localhost:{config.daemon_port}"
+
+
+@click.group()
+def conductor() -> None:
+    """Manage the conductor orchestration loop."""
+    pass
+
+
+@conductor.command("start")
+@click.option("--interval", "-i", type=int, default=30, help="Check interval in seconds")
+@click.option("--autonomous", "-a", is_flag=True, help="Enable autonomous agent spawning")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def start_conductor(interval: int, autonomous: bool, json_format: bool) -> None:
+    """Start the conductor loop.
+
+    Examples:
+
+        gobby conductor start
+
+        gobby conductor start --interval 60
+
+        gobby conductor start --autonomous
+    """
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/conductor/start",
+            json={"interval": interval, "autonomous": autonomous},
+            timeout=10.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"Error: HTTP {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except ValueError as e:
+        click.echo(f"Error: Invalid JSON response: {e}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo("Conductor started")
+        click.echo(f"  Interval: {interval}s")
+        if autonomous:
+            click.echo("  Autonomous mode: enabled")
+    else:
+        click.echo(f"Failed to start conductor: {result.get('error')}", err=True)
+
+
+@conductor.command("stop")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def stop_conductor(json_format: bool) -> None:
+    """Stop the conductor loop.
+
+    Examples:
+
+        gobby conductor stop
+    """
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/conductor/stop",
+            json={},
+            timeout=10.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"Error: HTTP {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except ValueError as e:
+        click.echo(f"Error: Invalid JSON response: {e}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo("Conductor stopped")
+    else:
+        click.echo(f"Failed to stop conductor: {result.get('error')}", err=True)
+
+
+@conductor.command("restart")
+@click.option("--interval", "-i", type=int, default=30, help="Check interval in seconds")
+@click.option("--autonomous", "-a", is_flag=True, help="Enable autonomous agent spawning")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def restart_conductor(interval: int, autonomous: bool, json_format: bool) -> None:
+    """Restart the conductor loop.
+
+    Examples:
+
+        gobby conductor restart
+
+        gobby conductor restart --interval 60
+    """
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/conductor/restart",
+            json={"interval": interval, "autonomous": autonomous},
+            timeout=10.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"Error: HTTP {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except ValueError as e:
+        click.echo(f"Error: Invalid JSON response: {e}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo("Conductor restarted")
+    else:
+        click.echo(f"Failed to restart conductor: {result.get('error')}", err=True)
+
+
+@conductor.command("status")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def status_conductor(json_format: bool) -> None:
+    """Show conductor status.
+
+    Examples:
+
+        gobby conductor status
+
+        gobby conductor status --json
+    """
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.get(
+            f"{daemon_url}/conductor/status",
+            timeout=10.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"Error: HTTP {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except ValueError as e:
+        click.echo(f"Error: Invalid JSON response: {e}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    running = result.get("running", False)
+    if running:
+        click.echo("Conductor: running")
+        click.echo(f"  Interval: {result.get('interval', 'unknown')}s")
+        click.echo(f"  Autonomous: {result.get('autonomous', False)}")
+        if result.get("last_tick"):
+            click.echo(f"  Last tick: {result['last_tick']}")
+    else:
+        click.echo("Conductor: not running")
+
+
+@conductor.command("chat")
+@click.argument("message")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def chat_conductor(message: str, json_format: bool) -> None:
+    """Send a message to the conductor.
+
+    The conductor can process commands like status checks, task queries,
+    or trigger manual actions.
+
+    Examples:
+
+        gobby conductor chat "Check all tasks"
+
+        gobby conductor chat "spawn agent for task-123"
+
+        gobby conductor chat --json "status check"
+    """
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/conductor/chat",
+            json={"message": message},
+            timeout=30.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"Error: HTTP {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except ValueError as e:
+        click.echo(f"Error: Invalid JSON response: {e}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo(result.get("response", "OK"))
+    else:
+        click.echo(f"Error: {result.get('error', 'Unknown error')}", err=True)

gobby/cli/installers/antigravity.py

@@ -12,7 +12,7 @@ import logging
 from pathlib import Path
 from typing import Any
 
-from .shared import configure_mcp_server_json, install_shared_skills
+from .shared import configure_mcp_server_json
 
 logger = logging.getLogger(__name__)
 
@@ -43,14 +43,8 @@ def install_antigravity(project_path: Path) -> dict[str, Any]:
     # Configure MCP server in Antigravity's MCP config (~/.gemini/antigravity/mcp_config.json)
     mcp_config = Path.home() / ".gemini" / "antigravity" / "mcp_config.json"
 
-    # Install shared skills to ~/.antigravity/skills/ (Standard Antigravity location)
-    try:
-        skills_path = Path.home() / ".antigravity" / "skills"
-        skills = install_shared_skills(skills_path)
-        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
-    except Exception as e:
-        logger.error(f"Failed to install shared skills: {e}")
-        # Proceeding despite skill install failure
+    # Skills are now auto-synced to database on daemon startup (sync_bundled_skills)
+    # No longer need to copy to .antigravity/skills/
 
     mcp_result = configure_mcp_server_json(mcp_config)
 

gobby/cli/installers/claude.py

@@ -17,10 +17,10 @@ from typing import Any
 from gobby.cli.utils import get_install_dir
 
 from .shared import (
+    backup_gobby_skills,
     configure_mcp_server_json,
     install_cli_content,
     install_shared_content,
-    install_shared_skills,
     remove_mcp_server_json,
 )
 
@@ -55,6 +55,12 @@ def install_claude(project_path: Path) -> dict[str, Any]:
     hooks_dir = claude_path / "hooks"
     hooks_dir.mkdir(parents=True, exist_ok=True)
 
+    # Backup existing gobby skills (now auto-synced from database)
+    skills_dir = claude_path / "skills"
+    backup_result = backup_gobby_skills(skills_dir)
+    if backup_result["backed_up"] > 0:
+        logger.info(f"Backed up {backup_result['backed_up']} existing gobby skills")
+
     # Get source files
     install_dir = get_install_dir()
     claude_install_dir = install_dir / "claude"
@@ -119,14 +125,8 @@ def install_claude(project_path: Path) -> dict[str, Any]:
     result["commands_installed"] = cli.get("commands", [])
     result["plugins_installed"] = shared.get("plugins", [])
 
-    # Install shared skills (SKILL.md)
-    try:
-        skills = install_shared_skills(claude_path / "skills")
-        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
-    except Exception as e:
-        logger.error(f"Failed to install shared skills: {e}")
-        result["error"] = f"Failed to install shared skills: {e}"
-        # Proceeding despite skill install failure
+    # Skills are now auto-synced to database on daemon startup (sync_bundled_skills)
+    # No longer need to copy to .claude/skills/
 
     # Backup existing settings.json if it exists
     backup_file = None

gobby/cli/installers/codex.py

@@ -18,7 +18,6 @@ from .shared import (
     configure_mcp_server_toml,
     install_cli_content,
     install_shared_content,
-    install_shared_skills,
     remove_mcp_server_toml,
 )
 
@@ -69,13 +68,8 @@ def install_codex_notify() -> dict[str, Any]:
     # Install CLI-specific content (can override shared)
     cli = install_cli_content("codex", codex_home)
 
-    # Install shared skills (SKILL.md)
-    try:
-        skills = install_shared_skills(codex_home / "skills")
-        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
-    except Exception as e:
-        logger.error(f"Failed to install shared skills: {e}")
-        # Proceeding despite skill install failure
+    # Skills are now auto-synced to database on daemon startup (sync_bundled_skills)
+    # No longer need to copy to .codex/skills/
 
     result["workflows_installed"] = shared["workflows"] + cli["workflows"]
     result["commands_installed"] = cli.get("commands", [])

gobby/cli/installers/gemini.py

@@ -18,7 +18,6 @@ from .shared import (
     configure_mcp_server_json,
     install_cli_content,
     install_shared_content,
-    install_shared_skills,
     remove_mcp_server_json,
 )
 
@@ -81,13 +80,8 @@ def install_gemini(project_path: Path) -> dict[str, Any]:
     # Install CLI-specific content (can override shared)
     cli = install_cli_content("gemini", gemini_path)
 
-    # Install shared skills (SKILL.md)
-    try:
-        skills = install_shared_skills(gemini_path / "skills")
-        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
-    except Exception as e:
-        logger.error(f"Failed to install shared skills: {e}")
-        # Proceeding despite skill install failure
+    # Skills are now auto-synced to database on daemon startup (sync_bundled_skills)
+    # No longer need to copy to .gemini/skills/
 
     result["workflows_installed"] = shared["workflows"] + cli["workflows"]
     result["commands_installed"] = cli.get("commands", [])

gobby/cli/installers/shared.py

@@ -41,10 +41,17 @@ def install_shared_content(cli_path: Path, project_path: Path) -> dict[str, list
     if shared_workflows.exists():
         target_workflows = project_path / ".gobby" / "workflows"
         target_workflows.mkdir(parents=True, exist_ok=True)
-        for workflow_file in shared_workflows.iterdir():
-            if workflow_file.is_file():
-                copy2(workflow_file, target_workflows / workflow_file.name)
-                installed["workflows"].append(workflow_file.name)
+        for item in shared_workflows.iterdir():
+            if item.is_file():
+                copy2(item, target_workflows / item.name)
+                installed["workflows"].append(item.name)
+            elif item.is_dir():
+                # Copy subdirectories (e.g., lifecycle/)
+                target_subdir = target_workflows / item.name
+                if target_subdir.exists():
+                    shutil.rmtree(target_subdir)
+                copytree(item, target_subdir)
+                installed["workflows"].append(f"{item.name}/")
 
     # Install shared plugins to ~/.gobby/plugins/ (global)
     shared_plugins = shared_dir / "plugins"
@@ -69,6 +76,55 @@ def install_shared_content(cli_path: Path, project_path: Path) -> dict[str, list
     return installed
 
 
+def backup_gobby_skills(skills_dir: Path) -> dict[str, Any]:
+    """Move gobby-prefixed skill directories to a backup location.
+
+    This function is called during installation to preserve existing gobby skills
+    before they are replaced by database-synced skills. User custom skills
+    (non-gobby prefixed) are not touched.
+
+    Args:
+        skills_dir: Path to skills directory (e.g., .claude/skills)
+
+    Returns:
+        Dict with:
+        - success: bool
+        - backed_up: int - number of skills moved to backup
+        - skipped: str (optional) - reason for skipping
+    """
+    result: dict[str, Any] = {
+        "success": True,
+        "backed_up": 0,
+    }
+
+    if not skills_dir.exists():
+        result["skipped"] = "skills directory does not exist"
+        return result
+
+    # Find gobby-prefixed skill directories
+    gobby_skills = [d for d in skills_dir.iterdir() if d.is_dir() and d.name.startswith("gobby-")]
+
+    if not gobby_skills:
+        return result
+
+    # Create backup directory (sibling to skills/)
+    backup_dir = skills_dir.parent / "skills.backup"
+    backup_dir.mkdir(parents=True, exist_ok=True)
+
+    # Move each gobby skill to backup
+    import shutil
+
+    for skill_dir in gobby_skills:
+        target = backup_dir / skill_dir.name
+        # If already exists in backup, remove it first (replace with newer)
+        if target.exists():
+            shutil.rmtree(target)
+        shutil.move(str(skill_dir), str(target))
+        result["backed_up"] += 1
+
+    return result
+
+
 def install_shared_skills(target_dir: Path) -> list[str]:
     """Install shared SKILL.md files to target directory.
 
@@ -149,10 +205,17 @@ def install_cli_content(cli_name: str, target_path: Path) -> dict[str, list[str]
     if cli_workflows.exists():
         target_workflows = target_path / "workflows"
         target_workflows.mkdir(parents=True, exist_ok=True)
-        for workflow_file in cli_workflows.iterdir():
-            if workflow_file.is_file():
-                copy2(workflow_file, target_workflows / workflow_file.name)
-                installed["workflows"].append(workflow_file.name)
+        for item in cli_workflows.iterdir():
+            if item.is_file():
+                copy2(item, target_workflows / item.name)
+                installed["workflows"].append(item.name)
+            elif item.is_dir():
+                # Copy subdirectories
+                target_subdir = target_workflows / item.name
+                if target_subdir.exists():
+                    shutil.rmtree(target_subdir)
+                copytree(item, target_subdir)
+                installed["workflows"].append(f"{item.name}/")
 
     # CLI-specific commands (slash commands)
     # Claude/Gemini: commands/, Codex: prompts/