gobby 0.2.5__py3-none-any.whl

gobby/cli/tasks/deps.py

@@ -0,0 +1,135 @@
+"""
+Dependency management commands for tasks.
+"""
+
+from typing import Literal
+
+import click
+
+from gobby.cli.tasks._utils import get_task_manager, resolve_task_id
+
+
+@click.group("dep")
+def dep_cmd() -> None:
+    """Manage task dependencies."""
+    pass
+
+
+DependencyType = Literal["blocks", "related", "discovered-from"]
+
+
+@dep_cmd.command("add")
+@click.argument("task_id", metavar="TASK")
+@click.argument("blocker_id", metavar="BLOCKER")
+@click.option(
+    "--type",
+    "-t",
+    "dep_type",
+    default="blocks",
+    help="Dependency type (blocks, related, discovered-from)",
+)
+def dep_add(task_id: str, blocker_id: str, dep_type: DependencyType) -> None:
+    """Add a dependency: BLOCKER blocks TASK.
+
+    TASK/BLOCKER can be: #N (e.g., #1, #47), path (e.g., 1.2.3), or UUID.
+
+    Example: gobby tasks dep add #3 #1
+    means #1 blocks #3 (task #3 depends on task #1)
+    """
+    from gobby.storage.task_dependencies import TaskDependencyManager
+
+    manager = get_task_manager()
+    resolved = resolve_task_id(manager, task_id)
+    if not resolved:
+        return
+
+    blocker = resolve_task_id(manager, blocker_id)
+    if not blocker:
+        return
+
+    dep_manager = TaskDependencyManager(manager.db)
+    try:
+        dep_manager.add_dependency(resolved.id, blocker.id, dep_type)
+        click.echo(f"Added dependency: {blocker.id[:8]} {dep_type} {resolved.id[:8]}")
+    except ValueError as e:
+        click.echo(f"Error: {e}", err=True)
+
+
+@dep_cmd.command("remove")
+@click.argument("task_id", metavar="TASK")
+@click.argument("blocker_id", metavar="BLOCKER")
+def dep_remove(task_id: str, blocker_id: str) -> None:
+    """Remove a dependency between tasks.
+
+    TASK/BLOCKER can be: #N (e.g., #1, #47), path (e.g., 1.2.3), or UUID.
+    """
+    from gobby.storage.task_dependencies import TaskDependencyManager
+
+    manager = get_task_manager()
+    resolved = resolve_task_id(manager, task_id)
+    if not resolved:
+        return
+
+    blocker = resolve_task_id(manager, blocker_id)
+    if not blocker:
+        return
+
+    dep_manager = TaskDependencyManager(manager.db)
+    dep_manager.remove_dependency(resolved.id, blocker.id)
+    click.echo(f"Removed dependency between {resolved.id[:8]} and {blocker.id[:8]}")
+
+
+@dep_cmd.command("tree")
+@click.argument("task_id", metavar="TASK")
+def dep_tree(task_id: str) -> None:
+    """Show dependency tree for a task.
+
+    TASK can be: #N (e.g., #1, #47), path (e.g., 1.2.3), or UUID.
+    """
+    from gobby.storage.task_dependencies import TaskDependencyManager
+
+    manager = get_task_manager()
+    resolved = resolve_task_id(manager, task_id)
+    if not resolved:
+        return
+
+    dep_manager = TaskDependencyManager(manager.db)
+    tree = dep_manager.get_dependency_tree(resolved.id)
+
+    click.echo(f"Dependency tree for {resolved.id[:8]} ({resolved.title}):")
+    click.echo("")
+
+    # Show blockers (what this task depends on)
+    if tree.get("blockers"):
+        click.echo("Blocked by:")
+        for b in tree["blockers"]:
+            status_icon = "✓" if b.get("status") == "closed" else "○"
+            click.echo(f"  {status_icon} {b['id'][:8]}: {b.get('title', 'Unknown')}")
+    else:
+        click.echo("Blocked by: (none)")
+
+    # Show blocking (what depends on this task)
+    if tree.get("blocking"):
+        click.echo("\nBlocking:")
+        for b in tree["blocking"]:
+            status_icon = "✓" if b.get("status") == "closed" else "○"
+            click.echo(f"  {status_icon} {b['id'][:8]}: {b.get('title', 'Unknown')}")
+    else:
+        click.echo("\nBlocking: (none)")
+
+
+@dep_cmd.command("cycles")
+def dep_cycles() -> None:
+    """Check for dependency cycles."""
+    from gobby.storage.task_dependencies import TaskDependencyManager
+
+    manager = get_task_manager()
+    dep_manager = TaskDependencyManager(manager.db)
+    cycles = dep_manager.check_cycles()
+
+    if cycles:
+        click.echo(f"Found {len(cycles)} dependency cycles:", err=True)
+        for cycle in cycles:
+            click.echo(f"  {' -> '.join(c[:8] for c in cycle)}", err=True)
+    else:
+        click.echo("✓ No dependency cycles found")

