task-agent 1.0.0__tar.gz → 1.0.2__tar.gz

{task_agent-1.0.0 → task_agent-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: task-agent
-Version: 1.0.0
+Version: 1.0.2
 Summary: A prioritized, file-based task queue for autonomous agentic workers
 Author-email: Mark Stouffer <1802850+InTEGr8or@users.noreply.github.com>
 License: MIT

{task_agent-1.0.0 → task_agent-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "task-agent"
-version = "1.0.0"
+version = "1.0.2"
 description = "A prioritized, file-based task queue for autonomous agentic workers"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -39,7 +39,7 @@ dev = [
 ]
 
 [tool.bumpversion]
-current_version = "1.0.0"
+current_version = "1.0.2"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "version = \"{current_version}\""

{task_agent-1.0.0 → task_agent-1.0.2}/src/taskagent/cli.py

@@ -3505,49 +3505,94 @@ def cmd_triage(
                             target_issue = indexed_issues[sibling_idx][0]
 
                     if target_issue:
+                        live.stop()
                         try:
-                            # Check transitive dependencies recursively to avoid redundancy
-                            all_issues = manager.load_mission()
-
-                            def is_ancestor(ancestor_slug, desc_slug):
-                                slug_to_issue = {i.slug: i for i in all_issues}
-                                if desc_slug not in slug_to_issue:
-                                    return False
-                                todo = list(slug_to_issue[desc_slug].dependencies)
-                                visited = set(todo)
-                                while todo:
-                                    curr = todo.pop()
-                                    if curr == ancestor_slug:
-                                        return True
-                                    if curr in slug_to_issue:
-                                        for dep in slug_to_issue[curr].dependencies:
-                                            if dep not in visited:
-                                                visited.add(dep)
-                                                todo.append(dep)
-                                return False
-
-                            # Add dependency on target_issue
-                            manager.add_dependency(
-                                current_issue.slug, target_issue.slug
-                            )
-
-                            # Remove redundant direct dependencies that are transitively covered
-                            for dep in list(current_issue.dependencies):
-                                if dep != target_issue.slug and is_ancestor(
-                                    dep, target_issue.slug
-                                ):
-                                    manager.remove_dependency(current_issue.slug, dep)
+                            choice = questionary.select(
+                                f"Link '{current_issue.slug}' to '{target_issue.slug}' as:",
+                                choices=[
+                                    f"Subtask of (Hierarchy: parent '{target_issue.slug}' is blocked until child '{current_issue.slug}' is done)",
+                                    f"Blocked by (Ordering: child '{current_issue.slug}' cannot start/finish until parent '{target_issue.slug}' is done)",
+                                    "Cancel",
+                                ],
+                            ).ask()
+                        except (EOFError, Exception):
+                            choice = "Blocked by"
+
+                        if choice and not choice.startswith("Cancel"):
+                            try:
+                                if choice.startswith("Subtask of"):
+                                    # If it was blocked_by, remove to avoid redundancy
+                                    if target_issue.slug in current_issue.blocked_by:
+                                        manager.remove_dependency(
+                                            current_issue.slug,
+                                            target_issue.slug,
+                                        )
+                                    manager.update_subtask_of(
+                                        current_issue.slug, target_issue.slug
+                                    )
+                                else:
+                                    # Blocked by
+                                    # If it was subtask_of, remove to avoid conflicts
+                                    if current_issue.subtask_of == target_issue.slug:
+                                        manager.update_subtask_of(
+                                            current_issue.slug, None
+                                        )
+
+                                    # Check transitive dependencies recursively to avoid redundancy
+                                    all_issues = manager.load_mission()
+
+                                    def is_ancestor(ancestor_slug, desc_slug):
+                                        slug_to_issue = {i.slug: i for i in all_issues}
+                                        if desc_slug not in slug_to_issue:
+                                            return False
+                                        todo = list(
+                                            slug_to_issue[desc_slug].dependencies
+                                        )
+                                        visited = set(todo)
+                                        while todo:
+                                            curr = todo.pop()
+                                            if curr == ancestor_slug:
+                                                return True
+                                            if curr in slug_to_issue:
+                                                for dep in slug_to_issue[
+                                                    curr
+                                                ].dependencies:
+                                                    if dep not in visited:
+                                                        visited.add(dep)
+                                                        todo.append(dep)
+                                        return False
+
+                                    manager.add_dependency(
+                                        current_issue.slug, target_issue.slug
+                                    )
+
+                                    # Remove redundant direct dependencies that are transitively covered
+                                    for dep in list(current_issue.dependencies):
+                                        if dep != target_issue.slug and is_ancestor(
+                                            dep, target_issue.slug
+                                        ):
+                                            manager.remove_dependency(
+                                                current_issue.slug, dep
+                                            )
 
-                            issues = get_display_issues(search_query, show_completed)
-                            indexed_issues = build_hierarchy(issues)
-                        except Exception as e:
-                            console.print(f"[red]Error: {e}[/red]")
+                                issues = get_display_issues(
+                                    search_query, show_completed
+                                )
+                                indexed_issues = build_hierarchy(issues)
+                            except Exception as e:
+                                console.print(f"[red]Error: {e}[/red]")
+                                questionary.press_any_key_to_continue().ask()
+                        live.start()
             elif key == "h" and not show_completed:  # remove dependency on above
                 if cursor > 0:
                     current_issue = indexed_issues[cursor][0]
                     above_issue = indexed_issues[cursor - 1][0]
                     try:
-                        if above_issue.slug in current_issue.dependencies:
+                        updated = False
+                        if current_issue.subtask_of == above_issue.slug:
+                            manager.update_subtask_of(current_issue.slug, None)
+                            updated = True
+                        elif above_issue.slug in current_issue.blocked_by:
                             parents = list(above_issue.dependencies)
                             manager.remove_dependency(
                                 current_issue.slug, above_issue.slug
@@ -3555,11 +3600,14 @@ def cmd_triage(
                             # Move up: inherit the parent's dependencies
                             for parent in parents:
                                 manager.add_dependency(current_issue.slug, parent)
+                            updated = True
 
+                        if updated:
                             issues = get_display_issues(search_query, show_completed)
                             indexed_issues = build_hierarchy(issues)
                     except Exception as e:
                         console.print(f"[red]Error: {e}[/red]")
+                        questionary.press_any_key_to_continue().ask()
 
 
 def display_overview(console: Console, manager: TaskAgent):

{task_agent-1.0.0 → task_agent-1.0.2}/tests/test_cli.py

@@ -575,3 +575,52 @@ def test_cmd_triage_depends_on_above(manager, monkeypatch):
     t3_updated = manager.find_issue_file("task-3")
     assert "task-1" in manager.extract_deps(t3_updated)
     assert "task-2" not in manager.extract_deps(t3_updated)
+
+
+def test_cmd_triage_subtask_of(manager, monkeypatch):
+    from taskagent.cli import cmd_triage
+    from unittest.mock import MagicMock, patch
+
+    manager.create_issue("Task 1")
+    manager.create_issue("Task 2")
+
+    mock_console = MagicMock()
+
+    # We mock questionary.select().ask() to return "Subtask of..."
+    mock_select = MagicMock()
+    mock_select.ask.return_value = "Subtask of (Hierarchy...)"
+
+    keys = ["j", "l", "q"]
+
+    def mock_get_key():
+        if keys:
+            return keys.pop(0)
+        return "q"
+
+    with (
+        patch("taskagent.cli.get_key", mock_get_key),
+        patch("taskagent.cli.Live"),
+        patch("questionary.select", return_value=mock_select),
+    ):
+        cmd_triage(mock_console, manager)
+
+    issue_t2 = manager.load_mission()[1]
+    assert issue_t2.subtask_of == "task-1"
+    assert "task-1" not in issue_t2.blocked_by
+
+    # Test 2: Unlink subtask relation using 'h' key
+    keys = ["j", "h", "q"]
+
+    def mock_get_key_unlink():
+        if keys:
+            return keys.pop(0)
+        return "q"
+
+    with (
+        patch("taskagent.cli.get_key", mock_get_key_unlink),
+        patch("taskagent.cli.Live"),
+    ):
+        cmd_triage(mock_console, manager)
+
+    issue_t2_unlinked = manager.load_mission()[1]
+    assert issue_t2_unlinked.subtask_of is None

{task_agent-1.0.0 → task_agent-1.0.2}/uv.lock

@@ -1135,7 +1135,7 @@ wheels = [
 
 [[package]]
 name = "task-agent"
-version = "1.0.0"
+version = "1.0.2"
 source = { editable = "." }
 dependencies = [
     { name = "githubkit" },