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

gobby/cli/tasks/ai.py

@@ -380,340 +380,6 @@ def _generate_criteria_for_all(manager: LocalTaskManager) -> None:
     )
 
 
-def _find_unexpanded_epic(manager: LocalTaskManager, root_task_id: str) -> Task | None:
-    """Depth-first search for first unexpanded epic in the task tree."""
-    task = manager.get_task(root_task_id)
-    if not task:
-        return None
-
-    # Check if this task itself is an unexpanded epic
-    if task.task_type == "epic" and not task.is_expanded:
-        return task
-
-    # Search children depth-first
-    children = manager.list_tasks(parent_task_id=root_task_id, limit=1000)
-    for child in children:
-        if child.task_type == "epic":
-            result = _find_unexpanded_epic(manager, child.id)
-            if result:
-                return result
-
-    return None
-
-
-def _count_unexpanded_epics(manager: LocalTaskManager, root_task_id: str) -> int:
-    """Count unexpanded epics in the task tree."""
-    count = 0
-    task = manager.get_task(root_task_id)
-    if not task:
-        return 0
-
-    # Count this task if it's an unexpanded epic
-    if task.task_type == "epic" and not task.is_expanded:
-        count += 1
-
-    # Count children recursively
-    children = manager.list_tasks(parent_task_id=root_task_id, limit=1000)
-    for child in children:
-        count += _count_unexpanded_epics(manager, child.id)
-
-    return count
-
-
-@click.command("expand")
-@click.argument("task_refs", nargs=-1, required=True, metavar="TASKS...")
-@click.option("--context", "-c", help="Additional context for expansion")
-@click.option(
-    "--web-research/--no-web-research",
-    default=False,
-    help="Enable/disable agentic web research",
-)
-@click.option(
-    "--code-context/--no-code-context",
-    default=True,
-    help="Enable/disable codebase context gathering",
-)
-@click.option(
-    "--cascade", is_flag=True, help="Iteratively expand all child epics (default for epics)"
-)
-@click.option("--force", "-f", is_flag=True, help="Re-expand already expanded tasks")
-@click.option("--project", "-p", "project_name", help="Project name or ID")
-def expand_task_cmd(
-    task_refs: tuple[str, ...],
-    context: str | None,
-    web_research: bool,
-    code_context: bool,
-    cascade: bool,
-    force: bool,
-    project_name: str | None,
-) -> None:
-    """Expand a task tree. Runs iteratively until complete.
-
-    TASKS can be: #N (e.g., #1, #47), comma-separated (#1,#2,#3), or UUIDs.
-
-    For epics, automatically expands all child epics iteratively (--cascade).
-    Use --no-cascade to expand only the root task.
-
-    Examples:
-        gobby tasks expand #42           # Expands #42 and all child epics
-        gobby tasks expand #42 --force   # Re-expand even if already expanded
-    """
-    import asyncio
-
-    from gobby.cli.tasks._utils import parse_task_refs
-    from gobby.cli.utils import get_active_session_id
-    from gobby.config.app import load_config
-    from gobby.llm import LLMService
-    from gobby.storage.task_dependencies import TaskDependencyManager
-    from gobby.tasks.expansion import TaskExpander
-    from gobby.tasks.tdd import (
-        TDD_CATEGORIES,
-        apply_tdd_sandwich,
-        build_expansion_context,
-        should_skip_expansion,
-        should_skip_tdd,
-    )
-    from gobby.tasks.validation import TaskValidator
-
-    # Parse task references
-    refs = parse_task_refs(task_refs)
-    if not refs:
-        click.echo("Error: No task references provided", err=True)
-        return
-
-    manager = get_task_manager()
-
-    # Resolve all tasks
-    root_tasks: list[Task] = []
-    for ref in refs:
-        task = resolve_task_id(manager, ref)
-        if not task:
-            continue
-        root_tasks.append(task)
-
-    if not root_tasks:
-        click.echo("No valid tasks to expand.", err=True)
-        return
-
-    # Initialize services
-    try:
-        config = load_config()
-        if not config.gobby_tasks.expansion.enabled:
-            click.echo("Error: Task expansion is disabled in config.", err=True)
-            return
-
-        llm_service = LLMService(config)
-        expander = TaskExpander(
-            config.gobby_tasks.expansion, llm_service, manager, mcp_manager=None
-        )
-        dep_manager = TaskDependencyManager(manager.db)
-        validator = TaskValidator(config.gobby_tasks.validation, llm_service)
-        auto_generate_validation = config.gobby_tasks.validation.auto_generate_on_expand
-
-    except Exception as e:
-        click.echo(f"Error initializing services: {e}", err=True)
-        return
-
-    async def _post_expansion_processing(task: Task, subtask_ids: list[str]) -> dict[str, Any]:
-        """Apply MCP-parity post-expansion processing.
-
-        - Wire parent → subtask blocking dependencies
-        - Apply TDD sandwich for code/config subtasks (non-epic only)
-        - Generate validation criteria for subtasks
-        """
-        result: dict[str, Any] = {"tdd_applied": False, "validation_generated": 0}
-
-        if not subtask_ids:
-            return result
-
-        # 1. Wire parent → subtask blocking dependencies
-        for subtask_id in subtask_ids:
-            try:
-                dep_manager.add_dependency(
-                    task_id=task.id, depends_on=subtask_id, dep_type="blocks"
-                )
-            except ValueError:
-                pass  # Dependency already exists
-
-        # 2. Apply TDD sandwich (non-epic tasks with code/config subtasks)
-        if task.task_type != "epic":
-            impl_task_ids = []
-            for sid in subtask_ids:
-                subtask = manager.get_task(sid)
-                if subtask and subtask.category in TDD_CATEGORIES:
-                    if not should_skip_tdd(subtask.title):
-                        impl_task_ids.append(sid)
-
-            if impl_task_ids:
-                tdd_result = await apply_tdd_sandwich(manager, dep_manager, task.id, impl_task_ids)
-                if tdd_result.get("success"):
-                    result["tdd_applied"] = True
-
-        # 3. Generate validation criteria for subtasks
-        if auto_generate_validation:
-            for sid in subtask_ids:
-                subtask = manager.get_task(sid)
-                if subtask and not subtask.validation_criteria and subtask.task_type != "epic":
-                    try:
-                        criteria = await validator.generate_criteria(
-                            title=subtask.title,
-                            description=subtask.description,
-                        )
-                        if criteria:
-                            manager.update_task(sid, validation_criteria=criteria)
-                            result["validation_generated"] += 1
-                    except Exception:
-                        pass  # nosec B110 - best effort validation generation
-
-        # 4. Update parent task: set is_expanded and validation criteria
-        manager.update_task(
-            task.id,
-            is_expanded=True,
-            validation_criteria="All child tasks must be completed (status: closed).",
-        )
-
-        return result
-
-    # Get current session ID for expansion context
-    session_id = get_active_session_id()
-
-    # Process each root task
-    total_iterations = 0
-    total_subtasks = 0
-
-    for root_task in root_tasks:
-        root_ref = f"#{root_task.seq_num}" if root_task.seq_num else root_task.id[:8]
-
-        # For epics, default to cascade mode
-        should_cascade = cascade or root_task.task_type == "epic"
-
-        if should_cascade:
-            # Iterative expansion mode
-            click.echo(f"Expanding {root_ref}: {root_task.title[:50]}...")
-            if web_research:
-                click.echo("  • Web research enabled")
-            if code_context:
-                click.echo("  • Code context enabled")
-
-            iteration = 0
-            while True:
-                iteration += 1
-
-                # Find next unexpanded epic
-                target = _find_unexpanded_epic(manager, root_task.id)
-
-                if target is None:
-                    click.echo(f"✓ Expansion complete after {iteration - 1} iterations")
-                    break
-
-                # Re-fetch to get latest state
-                target = manager.get_task(target.id)
-                if target is None:
-                    click.echo("    Task deleted during expansion", err=True)
-                    break
-
-                # Check if task should be skipped (TDD prefixes or already expanded)
-                skip, reason = should_skip_expansion(target.title, target.is_expanded, force)
-                if skip:
-                    target_ref = f"#{target.seq_num}" if target.seq_num else target.id[:8]
-                    click.echo(f"    Skipping {target_ref}: {reason}")
-                    continue
-
-                target_ref = f"#{target.seq_num}" if target.seq_num else target.id[:8]
-                click.echo(f"[{iteration}] Expanding {target_ref}: {target.title[:40]}...")
-
-                # Build merged context from stored expansion_context + user context
-                merged_context = build_expansion_context(target.expansion_context, context)
-
-                try:
-                    result = asyncio.run(
-                        expander.expand_task(
-                            task_id=target.id,
-                            title=target.title,
-                            description=target.description,
-                            context=merged_context,
-                            enable_web_research=web_research,
-                            enable_code_context=code_context,
-                            session_id=session_id,
-                        )
-                    )
-                except Exception as e:
-                    click.echo(f"    Error: {e}", err=True)
-                    break
-
-                if "error" in result:
-                    click.echo(f"    Error: {result['error']}", err=True)
-                    break
-
-                subtasks = result.get("subtask_ids", [])
-                click.echo(f"    → Created {len(subtasks)} subtasks")
-                total_subtasks += len(subtasks)
-
-                # Apply post-expansion processing (deps, TDD sandwich, validation)
-                post_result = asyncio.run(_post_expansion_processing(target, subtasks))
-                if post_result.get("tdd_applied"):
-                    click.echo("    → Applied TDD sandwich")
-                if post_result.get("validation_generated", 0) > 0:
-                    click.echo(
-                        f"    → Generated {post_result['validation_generated']} validation criteria"
-                    )
-
-                remaining = _count_unexpanded_epics(manager, root_task.id)
-                if remaining > 0:
-                    click.echo(f"    → {remaining} epic(s) remaining")
-
-            total_iterations += iteration - 1
-
-        else:
-            # Single task expansion (non-cascade)
-            skip, reason = should_skip_expansion(root_task.title, root_task.is_expanded, force)
-            if skip:
-                click.echo(f"Skipping {root_ref}: {reason}")
-                continue
-
-            click.echo(f"Expanding {root_ref}: {root_task.title[:50]}...")
-
-            # Build merged context from stored expansion_context + user context
-            merged_context = build_expansion_context(root_task.expansion_context, context)
-
-            try:
-                result = asyncio.run(
-                    expander.expand_task(
-                        task_id=root_task.id,
-                        title=root_task.title,
-                        description=root_task.description,
-                        context=merged_context,
-                        enable_web_research=web_research,
-                        enable_code_context=code_context,
-                        session_id=session_id,
-                    )
-                )
-            except Exception as e:
-                click.echo(f"  Error: {e}", err=True)
-                continue
-
-            if "error" in result:
-                click.echo(f"  Error: {result['error']}", err=True)
-                continue
-
-            subtasks = result.get("subtask_ids", [])
-            click.echo(f"  Created {len(subtasks)} subtasks")
-
-            # Apply post-expansion processing (deps, TDD sandwich, validation)
-            post_result = asyncio.run(_post_expansion_processing(root_task, subtasks))
-            if post_result.get("tdd_applied"):
-                click.echo("  → Applied TDD sandwich")
-            if post_result.get("validation_generated", 0) > 0:
-                click.echo(
-                    f"  → Generated {post_result['validation_generated']} validation criteria"
-                )
-            total_subtasks += len(subtasks)
-            total_iterations += 1
-
-    if len(root_tasks) > 1:
-        click.echo(f"\nTotal: {total_subtasks} subtasks across {total_iterations} expansions")
-
-
 @click.command("complexity")
 @click.argument("task_id", required=False)
 @click.option("--all", "analyze_all", is_flag=True, help="Analyze all pending tasks")