gobby/cli/tasks/labels.py

@@ -0,0 +1,63 @@
+"""
+Label management commands for tasks.
+"""
+
+import click
+
+from gobby.cli.tasks._utils import get_task_manager, resolve_task_id
+
+
+@click.group("label")
+def label_cmd() -> None:
+    """Manage task labels."""
+    pass
+
+
+@label_cmd.command("add")
+@click.argument("task_id", metavar="TASK")
+@click.argument("label")
+def add_label(task_id: str, label: str) -> None:
+    """Add a label to a task.
+
+    TASK can be: #N (e.g., #1, #47), path (e.g., 1.2.3), or UUID.
+    """
+    manager = get_task_manager()
+    resolved = resolve_task_id(manager, task_id)
+    if not resolved:
+        click.secho(f"Error: Could not resolve task '{task_id}'", fg="red", err=True)
+        raise SystemExit(1)
+
+    try:
+        manager.add_label(resolved.id, label)
+    except ValueError as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        raise SystemExit(1) from None
+    except Exception as e:
+        click.secho(f"Unexpected error adding label: {e}", fg="red", err=True)
+        raise SystemExit(1) from None
+    click.echo(f"Added label '{label}' to task {resolved.id}")
+
+
+@label_cmd.command("remove")
+@click.argument("task_id", metavar="TASK")
+@click.argument("label")
+def remove_label(task_id: str, label: str) -> None:
+    """Remove a label from a task.
+
+    TASK can be: #N (e.g., #1, #47), path (e.g., 1.2.3), or UUID.
+    """
+    manager = get_task_manager()
+    resolved = resolve_task_id(manager, task_id)
+    if not resolved:
+        click.secho(f"Error: Could not resolve task '{task_id}'", fg="red", err=True)
+        raise SystemExit(1)
+
+    try:
+        manager.remove_label(resolved.id, label)
+    except ValueError as e:
+        click.secho(f"Error: {e}", fg="red", err=True)
+        raise SystemExit(1) from None
+    except Exception as e:
+        click.secho(f"Unexpected error removing label: {e}", fg="red", err=True)
+        raise SystemExit(1) from None
+    click.echo(f"Removed label '{label}' from task {resolved.id}")

gobby/cli/tasks/main.py

