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

gobby/mcp_proxy/tools/tasks/_lifecycle.py

@@ -65,13 +65,13 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except TaskNotFoundError as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
         except ValueError as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
 
         task = ctx.task_manager.get_task(resolved_id)
         if not task:
-            return {"error": f"Task {task_id} not found"}
+            return {"success": False, "error": f"Task {task_id} not found"}
 
         # Link commit if provided (convenience for link + close in one call)
         if commit_sha:
@@ -85,6 +85,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         commit_result = validate_commit_requirements(task, reason, repo_path)
         if not commit_result.can_close:
             return {
+                "success": False,
                 "error": commit_result.error_type,
                 "message": commit_result.message,
             }
@@ -92,11 +93,48 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         # Auto-skip validation for certain close reasons
         should_skip = skip_validation or reason.lower() in SKIP_REASONS
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        if session_id:
+            try:
+                resolved_session_id = ctx.resolve_session_id(session_id)
+            except ValueError:
+                pass  # Fall back to raw value if resolution fails
+
+        # Enforce commits if session had edits
+        if resolved_session_id and not should_skip:
+            try:
+                from gobby.storage.sessions import LocalSessionManager
+
+                session_manager = LocalSessionManager(ctx.task_manager.db)
+                session = session_manager.get(resolved_session_id)
+
+                # Check if task has commits (including the one being linked right now)
+                has_commits = bool(task.commits) or bool(commit_sha)
+
+                if session and session.had_edits and not has_commits:
+                    return {
+                        "success": False,
+                        "error": "missing_commits_for_edits",
+                        "message": (
+                            "This session made edits but no commits are linked to the task. "
+                            "You must commit your changes and link them to the task before closing."
+                        ),
+                        "suggestion": (
+                            "Commit your changes with `[#task_id]` in the message, "
+                            "or pass `commit_sha` to `close_task`."
+                        ),
+                    }
+            except Exception:
+                # Don't block close on internal error
+                pass  # nosec B110 - best-effort session edit check
+
         if not should_skip:
             # Check if task has children (is a parent task)
             parent_result = validate_parent_task(ctx, resolved_id)
             if not parent_result.can_close:
-                response = {
+                response: dict[str, Any] = {
+                    "success": False,
                     "error": parent_result.error_type,
                     "message": parent_result.message,
                 }
@@ -127,6 +165,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                     )
                     if not llm_result.can_close:
                         response = {
+                            "success": False,
                             "error": llm_result.error_type,
                             "message": llm_result.message,
                         }
@@ -154,9 +193,9 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
             )
 
             # Auto-link session if provided
-            if session_id:
+            if resolved_session_id:
                 try:
-                    ctx.session_task_manager.link_task(session_id, resolved_id, "review")
+                    ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "review")
                 except Exception:
                     pass  # nosec B110 - best-effort linking
 
@@ -177,15 +216,15 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         ctx.task_manager.close_task(
             resolved_id,
             reason=reason,
-            closed_in_session_id=session_id,
+            closed_in_session_id=resolved_session_id,
             closed_commit_sha=current_commit_sha,
             validation_override_reason=override_justification if store_override else None,
         )
 
         # Auto-link session if provided
-        if session_id:
+        if resolved_session_id:
             try:
-                ctx.session_task_manager.link_task(session_id, resolved_id, "closed")
+                ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "closed")
             except Exception:
                 pass  # nosec B110 - best-effort linking, don't fail the close
 
@@ -193,9 +232,9 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         # Respects the clear_task_on_close variable (defaults to True if not set)
         # This is done here because Claude Code's post-tool-use hook doesn't include
         # the tool result, so the detection_helpers can't verify close succeeded
-        if session_id:
+        if resolved_session_id:
             try:
-                state = ctx.workflow_state_manager.get_state(session_id)
+                state = ctx.workflow_state_manager.get_state(resolved_session_id)
                 if state and state.variables.get("claimed_task_id") == resolved_id:
                     # Check if clear_task_on_close is enabled (default: True)
                     clear_on_close = state.variables.get("clear_task_on_close", True)
