gobby 0.2.5__py3-none-any.whl

gobby/utils/project_context.py

@@ -0,0 +1,182 @@
+"""
+Utilities for resolving project context.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+if TYPE_CHECKING:
+    from gobby.config.app import ProjectVerificationConfig
+    from gobby.config.features import HooksConfig
+
+logger = logging.getLogger(__name__)
+
+
+def find_project_root(cwd: Path | None = None) -> Path | None:
+    """
+    Find the project root directory by looking for .gobby/project.json.
+
+    Args:
+        cwd: Current working directory to start search from. Defaults to Path.cwd().
+
+    Returns:
+        Path to project root if found, None otherwise.
+    """
+    if cwd is None:
+        cwd = Path.cwd()
+
+    current = cwd.resolve()
+    # Traverse up
+    for parent in [current] + list(current.parents):
+        project_file = parent / ".gobby" / "project.json"
+        if project_file.exists():
+            return parent
+    return None
+
+
+def get_project_context(cwd: Path | None = None) -> dict[str, Any] | None:
+    """
+    Get project context from .gobby/project.json.
+
+    Args:
+        cwd: Current working directory to start search from.
+
+    Returns:
+        Dictionary containing project data (id, name, verification, etc.) and 'project_path',
+        or None if not found.
+
+        The returned dict may include:
+        - id: Project ID
+        - name: Project name
+        - created_at: Creation timestamp
+        - project_path: Path to project root
+        - verification: Optional dict with unit_tests, type_check, lint, integration, custom
+    """
+    root = find_project_root(cwd)
+    if not root:
+        return None
+
+    project_file = root / ".gobby" / "project.json"
+    try:
+        with open(project_file) as f:
+            data = json.load(f)
+        data["project_path"] = str(root)
+        return cast(dict[str, Any], data)
+    except Exception as e:
+        logger.warning(f"Failed to read project context: {e}")
+        return None
+
+
+def get_workflow_project_path(cwd: Path | None = None) -> Path | None:
+    """
+    Get the project path for workflow lookup.
+
+    In a worktree, returns parent_project_path (where workflows live).
+    In a main project, returns the project_path.
+
+    This allows worktree agents to discover workflows from the parent project
+    without needing to explicitly pass the project_path parameter.
+
+    Args:
+        cwd: Current working directory to start search from.
+
+    Returns:
+        Path to use for workflow discovery, or None if no project found.
+    """
+    ctx = get_project_context(cwd)
+    if not ctx:
+        return None
+
+    # If in a worktree, use parent project for workflows
+    parent = ctx.get("parent_project_path")
+    if parent:
+        return Path(parent)
+
+    # Otherwise use current project path
+    project_path = ctx.get("project_path")
+    return Path(project_path) if project_path else None
+
+
+def get_project_mcp_dir(project_name: str) -> Path:
+    """
+    Get the directory for project-specific MCP configuration.
+
+    Args:
+        project_name: Name of the project.
+
+    Returns:
+        Path to the project's MCP directory in ~/.gobby/projects/.
+    """
+    project_name_safe = project_name.replace(" ", "_").lower()
+    return Path.home() / ".gobby" / "projects" / project_name_safe
+
+
+def get_project_mcp_config_path(project_name: str) -> Path:
+    """
+    Get the path to the project-specific .mcp.json file.
+
+    Args:
+        project_name: Name of the project.
+
+    Returns:
+        Path to .mcp.json.
+    """
+    return get_project_mcp_dir(project_name) / ".mcp.json"
+
+
+def get_verification_config(cwd: Path | None = None) -> ProjectVerificationConfig | None:
+    """
+    Get project verification configuration from .gobby/project.json.
+
+    Args:
+        cwd: Current working directory to start search from.
+
+    Returns:
+        ProjectVerificationConfig if verification section exists, None otherwise.
+    """
+    from gobby.config.app import ProjectVerificationConfig
+
+    context = get_project_context(cwd)
+    if not context:
+        return None
+
+    verification_data = context.get("verification")
+    if not verification_data:
+        return None
+
+    try:
+        return ProjectVerificationConfig(**verification_data)
+    except Exception as e:
+        logger.warning(f"Failed to parse verification config: {e}")
+        return None
+
+
+def get_hooks_config(cwd: Path | None = None) -> HooksConfig | None:
+    """
+    Get git hooks configuration from .gobby/project.json.
+
+    Args:
+        cwd: Current working directory to start search from.
+
+    Returns:
+        HooksConfig if hooks section exists, None otherwise.
+    """
+    from gobby.config.features import HooksConfig
+
+    context = get_project_context(cwd)
+    if not context:
+        return None
+
+    hooks_data = context.get("hooks")
+    if not hooks_data:
+        return None
+
+    try:
+        return HooksConfig(**hooks_data)
+    except Exception as e:
+        logger.warning(f"Failed to parse hooks config: {e}")
+        return None

gobby/utils/project_init.py

@@ -0,0 +1,263 @@
+"""
+Shared project initialization utilities.
+
+This module provides the core logic for initializing a Gobby project,
+used by both the CLI and the hook system for auto-initialization.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class VerificationCommands:
+    """Auto-detected verification commands for a project."""
+
+    unit_tests: str | None = None
+    type_check: str | None = None
+    lint: str | None = None
+    integration: str | None = None
+    custom: dict[str, str] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary, excluding None values."""
+        result: dict[str, Any] = {}
+        if self.unit_tests:
+            result["unit_tests"] = self.unit_tests
+        if self.type_check:
+            result["type_check"] = self.type_check
+        if self.lint:
+            result["lint"] = self.lint
+        if self.integration:
+            result["integration"] = self.integration
+        if self.custom:
+            result["custom"] = self.custom
+        return result
+
+
+@dataclass
+class InitResult:
+    """Result of project initialization."""
+
+    project_id: str
+    project_name: str
+    project_path: str
+    created_at: str
+    already_existed: bool
+    verification: VerificationCommands | None = None
+
+
+def detect_verification_commands(cwd: Path) -> VerificationCommands:
+    """
+    Auto-detect verification commands based on project files.
+
+    Checks for pyproject.toml (Python) or package.json (Node.js) and suggests
+    appropriate commands for testing, type checking, and linting.
+
+    Args:
+        cwd: Project root directory.
+
+    Returns:
+        VerificationCommands with detected commands.
+    """
+    verification = VerificationCommands()
+
+    # Check for Python project (pyproject.toml)
+    pyproject_path = cwd / "pyproject.toml"
+    if pyproject_path.exists():
+        logger.debug("Detected Python project (pyproject.toml)")
+
+        # Check for tests directory
+        tests_dir = cwd / "tests"
+        if tests_dir.exists() and tests_dir.is_dir():
+            verification.unit_tests = "uv run pytest tests/ -v"
+
+        # Check for src directory (common pattern)
+        src_dir = cwd / "src"
+        if src_dir.exists() and src_dir.is_dir():
+            verification.type_check = "uv run mypy src/"
+            verification.lint = "uv run ruff check src/"
+        else:
+            # Fall back to current directory
+            verification.type_check = "uv run mypy ."
+            verification.lint = "uv run ruff check ."
+
+        return verification
+
+    # Check for Node.js project (package.json)
+    package_json_path = cwd / "package.json"
+    if package_json_path.exists():
+        logger.debug("Detected Node.js project (package.json)")
+
+        try:
+            with open(package_json_path) as f:
+                package_data = json.load(f)
+
+            scripts = package_data.get("scripts", {})
+
+            # Check for test script
+            if "test" in scripts:
+                verification.unit_tests = "npm test"
+
+            # Check for lint script
+            if "lint" in scripts:
+                verification.lint = "npm run lint"
+
+            # Check for type-check script (common names)
+            for script_name in ["type-check", "typecheck", "types", "tsc"]:
+                if script_name in scripts:
+                    verification.type_check = f"npm run {script_name}"
+                    break
+
+        except (json.JSONDecodeError, OSError) as e:
+            logger.warning(f"Failed to parse package.json: {e}")
+
+        return verification
+
+    logger.debug("No recognized project type detected")
+    return verification
+
+
+def initialize_project(
+    cwd: Path | None = None,
+    name: str | None = None,
+    github_url: str | None = None,
+) -> InitResult:
+    """
+    Initialize a Gobby project in the given directory.
+
+    If the project is already initialized (has .gobby/project.json),
+    returns the existing project info. Otherwise creates a new project
+    in the database and writes the local project.json file.
+
+    Args:
+        cwd: Directory to initialize. Defaults to current working directory.
+        name: Project name. Defaults to directory name if not provided.
+        github_url: GitHub URL. Auto-detected from git remote if not provided.
+
+    Returns:
+        InitResult with project details and whether it already existed.
+
+    Raises:
+        Exception: If project creation fails.
+    """
+    from gobby.storage.database import LocalDatabase
+    from gobby.storage.migrations import run_migrations
+    from gobby.storage.projects import LocalProjectManager
+    from gobby.utils.git import get_github_url as detect_github_url
+    from gobby.utils.project_context import get_project_context
+
+    if cwd is None:
+        cwd = Path.cwd()
+
+    cwd = cwd.resolve()
+
+    # Check if already initialized
+    project_context = get_project_context(cwd)
+    if project_context and project_context.get("id"):
+        logger.debug(f"Project already initialized: {project_context.get('name')}")
+        return InitResult(
+            project_id=str(project_context["id"]),
+            project_name=project_context.get("name", ""),
+            project_path=project_context.get("project_path", str(cwd)),
+            created_at=project_context.get("created_at", ""),
+            already_existed=True,
+        )
+
+    # Auto-detect name from directory if not provided
+    if not name:
+        name = cwd.name
+
+    # Auto-detect GitHub URL from git remote if not provided
+    if not github_url:
+        github_url = detect_github_url(cwd)
+
+    # Initialize database and run migrations
+    db = LocalDatabase()
+    run_migrations(db)
+    project_manager = LocalProjectManager(db)
+
+    # Auto-detect verification commands
+    verification = detect_verification_commands(cwd)
+
+    # Check if project with same name exists in database
+    existing = project_manager.get_by_name(name)
+    if existing:
+        # Project exists in DB but no local project.json - write it
+        logger.debug(f"Found existing project in database: {name}")
+        _write_project_json(cwd, existing.id, existing.name, existing.created_at, verification)
+        return InitResult(
+            project_id=existing.id,
+            project_name=existing.name,
+            project_path=str(cwd),
+            created_at=existing.created_at,
+            already_existed=True,
+            verification=verification if verification.to_dict() else None,
+        )
+
+    # Create new project
+    logger.debug(f"Creating new project: {name}")
+    project = project_manager.create(
+        name=name,
+        repo_path=str(cwd),
+        github_url=github_url,
+    )
+
+    # Write local .gobby/project.json
+    _write_project_json(cwd, project.id, project.name, project.created_at, verification)
+
+    logger.info(f"Initialized project '{name}' in {cwd}")
+
+    return InitResult(
+        project_id=project.id,
+        project_name=project.name,
+        project_path=str(cwd),
+        created_at=project.created_at,
+        already_existed=False,
+        verification=verification if verification.to_dict() else None,
+    )
+
+
+def _write_project_json(
+    cwd: Path,
+    project_id: str,
+    name: str,
+    created_at: str,
+    verification: VerificationCommands | None = None,
+) -> None:
+    """Write the .gobby/project.json file.
+
+    Args:
+        cwd: Project root directory.
+        project_id: Project ID.
+        name: Project name.
+        created_at: Project creation timestamp.
+        verification: Optional verification commands to include.
+    """
+    gobby_dir = cwd / ".gobby"
+    gobby_dir.mkdir(exist_ok=True)
+
+    project_file = gobby_dir / "project.json"
+    project_data: dict[str, Any] = {
+        "id": project_id,
+        "name": name,
+        "created_at": created_at,
+    }
+
+    # Add verification config if provided and has commands
+    if verification:
+        verification_dict = verification.to_dict()
+        if verification_dict:
+            project_data["verification"] = verification_dict
+
+    with open(project_file, "w") as f:
+        json.dump(project_data, f, indent=2)
+
+    logger.debug(f"Wrote project.json to {project_file}")

gobby/utils/status.py

@@ -0,0 +1,256 @@
+"""
+Status message formatting for Gobby daemon.
+
+Provides consistent status display across CLI and MCP server.
+"""
+
+import logging
+from typing import Any
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+def fetch_rich_status(http_port: int, timeout: float = 2.0) -> dict[str, Any]:
+    """
+    Fetch rich status data from the daemon API.
+
+    Args:
+        http_port: HTTP port of the daemon
+        timeout: Request timeout in seconds
+
+    Returns:
+        Dict of status kwargs to pass to format_status_message
+    """
+    status_kwargs: dict[str, Any] = {}
+
+    try:
+        response = httpx.get(f"http://localhost:{http_port}/admin/status", timeout=timeout)
+        if response.status_code != 200:
+            return status_kwargs
+
+        data = response.json()
+
+        # Process metrics
+        process_data = data.get("process")
+        if process_data:
+            status_kwargs["memory_mb"] = process_data.get("memory_rss_mb")
+            status_kwargs["cpu_percent"] = process_data.get("cpu_percent")
+
+        # MCP servers
+        mcp_servers = data.get("mcp_servers", {})
+        if mcp_servers:
+            total = len(mcp_servers)
+            connected = sum(1 for s in mcp_servers.values() if s.get("connected"))
+            status_kwargs["mcp_total"] = total
+            status_kwargs["mcp_connected"] = connected
+            status_kwargs["mcp_tools_cached"] = data.get("mcp_tools_cached", 0)
+
+            # Find unhealthy servers
+            unhealthy = []
+            for name, info in mcp_servers.items():
+                health = info.get("health")
+                if health and health not in ("healthy", None):
+                    unhealthy.append((name, health))
+                elif info.get("consecutive_failures", 0) > 0:
+                    unhealthy.append((name, f"{info['consecutive_failures']} failures"))
+            if unhealthy:
+                status_kwargs["mcp_unhealthy"] = unhealthy
+
+        # Sessions
+        sessions = data.get("sessions", {})
+        if sessions:
+            status_kwargs["sessions_active"] = sessions.get("active", 0)
+            status_kwargs["sessions_paused"] = sessions.get("paused", 0)
+            status_kwargs["sessions_handoff_ready"] = sessions.get("handoff_ready", 0)
+
+        # Tasks
+        tasks = data.get("tasks", {})
+        if tasks:
+            status_kwargs["tasks_open"] = tasks.get("open", 0)
+            status_kwargs["tasks_in_progress"] = tasks.get("in_progress", 0)
+            status_kwargs["tasks_ready"] = tasks.get("ready", 0)
+            status_kwargs["tasks_blocked"] = tasks.get("blocked", 0)
+
+        # Memory
+        memory = data.get("memory", {})
+        if memory and memory.get("count", 0) > 0:
+            status_kwargs["memories_count"] = memory.get("count", 0)
+            status_kwargs["memories_avg_importance"] = memory.get("avg_importance", 0.0)
+
+    except (httpx.ConnectError, httpx.TimeoutException):
+        # Daemon not responding - return empty
+        pass
+    except Exception as e:
+        logger.debug(f"Failed to fetch daemon status: {e}")
+
+    return status_kwargs
+
+
+def format_status_message(
+    *,
+    running: bool,
+    pid: int | None = None,
+    pid_file: str | None = None,
+    log_files: str | None = None,
+    uptime: str | None = None,
+    http_port: int | None = None,
+    websocket_port: int | None = None,
+    # Process metrics
+    memory_mb: float | None = None,
+    cpu_percent: float | None = None,
+    # MCP proxy info
+    mcp_connected: int | None = None,
+    mcp_total: int | None = None,
+    mcp_tools_cached: int | None = None,
+    mcp_unhealthy: list[tuple[str, str]] | None = None,
+    # Sessions info
+    sessions_active: int | None = None,
+    sessions_paused: int | None = None,
+    sessions_handoff_ready: int | None = None,
+    # Tasks info
+    tasks_open: int | None = None,
+    tasks_in_progress: int | None = None,
+    tasks_ready: int | None = None,
+    tasks_blocked: int | None = None,
+    # Memory
+    memories_count: int | None = None,
+    memories_avg_importance: float | None = None,
+    **kwargs: Any,
+) -> str:
+    """
+    Format Gobby daemon status message with consistent styling.
+
+    Args:
+        running: Whether the daemon is running
+        pid: Process ID
+        pid_file: Path to PID file
+        log_files: Path to log files directory
+        uptime: Formatted uptime string (e.g., "1h 23m 45s")
+        http_port: HTTP server port
+        websocket_port: WebSocket server port
+        memory_mb: Memory usage in MB
+        cpu_percent: CPU usage percentage
+        mcp_connected: Number of connected MCP servers
+        mcp_total: Total number of configured MCP servers
+        mcp_tools_cached: Number of cached tools
+        mcp_unhealthy: List of (server_name, status) for unhealthy servers
+        sessions_active: Number of active sessions
+        sessions_paused: Number of paused sessions
+        sessions_handoff_ready: Number of sessions ready for handoff
+        tasks_open: Number of open tasks
+        tasks_in_progress: Number of in-progress tasks
+        tasks_ready: Number of ready tasks
+        tasks_blocked: Number of blocked tasks
+        memories_count: Total number of memories
+        memories_avg_importance: Average memory importance
+
+
+    Returns:
+        Formatted status message string
+    """
+    lines = []
+
+    # Header
+    lines.append("=" * 70)
+    lines.append("GOBBY DAEMON STATUS")
+    lines.append("=" * 70)
+    lines.append("")
+
+    # Status section
+    if running:
+        status_line = "Status: Running"
+        if pid:
+            status_line += f" (PID: {pid})"
+        lines.append(status_line)
+
+        # Uptime and process metrics on same conceptual level
+        metrics_parts = []
+        if uptime:
+            metrics_parts.append(f"Uptime: {uptime}")
+        if memory_mb is not None:
+            metrics_parts.append(f"Memory: {memory_mb:.1f} MB")
+        if cpu_percent is not None:
+            metrics_parts.append(f"CPU: {cpu_percent:.1f}%")
+
+        if metrics_parts:
+            lines.append(f"  {' | '.join(metrics_parts)}")
+    else:
+        lines.append("Status: Stopped")
+
+    lines.append("")
+
+    # Server Configuration section
+    if http_port or websocket_port:
+        lines.append("Server Configuration:")
+        if http_port:
+            lines.append(f"  HTTP: localhost:{http_port}")
+        if websocket_port:
+            lines.append(f"  WebSocket: localhost:{websocket_port}")
+        lines.append("")
+
+    # MCP Proxy section (only show if we have data)
+    if mcp_total is not None:
+        lines.append("MCP Proxy:")
+        connected = mcp_connected if mcp_connected is not None else 0
+        lines.append(f"  Servers: {connected} connected / {mcp_total} total")
+        if mcp_tools_cached is not None:
+            lines.append(f"  Tools cached: {mcp_tools_cached}")
+        if mcp_unhealthy:
+            unhealthy_str = ", ".join(f"{name} ({status})" for name, status in mcp_unhealthy)
+            lines.append(f"  Unhealthy: {unhealthy_str}")
+        lines.append("")
+
+    # Sessions section (only show if we have data)
+    if sessions_active is not None or sessions_paused is not None:
+        lines.append("Sessions:")
+        parts = []
+        if sessions_active is not None:
+            parts.append(f"Active: {sessions_active}")
+        if sessions_paused is not None:
+            parts.append(f"Paused: {sessions_paused}")
+        if sessions_handoff_ready is not None:
+            parts.append(f"Handoff Ready: {sessions_handoff_ready}")
+        if parts:
+            lines.append(f"  {' | '.join(parts)}")
+        lines.append("")
+
+    # Tasks section (only show if we have data)
+    if tasks_open is not None or tasks_in_progress is not None:
+        lines.append("Tasks:")
+        parts = []
+        if tasks_open is not None:
+            parts.append(f"Open: {tasks_open}")
+        if tasks_in_progress is not None:
+            parts.append(f"In Progress: {tasks_in_progress}")
+        if tasks_ready is not None:
+            parts.append(f"Ready: {tasks_ready}")
+        if tasks_blocked is not None:
+            parts.append(f"Blocked: {tasks_blocked}")
+        if parts:
+            lines.append(f"  {' | '.join(parts)}")
+        lines.append("")
+
+    # Memory section (only show if we have data)
+    if memories_count is not None:
+        lines.append("Memory:")
+        mem_str = f"Memories: {memories_count}"
+        if memories_avg_importance is not None:
+            mem_str += f" (avg importance: {memories_avg_importance:.2f})"
+        lines.append(f"  {mem_str}")
+        lines.append("")
+
+    # Paths section (only when running)
+    if running and (pid_file or log_files):
+        lines.append("Paths:")
+        if pid_file:
+            lines.append(f"  PID file: {pid_file}")
+        if log_files:
+            lines.append(f"  Logs: {log_files}")
+        lines.append("")
+
+    # Footer
+    lines.append("=" * 70)
+
+    return "\n".join(lines)