@@ -829,112 +495,6 @@ def _analyze_task_complexity(manager: LocalTaskManager, task: Task) -> dict[str,
     }
 
 
-@click.command("expand-all")
-@click.option("--max", "-m", "max_tasks", default=5, help="Maximum tasks to expand")
-@click.option("--min-complexity", default=1, help="Only expand tasks with complexity >= this")
-@click.option("--type", "task_type", help="Filter by task type")
-@click.option("--web-research/--no-web-research", default=False, help="Enable web research")
-@click.option("--dry-run", "-d", is_flag=True, help="Show what would be expanded without doing it")
-def expand_all_cmd(
-    max_tasks: int,
-    min_complexity: int,
-    task_type: str | None,
-    web_research: bool,
-    dry_run: bool,
-) -> None:
-    """Expand all unexpanded tasks (tasks without subtasks)."""
-    import asyncio
-
-    from gobby.config.app import load_config
-    from gobby.llm import LLMService
-    from gobby.tasks.expansion import TaskExpander
-
-    manager = get_task_manager()
-
-    # Find tasks without children
-    all_tasks = manager.list_tasks(status="open", task_type=task_type, limit=100)
-
-    unexpanded = []
-    for t in all_tasks:
-        children = manager.list_tasks(parent_task_id=t.id, limit=1)
-        if not children:
-            if t.complexity_score is None or t.complexity_score >= min_complexity:
-                unexpanded.append(t)
-
-    to_expand = unexpanded[:max_tasks]
-
-    if not to_expand:
-        click.echo("No unexpanded tasks found matching criteria.")
-        return
-
-    if dry_run:
-        click.echo(f"Would expand {len(to_expand)} tasks:")
-        for t in to_expand:
-            score = t.complexity_score or "?"
-            click.echo(f"  {t.id[:12]} | Complexity: {score} | {t.title[:50]}")
-        return
-
-    # Initialize services
-    try:
-        config = load_config()
-        if not config.gobby_tasks.expansion.enabled:
-            click.echo("Error: Task expansion is disabled in config.", err=True)
-            return
-
-        llm_service = LLMService(config)
-        expander = TaskExpander(
-            config.gobby_tasks.expansion, llm_service, manager, mcp_manager=None
-        )
-    except Exception as e:
-        click.echo(f"Error initializing services: {e}", err=True)
-        return
-
-    click.echo(f"Expanding {len(to_expand)} tasks...")
-
-    async def expand_tasks() -> list[dict[str, Any]]:
-        results = []
-        for task in to_expand:
-            click.echo(f"\nExpanding: {task.title[:60]}...")
-            try:
-                result = await expander.expand_task(
-                    task_id=task.id,
-                    title=task.title,
-                    description=task.description,
-                    enable_web_research=web_research,
-                    enable_code_context=True,
-                )
-                subtask_ids = result.get("subtask_ids", [])
-                results.append(
-                    {
-                        "task_id": task.id,
-                        "title": task.title,
-                        "subtasks_created": len(subtask_ids),
-                        "status": "success" if not result.get("error") else "error",
-                        "error": result.get("error"),
-                    }
-                )
-                if result.get("error"):
-                    click.echo(f"  Error: {result['error']}")
-                else:
-                    click.echo(f"  Created {len(subtask_ids)} subtasks")
-            except Exception as e:
-                results.append(
-                    {
-                        "task_id": task.id,
-                        "title": task.title,
-                        "status": "error",
-                        "error": str(e),
-                    }
-                )
-                click.echo(f"  Error: {e}")
-        return results
-
-    results = asyncio.run(expand_tasks())
-
-    success_count = len([r for r in results if r["status"] == "success"])
-    click.echo(f"\nExpanded {success_count}/{len(results)} tasks successfully.")
-
-
 @click.command("suggest")
 @click.option("--type", "-t", "task_type", help="Filter by task type")
 @click.option("--no-prefer-subtasks", is_flag=True, help="Don't prefer leaf tasks over parents")