@@ -257,7 +296,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Your session ID (from system context). Pass this to track which session closed the task.",
+                    "description": "Your session ID (accepts #N, N, UUID, or prefix). Pass this to track which session closed the task.",
                     "default": None,
                 },
                 "override_justification": {
@@ -292,7 +331,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except (TaskNotFoundError, ValueError) as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
 
         try:
             ctx.task_manager.reopen_task(resolved_id, reason=reason)
@@ -313,7 +352,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
             return {}
         except ValueError as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
 
     registry.register(
         name="reopen_task",
@@ -345,22 +384,23 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except (TaskNotFoundError, ValueError) as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
 
         # Get task before deleting to capture seq_num for ref
         task = ctx.task_manager.get_task(resolved_id)
         if not task:
-            return {"error": f"Task {task_id} not found"}
+            return {"success": False, "error": f"Task {task_id} not found"}
         ref = f"#{task.seq_num}" if task.seq_num else resolved_id[:8]
 
         try:
             deleted = ctx.task_manager.delete_task(resolved_id, cascade=cascade, unlink=unlink)
             if not deleted:
-                return {"error": f"Task {task_id} not found"}
+                return {"success": False, "error": f"Task {task_id} not found"}
         except ValueError as e:
             error_msg = str(e)
             if "dependent task(s)" in error_msg:
                 return {
+                    "success": False,
                     "error": "has_dependents",
                     "message": error_msg,
                     "suggestion": f"Use cascade=True to delete task {ref} and its dependents, "
@@ -368,11 +408,12 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 }
             elif "has children" in error_msg:
                 return {
+                    "success": False,
                     "error": "has_children",
                     "message": error_msg,
                     "suggestion": f"Use cascade=True to delete task {ref} and all its subtasks.",
                 }
-            return {"error": error_msg}
+            return {"success": False, "error": error_msg}
 
         return {
             "ref": ref,
@@ -413,10 +454,10 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except (TaskNotFoundError, ValueError) as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
         task = ctx.task_manager.add_label(resolved_id, label)
         if not task:
-            return {"error": f"Task {task_id} not found"}
+            return {"success": False, "error": f"Task {task_id} not found"}
         return {}
 
     registry.register(
@@ -441,10 +482,10 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except (TaskNotFoundError, ValueError) as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
         task = ctx.task_manager.remove_label(resolved_id, label)
         if not task:
-            return {"error": f"Task {task_id} not found"}
+            return {"success": False, "error": f"Task {task_id} not found"}
         return {}
 
     registry.register(
@@ -487,17 +528,25 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         try:
             resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
         except TaskNotFoundError as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
         except ValueError as e:
-            return {"error": str(e)}
+            return {"success": False, "error": str(e)}
 
         task = ctx.task_manager.get_task(resolved_id)
         if not task:
-            return {"error": f"Task {task_id} not found"}
+            return {"success": False, "error": f"Task {task_id} not found"}
+
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        try:
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError:
+            pass  # Fall back to raw value if resolution fails
 
         # Check if already claimed by another session
-        if task.assignee and task.assignee != session_id and not force:
+        if task.assignee and task.assignee != resolved_session_id and not force:
             return {
+                "success": False,
                 "error": "Task already claimed by another session",
                 "claimed_by": task.assignee,
                 "message": f"Task is already claimed by session '{task.assignee}'. Use force=True to override.",
@@ -506,15 +555,15 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         # Update task with assignee and status in single atomic call
         updated = ctx.task_manager.update_task(
             resolved_id,
-            assignee=session_id,
+            assignee=resolved_session_id,
             status="in_progress",
         )
         if not updated:
-            return {"error": f"Failed to claim task {task_id}"}
+            return {"success": False, "error": f"Failed to claim task {task_id}"}
 
         # Link task to session (best-effort, don't fail the claim if this fails)
         try:
-            ctx.session_task_manager.link_task(session_id, resolved_id, "claimed")
+            ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "claimed")
         except Exception:
             pass  # nosec B110 - best-effort linking
 
@@ -532,7 +581,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Your session ID (from system context). The session claiming the task.",
+                    "description": "Your session ID (accepts #N, N, UUID, or prefix). The session claiming the task.",
                 },
                 "force": {
                     "type": "boolean",

gobby/mcp_proxy/tools/tasks/_lifecycle_validation.py

@@ -53,7 +53,7 @@ def validate_commit_requirements(
             can_close=False,
             error_type="no_commits_linked",
             message=(
-                "A commit is required before closing this task.\n\n"
+                "\nA commit is required before closing this task.\n\n"
                 "**Normal flow:**\n"
                 '1. Commit your changes: git commit -m "[#N] description"\n'
                 '2. Close with commit_sha: close_task(task_id="#N", commit_sha="<sha>")\n\n'

gobby/mcp_proxy/tools/tasks/_session.py

@@ -40,15 +40,21 @@ def create_session_registry(ctx: RegistryContext) -> InternalToolRegistry:
         except (TaskNotFoundError, ValueError) as e:
             return {"error": str(e)}
 
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
         try:
-            ctx.session_task_manager.link_task(session_id, resolved_id, action)
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError as e:
+            return {"error": f"Invalid session_id '{session_id}': {e}"}
+
+        try:
+            ctx.session_task_manager.link_task(resolved_session_id, resolved_id, action)
             return {}
         except ValueError as e:
             return {"error": str(e)}
 
     registry.register(
         name="link_task_to_session",
-        description="Link a task to a session.",
+        description="Link a task to a session. Accepts #N, N, UUID, or prefix for session_id.",
         input_schema={
             "type": "object",
             "properties": {
@@ -58,7 +64,7 @@ def create_session_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Session ID (optional, defaults to linking context if available)",
+                    "description": "Session reference (accepts #N, N, UUID, or prefix)",
                     "default": None,
                 },
                 "action": {
@@ -74,16 +80,25 @@ def create_session_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
     def get_session_tasks(session_id: str) -> dict[str, Any]:
         """Get all tasks associated with a session."""
-        tasks = ctx.session_task_manager.get_session_tasks(session_id)
-        return {"session_id": session_id, "tasks": tasks}
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        try:
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError as e:
+            return {"error": f"Invalid session_id '{session_id}': {e}"}
+
+        tasks = ctx.session_task_manager.get_session_tasks(resolved_session_id)
+        return {"session_id": resolved_session_id, "tasks": tasks}
 
     registry.register(
         name="get_session_tasks",
-        description="Get all tasks associated with a session.",
+        description="Get all tasks associated with a session. Accepts #N, N, UUID, or prefix for session_id.",
         input_schema={
             "type": "object",
             "properties": {
-                "session_id": {"type": "string", "description": "Session ID"},
+                "session_id": {
+                    "type": "string",
+                    "description": "Session reference (accepts #N, N, UUID, or prefix)",
+                },
             },
             "required": ["session_id"],
         },