@@ -0,0 +1,273 @@
+"""
+Task management commands - entry point and misc utilities.
+"""
+
+import logging
+from typing import Any
+
+import click
+
+from gobby.cli.tasks._utils import (
+    check_tasks_enabled,
+    get_sync_manager,
+    get_task_manager,
+)
+from gobby.cli.tasks.ai import (
+    complexity_cmd,
+    expand_all_cmd,
+    expand_task_cmd,
+    generate_criteria_cmd,
+    suggest_cmd,
+    validate_task_cmd,
+)
+from gobby.cli.tasks.commits import commit_cmd, diff_cmd
+from gobby.cli.tasks.crud import (
+    blocked_tasks,
+    close_task_cmd,
+    create_task,
+    de_escalate_cmd,
+    delete_task,
+    list_tasks,
+    ready_tasks,
+    reopen_task_cmd,
+    show_task,
+    task_stats,
+    update_task,
+    validation_history_cmd,
+)
+from gobby.cli.tasks.deps import dep_cmd
+from gobby.cli.tasks.labels import label_cmd
+from gobby.cli.tasks.search import reindex_tasks, search_tasks
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def tasks() -> None:
+    """Manage development tasks."""
+    check_tasks_enabled()
+
+
+# Register CRUD commands from extracted module
+tasks.add_command(list_tasks)
+tasks.add_command(ready_tasks)
+tasks.add_command(blocked_tasks)
+tasks.add_command(task_stats)
+tasks.add_command(create_task)
+tasks.add_command(show_task)
+tasks.add_command(update_task)
+tasks.add_command(close_task_cmd)
+tasks.add_command(reopen_task_cmd)
+tasks.add_command(delete_task)
+tasks.add_command(de_escalate_cmd)
+tasks.add_command(validation_history_cmd)
+
+# Register AI-powered commands from extracted module
+tasks.add_command(validate_task_cmd)
+tasks.add_command(generate_criteria_cmd)
+tasks.add_command(expand_task_cmd)
+tasks.add_command(complexity_cmd)
+tasks.add_command(expand_all_cmd)
+tasks.add_command(suggest_cmd)
+
+# Register search commands
+tasks.add_command(search_tasks)
+tasks.add_command(reindex_tasks)
+
+
+@tasks.command("sync")
+@click.option("--import", "do_import", is_flag=True, help="Import tasks from JSONL")
+@click.option("--export", "do_export", is_flag=True, help="Export tasks to JSONL")
+@click.option("--quiet", "-q", is_flag=True, help="Suppress output")
+def sync_tasks(do_import: bool, do_export: bool, quiet: bool) -> None:
+    """Sync tasks with .gobby/tasks.jsonl.
+
+    If neither --import nor --export specified, does both.
+    """
+    manager = get_sync_manager()
+
+    # Default to both if neither specified
+    if not do_import and not do_export:
+        do_import = True
+        do_export = True
+
+    if do_import:
+        if not quiet:
+            click.echo("Importing tasks...")
+        manager.import_from_jsonl()
+
+    if do_export:
+        if not quiet:
+            click.echo("Exporting tasks...")
+        manager.export_to_jsonl()
+
+    if not quiet:
+        click.echo("Sync completed")
+
+
+@tasks.group("compact")
+def compact_cmd() -> None:
+    """Task compaction commands."""
+    pass
+
+
+@compact_cmd.command("analyze")
+@click.option("--days", type=int, default=30, help="Days blocked threshold")
+def compact_analyze(days: int) -> None:
+    """Find tasks eligible for compaction."""
+    manager = get_task_manager()
+    from gobby.storage.compaction import TaskCompactor
+
+    compactor = TaskCompactor(manager)
+    candidates = compactor.find_candidates(days_closed=days)
+
+    if not candidates:
+        click.echo("No compaction candidates found.")
+        return
+
+    click.echo(f"Found {len(candidates)} candidates closed > {days} days:")
+    for task in candidates:
+        click.echo(f"  {task['id']}: {task['title']} (Updated: {task['updated_at']})")
+
+
+@compact_cmd.command("apply")
+@click.option("--id", "task_id", required=True, help="Task ID to compact")
+@click.option("--summary", required=True, help="Summary text or file path (@path)")
+def compact_apply(task_id: str, summary: str) -> None:
+    """Compact a task with a summary."""
+    manager = get_task_manager()
+    from gobby.storage.compaction import TaskCompactor
+
+    # Handle file input for summary
+    if summary.startswith("@"):
+        path = summary[1:]
+        try:
+            with open(path) as f:
+                summary_content = f.read()
+        except Exception as e:
+            click.echo(f"Error reading summary file: {e}", err=True)
+            return
+    else:
+        summary_content = summary
+
+    compactor = TaskCompactor(manager)
+    try:
+        compactor.compact_task(task_id, summary_content)
+        click.echo(f"Compacted task {task_id}.")
+    except Exception as e:
+        click.echo(f"Error compacting task: {e}", err=True)
+
+
+@compact_cmd.command("stats")
+def compact_stats() -> None:
+    """Show compaction statistics."""
+    manager = get_task_manager()
+    from gobby.storage.compaction import TaskCompactor
+
+    compactor = TaskCompactor(manager)
+    stats = compactor.get_stats()
+
+    click.echo("Compaction Statistics:")
+    click.echo(f"  Total Closed: {stats['total_closed']}")
+    click.echo(f"  Compacted:    {stats['compacted']}")
+    click.echo(f"  Rate:         {stats['rate']}%")
+
+
+# Register subgroups from extracted modules
+tasks.add_command(dep_cmd)
+tasks.add_command(label_cmd)
+tasks.add_command(commit_cmd)
+tasks.add_command(diff_cmd)
+
+
+@tasks.group("import")
+def import_cmd() -> None:
+    """Import tasks from external sources."""
+    pass
+
+
+@import_cmd.command("github")
+@click.argument("url")
+@click.option("--limit", default=50, help="Max issues to import")
+def import_github(url: str, limit: int) -> None:
+    """Import open issues from GitHub."""
+    import asyncio
+
+    manager = get_sync_manager()
+
+    # We need to run async method
+    async def run() -> dict[str, Any]:
+        result: dict[str, Any] = await manager.import_from_github_issues(url, limit=limit)
+        return result
+
+    try:
+        result = asyncio.run(run())
+
+        if result["success"]:
+            click.echo(result["message"])
+            for issue_id in result["imported"]:
+                click.echo(f"  Imported {issue_id}")
+        else:
+            click.echo(f"Error: {result['error']}", err=True)
+    except Exception as e:
+        click.echo(f"Failed to run import: {e}", err=True)
+
+
+@tasks.command("doctor")
+def doctor_cmd() -> None:
+    """Validate task data integrity."""
+    manager = get_task_manager()
+    from gobby.utils.validation import TaskValidator
+
+    validator = TaskValidator(manager)
+    results = validator.validate_all()
+
+    issues_found = False
+
+    orphans = results["orphan_dependencies"]
+    if orphans:
+        issues_found = True
+        click.echo(f"Found {len(orphans)} orphan dependencies:", err=True)
+        for d in orphans:
+            click.echo(f"  Dependency {d['id']}: {d['task_id']} -> {d['depends_on']}", err=True)
+    else:
+        click.echo("✓ No orphan dependencies")
+
+    invalid_projects = results["invalid_projects"]
+    if invalid_projects:
+        issues_found = True
+        click.echo(f"Found {len(invalid_projects)} tasks with invalid projects:", err=True)
+        for t in invalid_projects:
+            click.echo(f"  Task {t['id']}: {t['title']} (Project ID: {t['project_id']})", err=True)
+    else:
+        click.echo("✓ No invalid projects")
+
+    cycles = results["cycles"]
+    if cycles:
+        issues_found = True
+        click.echo(f"Found {len(cycles)} dependency cycles:", err=True)
+        for cycle in cycles:
+            click.echo(f"  Cycle: {' -> '.join(cycle)}", err=True)
+    else:
+        click.echo("✓ No dependency cycles")
+
+    if issues_found:
+        click.echo("\nIssues found. Run 'gobby tasks clean' to fix fixable issues.")
+        # Exit with error code if issues found
+        # (Click handles exit code but we can explicitly exit if needed, usually just return is fine unless we want non-zero)
+
+
+@tasks.command("clean")
+@click.confirmation_option(prompt="This will remove orphaned dependencies. Are you sure?")
+def clean_cmd() -> None:
+    """Fix data integrity issues (remove orphans)."""
+    manager = get_task_manager()
+    from gobby.utils.validation import TaskValidator
+
+    validator = TaskValidator(manager)
+    count = validator.clean_orphans()
+
+    if count > 0:
+        click.echo(f"Removed {count} orphan dependencies.")
+    else:
+        click.echo("No orphan dependencies found.")