gobby/cli/tasks/crud.py

@@ -320,8 +320,21 @@ def task_stats(project_ref: str | None, json_format: bool) -> None:
 @click.option("--description", "-d", help="Task description")
 @click.option("--priority", "-p", type=int, default=2, help="Priority (1=High, 2=Med, 3=Low)")
 @click.option("--type", "-t", "task_type", default="task", help="Task type")
-def create_task(title: str, description: str | None, priority: int, task_type: str) -> None:
-    """Create a new task."""
+@click.option("--depends-on", "-D", multiple=True, help="Task(s) this task depends on (#N, UUID)")
+def create_task(
+    title: str,
+    description: str | None,
+    priority: int,
+    task_type: str,
+    depends_on: tuple[str, ...],
+) -> None:
+    """Create a new task.
+
+    Examples:
+        gobby tasks create "Fix bug"
+        gobby tasks create "Implement feature" --depends-on "#1"
+        gobby tasks create "Final review" -D "#1" -D "#2"
+    """
     project_ctx = get_project_context()
     if not project_ctx or "id" not in project_ctx:
         click.echo("Error: Not in a gobby project or project.json missing 'id'.", err=True)
@@ -343,6 +356,22 @@ def create_task(title: str, description: str | None, priority: int, task_type: s
     else:
         click.echo(f"Created task {task_ref}: {task.title}")
 
+    # Handle depends_on
+    if depends_on:
+        from gobby.storage.task_dependencies import TaskDependencyManager
+
+        dep_manager = TaskDependencyManager(manager.db)
+        for blocker_ref in depends_on:
+            try:
+                blocker = resolve_task_id(manager, blocker_ref)
+                if blocker:
+                    # blocker blocks task (task depends on blocker)
+                    dep_manager.add_dependency(blocker.id, task.id, "blocks")
+                    blocker_display = f"#{blocker.seq_num}" if blocker.seq_num else blocker.id[:8]
+                    click.echo(f"  → depends on {blocker_display}")
+            except Exception as e:
+                click.echo(f"  Warning: Could not add dependency on '{blocker_ref}': {e}", err=True)
+
 
 @click.command("show")
 @click.argument("task_id", metavar="TASK")
@@ -537,9 +566,12 @@ def reopen_task_cmd(task_id: str, reason: str | None) -> None:
 
 @click.command("delete")
 @click.argument("task_refs", nargs=-1, required=True, metavar="TASKS...")
-@click.option("--cascade", "-c", is_flag=True, help="Delete child tasks")
+@click.option("--cascade", "-c", is_flag=True, help="Delete child tasks and dependent tasks")
+@click.option(
+    "--unlink", "-u", is_flag=True, help="Remove dependency links but preserve dependent tasks"
+)
 @click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
-def delete_task(task_refs: tuple[str, ...], cascade: bool, yes: bool) -> None:
+def delete_task(task_refs: tuple[str, ...], cascade: bool, unlink: bool, yes: bool) -> None:
     """Delete one or more tasks.
 
     TASKS can be: #N (e.g., #1, #47), comma-separated (#1,#2,#3), or UUIDs.
@@ -549,6 +581,7 @@ def delete_task(task_refs: tuple[str, ...], cascade: bool, yes: bool) -> None:
         gobby tasks delete #42
         gobby tasks delete #42,#43,#44 --cascade
         gobby tasks delete #42 #43 #44 --yes
+        gobby tasks delete #42 --unlink
     """
     from gobby.cli.tasks._utils import parse_task_refs
 
@@ -576,13 +609,18 @@ def delete_task(task_refs: tuple[str, ...], cascade: bool, yes: bool) -> None:
     deleted = 0
     for ref, resolved in resolved_tasks:
         try:
-            manager.delete_task(resolved.id, cascade=cascade)
+            manager.delete_task(resolved.id, cascade=cascade, unlink=unlink)
             click.echo(f"Deleted task {resolved.id}")
             deleted += 1
         except ValueError as e:
             msg = str(e)
-            if "has children" in msg and "cascade=True" in msg:
+            if "has children" in msg:
                 msg = f"Task {ref} has children. Use --cascade to delete with all subtasks."
+            elif "dependent task(s)" in msg:
+                msg = (
+                    f"Task {ref} has dependent tasks. "
+                    f"Use --cascade to delete them, or --unlink to preserve them."
+                )
             click.echo(f"Error: {msg}", err=True)
 
     if len(resolved_tasks) > 1:

gobby/cli/tasks/main.py

@@ -14,8 +14,6 @@ from gobby.cli.tasks._utils import (
 )
 from gobby.cli.tasks.ai import (
     complexity_cmd,
-    expand_all_cmd,
-    expand_task_cmd,
     generate_criteria_cmd,
     suggest_cmd,
     validate_task_cmd,
@@ -65,9 +63,7 @@ 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

gobby/cli/tui.py

@@ -7,14 +7,14 @@ import click
 @click.option(
     "--port",
     "-p",
-    default=8765,
+    default=60887,
     help="Daemon HTTP port",
     show_default=True,
 )
 @click.option(
     "--ws-port",
     "-w",
-    default=8766,
+    default=60888,
     help="Daemon WebSocket port",
     show_default=True,
 )

gobby/cli/utils.py

@@ -118,7 +118,7 @@ def get_active_session_id(db: LocalDatabase | None = None) -> str | None:
             db.close()
 
 
-def resolve_session_id(session_ref: str | None) -> str:
+def resolve_session_id(session_ref: str | None, project_id: str | None = None) -> str:
     """
     Resolve session reference to UUID.
 
@@ -126,6 +126,8 @@ def resolve_session_id(session_ref: str | None) -> str:
 
     Args:
         session_ref: User input string (UUID, #N, N, prefix) or None
+        project_id: Project ID for project-scoped #N lookup.
+            If not provided, auto-detected from current project context.
 
     Returns:
         Resolved UUID string
@@ -142,10 +144,15 @@ def resolve_session_id(session_ref: str | None) -> str:
                 raise click.ClickException("No active session found. Specify --session.")
             return active_id
 
+        # Get project_id from context if not provided
+        if not project_id:
+            ctx = get_project_context()
+            project_id = ctx.get("id") if ctx else None
+
         # Use SessionManager for resolution logic
         manager = LocalSessionManager(db)
         try:
-            return manager.resolve_session_reference(session_ref)
+            return manager.resolve_session_reference(session_ref, project_id)
         except ValueError as e:
             raise click.ClickException(str(e)) from None
     finally:
@@ -263,7 +270,7 @@ def kill_all_gobby_daemons() -> int:
 
     Detection methods:
     1. Matches gobby.runner (the main daemon process)
-    2. Matches processes listening on daemon ports (8765/8766)
+    2. Matches processes listening on daemon ports (60887/60888)
 
     Returns:
         Number of processes killed
@@ -275,8 +282,8 @@ def kill_all_gobby_daemons() -> int:
         ws_port = config.websocket.port
     except Exception:
         # Fallback to defaults if config can't be loaded
-        http_port = 8765
-        ws_port = 8766
+        http_port = 60887
+        ws_port = 60888
 
     killed_count = 0
     current_pid = os.getpid()

gobby/clones/__init__.py

@@ -0,0 +1,13 @@
+"""Clone management for parallel development.
+
+This module provides git clone operations, distinct from worktrees.
+Clones are full repository copies while worktrees share a single .git directory.
+"""
+
+from gobby.clones.git import CloneGitManager, CloneStatus, GitOperationResult
+
+__all__ = [
+    "CloneGitManager",
+    "CloneStatus",
+    "GitOperationResult",
+]