gobby/cli/tasks/search.py

@@ -0,0 +1,178 @@
+"""
+Search commands for task management.
+"""
+
+import json
+
+import click
+
+from gobby.cli.tasks._utils import (
+    get_task_manager,
+    normalize_status,
+)
+from gobby.cli.utils import resolve_project_ref
+
+
+@click.command("search")
+@click.argument("query")
+@click.option(
+    "--status",
+    "-s",
+    help="Filter by status (open, in_progress, review, closed). Comma-separated for multiple.",
+)
+@click.option(
+    "--type",
+    "-t",
+    "task_type",
+    help="Filter by task type (task, bug, feature, epic)",
+)
+@click.option(
+    "--priority",
+    "-p",
+    type=int,
+    help="Filter by priority (1=High, 2=Medium, 3=Low)",
+)
+@click.option(
+    "--project",
+    "project_ref",
+    help="Filter by project (name or UUID). Default: current project.",
+)
+@click.option(
+    "--all-projects",
+    "-a",
+    is_flag=True,
+    help="Search all projects instead of just the current project",
+)
+@click.option(
+    "--limit",
+    "-n",
+    default=20,
+    help="Maximum number of results (default: 20)",
+)
+@click.option(
+    "--min-score",
+    type=float,
+    default=0.0,
+    help="Minimum similarity score threshold (0.0-1.0)",
+)
+@click.option(
+    "--json",
+    "json_format",
+    is_flag=True,
+    help="Output as JSON",
+)
+def search_tasks(
+    query: str,
+    status: str | None,
+    task_type: str | None,
+    priority: int | None,
+    project_ref: str | None,
+    all_projects: bool,
+    limit: int,
+    min_score: float,
+    json_format: bool,
+) -> None:
+    """Search tasks using semantic TF-IDF search.
+
+    QUERY is the natural language search query.
+
+    Examples:
+
+        gobby tasks search "authentication"
+
+        gobby tasks search "database migration" --status open
+
+        gobby tasks search "refactor" --type bug --limit 10
+    """
+    if not query.strip():
+        click.echo("Error: Query cannot be empty.", err=True)
+        return
+
+    # Parse comma-separated statuses
+    status_filter: str | list[str] | None = None
+    if status:
+        if "," in status:
+            status_filter = [normalize_status(s.strip()) for s in status.split(",")]
+        else:
+            status_filter = normalize_status(status)
+
+    # Resolve project
+    project_id = None
+    if not all_projects:
+        project_id = resolve_project_ref(project_ref)
+
+    manager = get_task_manager()
+
+    # Perform search
+    results = manager.search_tasks(
+        query=query.strip(),
+        project_id=project_id,
+        status=status_filter,
+        task_type=task_type,
+        priority=priority,
+        limit=limit,
+        min_score=min_score,
+    )
+
+    if json_format:
+        output = {
+            "query": query.strip(),
+            "count": len(results),
+            "tasks": [
+                {
+                    **task.to_dict(),
+                    "score": round(score, 4),
+                }
+                for task, score in results
+            ],
+        }
+        click.echo(json.dumps(output, indent=2, default=str))
+        return
+
+    if not results:
+        click.echo(f"No tasks found matching '{query}'.")
+        return
+
+    click.echo(f"Found {len(results)} task(s) matching '{query}':\n")
+
+    # Print header
+    click.echo(f"{'#':<6} {'Score':<7} {'Status':<12} {'Pri':<4} {'Title'}")
+    click.echo("-" * 70)
+
+    for task, score in results:
+        # Format similar to list_tasks but with score
+        seq_ref = f"#{task.seq_num}" if task.seq_num else task.id[:8]
+        status_display = task.status[:11] if task.status else ""
+        pri_display = str(task.priority) if task.priority else ""
+        title_display = task.title[:45] if task.title else ""
+
+        click.echo(
+            f"{seq_ref:<6} {score:<7.3f} {status_display:<12} {pri_display:<4} {title_display}"
+        )
+
+
+@click.command("reindex")
+@click.option(
+    "--all-projects",
+    "-a",
+    is_flag=True,
+    help="Reindex all projects instead of just the current project",
+)
+def reindex_tasks(all_projects: bool) -> None:
+    """Rebuild the task search index.
+
+    Use this after bulk operations or if search results seem stale.
+    """
+    # Resolve project
+    project_id = None
+    if not all_projects:
+        project_id = resolve_project_ref(None)
+
+    manager = get_task_manager()
+
+    click.echo("Rebuilding task search index...")
+    stats = manager.reindex_search(project_id)
+
+    click.echo(f"Search index rebuilt with {stats.get('item_count', 0)} tasks.")
+    if stats.get("vocabulary_size"):
+        click.echo(f"Vocabulary size: {stats['vocabulary_size']}")

gobby/cli/tui.py

@@ -0,0 +1,34 @@
+"""TUI command for launching the Gobby dashboard."""
+
+import click
+
+
+@click.command()
+@click.option(
+    "--port",
+    "-p",
+    default=8765,
+    help="Daemon HTTP port",
+    show_default=True,
+)
+@click.option(
+    "--ws-port",
+    "-w",
+    default=8766,
+    help="Daemon WebSocket port",
+    show_default=True,
+)
+def ui(port: int, ws_port: int) -> None:
+    """Launch the Gobby TUI dashboard.
+
+    The TUI provides a terminal-based interface for monitoring and managing
+    Gobby sessions, tasks, agents, and more.
+
+    Requires the Gobby daemon to be running (gobby start).
+    """
+    from gobby.tui.app import run_tui
+
+    daemon_url = f"http://localhost:{port}"
+    ws_url = f"ws://localhost:{ws_port}"
+
+    run_tui(daemon_url=daemon_url, ws_url=ws_url)