task-agent 1.3.7__tar.gz → 1.3.8__tar.gz

{task_agent-1.3.7 → task_agent-1.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: task-agent
-Version: 1.3.7
+Version: 1.3.8
 Summary: A prioritized, file-based task queue for autonomous agentic workers
 Project-URL: Homepage, https://github.com/InTEGr8or/task-agent
 Project-URL: Repository, https://github.com/InTEGr8or/task-agent.git

{task_agent-1.3.7 → task_agent-1.3.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "task-agent"
-version = "1.3.7"
+version = "1.3.8"
 description = "A prioritized, file-based task queue for autonomous agentic workers"
 readme = "README.md"
 requires-python = ">=3.12"

{task_agent-1.3.7 → task_agent-1.3.8}/src/taskagent/cli.py

@@ -1669,6 +1669,7 @@ def cmd_done(
     solution: Optional[str] = None,
     no_verify: bool = True,
     metrics: Optional[SubtaskMetric] = None,
+    cached_only: bool = False,
 ):
     """Mark an issue as done."""
     if not slug:
@@ -1699,6 +1700,7 @@ def cmd_done(
             solution_explanation=solution,
             no_verify=no_verify,
             metrics=metrics,
+            cached_only=cached_only,
         )
         console.print(
             f"[bold green]Issue '{issue.slug}' marked as done and "
@@ -7050,6 +7052,15 @@ TA_STRATEGY_COOLDOWN_HOURS environment variable.
         default=True,
         help="Skip running git pre-commit hooks (default)",
     )
+    done_parser.add_argument(
+        "--cached-only",
+        action="store_true",
+        help=(
+            "Commit only what's already staged (git add) instead of `git add .` — "
+            "for concurrent agents in the same working tree/branch on unrelated "
+            "files, so one agent's `done` doesn't sweep up the other's changes"
+        ),
+    )
     done_parser.add_argument(
         "--hooks",
         dest="no_verify",
@@ -7456,6 +7467,7 @@ TA_STRATEGY_COOLDOWN_HOURS environment variable.
             args.solution,
             args.no_verify,
             metrics=done_metrics,
+            cached_only=getattr(args, "cached_only", False),
         )
     elif args.command == "delete":
         cmd_soft_delete(console, manager, args.slug)

{task_agent-1.3.7 → task_agent-1.3.8}/src/taskagent/manager.py

@@ -1305,8 +1305,19 @@ class TaskAgent:
         amend: bool = False,
         files: Optional[List[str]] = None,
         no_verify: bool = True,
+        cached_only: bool = False,
     ) -> str:
-        """Helper to perform a git commit with retry logic for hooks."""
+        """Helper to perform a git commit with retry logic for hooks.
+
+        ``cached_only`` skips every ``git add`` this method would otherwise
+        run (both ``files`` and the ``git add .`` fallback) and commits
+        exactly what's already staged. For two agents editing the same
+        working tree/branch concurrently on unrelated files, this is the
+        difference between "commit my changes" and "commit whatever's lying
+        around" — the latter silently sweeps up the other agent's in-progress
+        work. The caller is expected to have already run their own
+        ``git add`` for exactly what they want committed.
+        """
 
         def _get_git_add_path(f: str) -> str:
             resolved_f = Path(f).resolve()
@@ -1316,7 +1327,9 @@ class TaskAgent:
             except ValueError:
                 return f
 
-        if files:
+        if cached_only:
+            pass
+        elif files:
             for f in files:
                 git_add_path = _get_git_add_path(f)
                 # Force-add so gitignored task paths are included when needed
@@ -1353,7 +1366,7 @@ class TaskAgent:
             ):
                 return "no_changes"
 
-            if not amend:
+            if not amend and not cached_only:
                 # Retry once for pre-commit hooks
                 if files:
                     for f in files:
@@ -1418,12 +1431,19 @@ class TaskAgent:
         solution_explanation: Optional[str] = None,
         no_verify: bool = True,
         metrics: Optional[SubtaskMetric] = None,
+        cached_only: bool = False,
     ) -> Tuple[Issue, str]:
         """Mark an issue as done. Returns (issue, commit_hash).
 
         Optional ``metrics`` captures agent self-reported cost context
         (model, harness, tokens, duration) written into the task README and
         ``meta.json`` for later cost analysis via ``ta report``.
+
+        ``cached_only`` commits only what's already staged in the code repo
+        (no ``git add .``) — for two agents completing tasks in the same
+        working tree/branch at once on unrelated files, so one agent's
+        ``ta done`` never sweeps up the other's untracked or modified-but-
+        unstaged work. The caller must ``git add`` their own files first.
         """
         issues = self.load_mission()
         target_issue = next((i for i in issues if i.slug == slug), None)
@@ -1454,7 +1474,10 @@ class TaskAgent:
                 msg = commit_message or f"feat: complete {target_issue.slug}"
                 if self.code_root:
                     code_hash = self._git_commit(
-                        self.code_root, msg, no_verify=no_verify
+                        self.code_root,
+                        msg,
+                        no_verify=no_verify,
+                        cached_only=cached_only,
                     )
                     if code_hash == "failed":
                         raise RuntimeError(

{task_agent-1.3.7 → task_agent-1.3.8}/src/taskagent/mcp.py

@@ -720,6 +720,7 @@ def complete_task(
     started_at: Optional[str] = None,
     ended_at: Optional[str] = None,
     metrics_notes: Optional[str] = None,
+    cached_only: bool = False,
 ) -> str:
     """Mark a task as completed and commit the changes.
 
@@ -743,6 +744,11 @@ def complete_task(
         started_at: ISO-8601 start time (optional; derived from duration when omitted).
         ended_at: ISO-8601 end time (defaults to now when metrics are provided).
         metrics_notes: Free-form cost notes (retries, cache hits, tool-loop count, …).
+        cached_only: Commit only what's already staged (git add) instead of
+            `git add .`. Use this when another agent is working in the same
+            repo/branch/worktree on unrelated files at the same time — stage
+            exactly your own files first, then complete with this on, so you
+            never sweep up their in-progress, unstaged work into your commit.
     """
     from taskagent.models.metric import SubtaskMetric
 
@@ -768,6 +774,7 @@ def complete_task(
             commit_message=message,
             solution_explanation=solution,
             metrics=metrics,
+            cached_only=cached_only,
         )
         lines = [
             "### Task Completed Successfully",

{task_agent-1.3.7 → task_agent-1.3.8}/tests/test_cli.py

@@ -1551,6 +1551,26 @@ def test_cli_log(manager, monkeypatch):
             assert "2" in extra_args
 
 
+def test_cli_done_cached_only_flag(manager, monkeypatch):
+    """ta done --cached-only must reach cmd_done as cached_only=True, and
+    plain `ta done` (the default) must not."""
+    from taskagent.cli import main
+    from unittest.mock import patch
+
+    monkeypatch.setattr("sys.argv", ["ta", "done", "some-task", "--cached-only"])
+    with patch("taskagent.cli.cmd_done") as mock_cmd_done:
+        with patch("taskagent.cli.TaskAgent", return_value=manager):
+            main()
+            mock_cmd_done.assert_called_once()
+            assert mock_cmd_done.call_args[1].get("cached_only") is True
+
+    monkeypatch.setattr("sys.argv", ["ta", "done", "some-task"])
+    with patch("taskagent.cli.cmd_done") as mock_cmd_done:
+        with patch("taskagent.cli.TaskAgent", return_value=manager):
+            main()
+            assert mock_cmd_done.call_args[1].get("cached_only") is False
+
+
 def test_format_git_log_rich():
     from taskagent.cli import format_git_log_rich
 

task_agent-1.3.8/tests/test_manager_git.py

@@ -0,0 +1,253 @@
+import subprocess
+
+import pytest
+from unittest.mock import MagicMock, patch
+from pathlib import Path
+from taskagent.manager import TaskAgent
+
+
+@pytest.fixture
+def manager(tmp_path):
+    issues_root = tmp_path / "docs" / "tasks"
+    return TaskAgent(config_dir=str(issues_root))
+
+
+def test_git_root_detection(tmp_path, manager):
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value.stdout = "/path/to/repo\n"
+        mock_run.return_value.returncode = 0
+
+        root = manager._get_git_root(tmp_path)
+        assert root == Path("/path/to/repo")
+        # We now use shell=(os.name == "nt")
+        import os
+
+        mock_run.assert_called_with(
+            ["git", "-C", str(tmp_path), "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            check=True,
+            shell=(os.name == "nt"),
+        )
+
+
+def test_git_commit_retry_on_hook_failure(manager):
+    with (
+        patch("subprocess.run") as mock_run,
+        patch("subprocess.check_output") as mock_check,
+    ):
+        # First call fails (hook), second succeeds
+        mock_run.side_effect = [
+            MagicMock(returncode=0),  # git add
+            MagicMock(returncode=1),  # git commit fail
+            MagicMock(returncode=0),  # git add retry
+            MagicMock(returncode=0),  # git commit retry
+        ]
+        mock_check.return_value = "abc1234\n"
+
+        result = manager._git_commit(Path("/repo"), "feat: test")
+        assert result == "abc1234"
+        assert mock_run.call_count == 4
+
+
+def test_dual_repo_detection(tmp_path, manager):
+    # Mock code_root and mission_root to be different
+    manager.code_root = Path("/projects/app")
+    manager.mission_root = Path("/projects/tasks")
+    assert manager.is_dual_repo is True
+
+    manager.mission_root = Path("/projects/app")
+    assert manager.is_dual_repo is False
+
+
+@pytest.mark.skip(reason="Test failing due to environment issue")
+def test_complete_issue_dual_repo_flow(tmp_path, manager):
+    # Setup dual repo state
+    code_root = tmp_path / "code"
+    mission_root = tmp_path / "mission"
+    code_root.mkdir()
+    mission_root.mkdir()
+
+    # Set them explicitly
+    manager.code_root = code_root
+    manager.mission_root = mission_root
+    manager.issues_root = mission_root / "tasks"
+    manager.create_issue("Test Task")
+
+    print(f"DEBUG: mission_root={manager.mission_root}")
+    print(f"DEBUG: code_root={manager.code_root}")
+    print(f"DEBUG: is_dual_repo={manager.is_dual_repo}")
+
+    with patch.object(TaskAgent, "_git_commit") as mock_commit:
+        mock_commit.return_value = "hash123"
+
+        manager.complete_issue("test-task", should_commit=True)
+
+        # Should call commit twice (once for code, once for mission)
+        # Plus the amend call
+        assert mock_commit.call_count >= 2
+        # Verify first call is for code repo
+        assert mock_commit.call_args_list[0].args[0] == code_root
+        # Verify second call is for mission repo
+        assert mock_commit.call_args_list[1].args[0] == mission_root
+
+
+def test_git_commit_no_verify(manager):
+
+    with (
+        patch("subprocess.run") as mock_run,
+        patch("subprocess.check_output") as mock_check,
+    ):
+        mock_run.return_value = MagicMock(returncode=0)
+        mock_check.return_value = "abc1234\n"
+
+        # Call with no_verify=True (default)
+        result = manager._git_commit(Path("/repo"), "feat: test", no_verify=True)
+        assert result == "abc1234"
+
+        # Verify the commit call included --no-verify
+        commit_call = mock_run.call_args_list[1]
+        assert "--no-verify" in commit_call.args[0]
+
+        # Call with no_verify=False
+        result = manager._git_commit(Path("/repo"), "feat: test", no_verify=False)
+        assert result == "abc1234"
+
+        # Verify the commit call did NOT include --no-verify
+        commit_call_2 = mock_run.call_args_list[3]
+        assert "--no-verify" not in commit_call_2.args[0]
+
+
+def test_git_commit_cached_only_skips_git_add(manager):
+    """cached_only must never run `git add` — only the commit itself — since
+    the whole point is committing exactly what the caller already staged,
+    not sweeping in whatever else is sitting in the working tree (e.g. a
+    second agent's in-progress, unstaged edits in the same repo)."""
+    with (
+        patch("subprocess.run") as mock_run,
+        patch("subprocess.check_output") as mock_check,
+    ):
+        mock_run.return_value = MagicMock(returncode=0)
+        mock_check.return_value = "abc1234\n"
+
+        result = manager._git_commit(Path("/repo"), "feat: test", cached_only=True)
+
+        assert result == "abc1234"
+        assert mock_run.call_count == 1  # commit only, no add
+        commit_call = mock_run.call_args_list[0]
+        assert commit_call.args[0][3] == "commit"
+
+
+def test_git_commit_cached_only_with_files_still_skips_add(manager):
+    """files= is meaningless once cached_only=True — still no add call."""
+    with (
+        patch("subprocess.run") as mock_run,
+        patch("subprocess.check_output") as mock_check,
+    ):
+        mock_run.return_value = MagicMock(returncode=0)
+        mock_check.return_value = "abc1234\n"
+
+        manager._git_commit(
+            Path("/repo"),
+            "feat: test",
+            files=["some/file.py"],
+            cached_only=True,
+        )
+
+        assert mock_run.call_count == 1
+
+
+def test_git_commit_cached_only_does_not_retry_on_failure(manager):
+    """The retry path re-adds (`git add .` or specific files) to pick up
+    hook-modified files — for cached_only that would defeat the purpose by
+    staging whatever else is in the tree, so it must not retry at all."""
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(
+            returncode=1, stdout="", stderr="hook rejected"
+        )
+
+        result = manager._git_commit(Path("/repo"), "feat: test", cached_only=True)
+
+        assert result == "failed"
+        assert mock_run.call_count == 1  # the one failed commit attempt, no retry
+
+
+def test_git_commit_cached_only_reports_no_changes_when_index_empty(manager):
+    with patch("subprocess.run") as mock_run:
+        mock_run.return_value = MagicMock(
+            returncode=1, stdout="nothing to commit, working tree clean", stderr=""
+        )
+
+        result = manager._git_commit(Path("/repo"), "feat: test", cached_only=True)
+
+        assert result == "no_changes"
+        assert mock_run.call_count == 1
+
+
+def test_git_commit_cached_only_leaves_other_agents_unstaged_work_alone(
+    tmp_path, manager
+):
+    """The actual scenario this exists for: two agents editing the same
+    working tree/branch on unrelated files. Real git repo, no mocking —
+    stage only "my" file, leave "their" file modified-but-unstaged, and
+    confirm cached_only=True commits exactly the former and never touches
+    the latter."""
+    repo = tmp_path / "repo"
+    repo.mkdir()
+
+    def git(*args):
+        return subprocess.run(
+            ["git", "-C", str(repo), *args],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+    git("init", "-q")
+    git("config", "user.email", "t@example.com")
+    git("config", "user.name", "t")
+
+    mine = repo / "backend.py"
+    theirs = repo / "tui.py"
+    mine.write_text("original backend\n")
+    theirs.write_text("original tui\n")
+    git("add", "-A")
+    git("commit", "-q", "-m", "seed")
+
+    # Both agents edit their own file.
+    mine.write_text("backend: my finished change\n")
+    theirs.write_text("tui: their in-progress, unrelated change\n")
+    # Only I stage mine — theirs stays a plain unstaged working-tree edit,
+    # exactly like a second agent's uncommitted work sitting in the same
+    # checkout.
+    git("add", "backend.py")
+
+    result = manager._git_commit(repo, "feat: complete backend work", cached_only=True)
+
+    assert result != "failed"
+    assert result != "no_changes"
+
+    committed_files = git("show", "--name-only", "--format=", "HEAD").stdout.split()
+    assert committed_files == ["backend.py"]
+
+    # Their edit must still be sitting there, unstaged, exactly as they left
+    # it: " M" (leading space, not staged) — not "M " or "A ", which would
+    # mean it got swept into the index.
+    status = git("status", "--porcelain").stdout.rstrip("\n")
+    assert status == " M tui.py"
+    assert theirs.read_text() == "tui: their in-progress, unrelated change\n"
+
+
+def test_git_commit_clean_tree(manager):
+    with patch("subprocess.run") as mock_run:
+        # First call: git add (succeeds)
+        # Second call: git commit (fails with returncode=1, but stdout says nothing to commit)
+        mock_run.side_effect = [
+            MagicMock(returncode=0),
+            MagicMock(
+                returncode=1, stdout="nothing to commit, working tree clean", stderr=""
+            ),
+        ]
+
+        result = manager._git_commit(Path("/repo"), "feat: test")
+        assert result == "no_changes"

{task_agent-1.3.7 → task_agent-1.3.8}/tests/test_mcp.py

@@ -142,9 +142,25 @@ def test_mcp_complete_task(mock_manager):
         commit_message="Done",
         solution_explanation="Implemented feature X",
         metrics=None,
+        cached_only=False,
     )
 
 
+def test_mcp_complete_task_cached_only(mock_manager):
+    """Concurrent-agent case: stage your own files first, then complete
+    with cached_only so the commit can't sweep up another agent's unstaged,
+    in-progress work in the same repo/branch/worktree."""
+    mock_manager.slugify.return_value = "task-1"
+    mock_manager.complete_issue.return_value = (
+        Issue(name="Task 1", slug="task-1", status="completed"),
+        "abc1234",
+    )
+
+    mcp.complete_task("Task 1", solution="Backend work", cached_only=True)
+
+    assert mock_manager.complete_issue.call_args.kwargs["cached_only"] is True
+
+
 def test_mcp_complete_task_with_metrics(mock_manager):
     from taskagent.models.metric import SubtaskMetric
 

{task_agent-1.3.7 → task_agent-1.3.8}/uv.lock

@@ -1442,7 +1442,7 @@ wheels = [
 
 [[package]]
 name = "task-agent"
-version = "1.3.7"
+version = "1.3.8"
 source = { editable = "." }
 dependencies = [
     { name = "boto3" },

task_agent-1.3.7/tests/test_manager_git.py

@@ -1,131 +0,0 @@
-import pytest
-from unittest.mock import MagicMock, patch
-from pathlib import Path
-from taskagent.manager import TaskAgent
-
-
-@pytest.fixture
-def manager(tmp_path):
-    issues_root = tmp_path / "docs" / "tasks"
-    return TaskAgent(config_dir=str(issues_root))
-
-
-def test_git_root_detection(tmp_path, manager):
-    with patch("subprocess.run") as mock_run:
-        mock_run.return_value.stdout = "/path/to/repo\n"
-        mock_run.return_value.returncode = 0
-
-        root = manager._get_git_root(tmp_path)
-        assert root == Path("/path/to/repo")
-        # We now use shell=(os.name == "nt")
-        import os
-
-        mock_run.assert_called_with(
-            ["git", "-C", str(tmp_path), "rev-parse", "--show-toplevel"],
-            capture_output=True,
-            text=True,
-            check=True,
-            shell=(os.name == "nt"),
-        )
-
-
-def test_git_commit_retry_on_hook_failure(manager):
-    with (
-        patch("subprocess.run") as mock_run,
-        patch("subprocess.check_output") as mock_check,
-    ):
-        # First call fails (hook), second succeeds
-        mock_run.side_effect = [
-            MagicMock(returncode=0),  # git add
-            MagicMock(returncode=1),  # git commit fail
-            MagicMock(returncode=0),  # git add retry
-            MagicMock(returncode=0),  # git commit retry
-        ]
-        mock_check.return_value = "abc1234\n"
-
-        result = manager._git_commit(Path("/repo"), "feat: test")
-        assert result == "abc1234"
-        assert mock_run.call_count == 4
-
-
-def test_dual_repo_detection(tmp_path, manager):
-    # Mock code_root and mission_root to be different
-    manager.code_root = Path("/projects/app")
-    manager.mission_root = Path("/projects/tasks")
-    assert manager.is_dual_repo is True
-
-    manager.mission_root = Path("/projects/app")
-    assert manager.is_dual_repo is False
-
-
-@pytest.mark.skip(reason="Test failing due to environment issue")
-def test_complete_issue_dual_repo_flow(tmp_path, manager):
-    # Setup dual repo state
-    code_root = tmp_path / "code"
-    mission_root = tmp_path / "mission"
-    code_root.mkdir()
-    mission_root.mkdir()
-
-    # Set them explicitly
-    manager.code_root = code_root
-    manager.mission_root = mission_root
-    manager.issues_root = mission_root / "tasks"
-    manager.create_issue("Test Task")
-
-    print(f"DEBUG: mission_root={manager.mission_root}")
-    print(f"DEBUG: code_root={manager.code_root}")
-    print(f"DEBUG: is_dual_repo={manager.is_dual_repo}")
-
-    with patch.object(TaskAgent, "_git_commit") as mock_commit:
-        mock_commit.return_value = "hash123"
-
-        manager.complete_issue("test-task", should_commit=True)
-
-        # Should call commit twice (once for code, once for mission)
-        # Plus the amend call
-        assert mock_commit.call_count >= 2
-        # Verify first call is for code repo
-        assert mock_commit.call_args_list[0].args[0] == code_root
-        # Verify second call is for mission repo
-        assert mock_commit.call_args_list[1].args[0] == mission_root
-
-
-def test_git_commit_no_verify(manager):
-
-    with (
-        patch("subprocess.run") as mock_run,
-        patch("subprocess.check_output") as mock_check,
-    ):
-        mock_run.return_value = MagicMock(returncode=0)
-        mock_check.return_value = "abc1234\n"
-
-        # Call with no_verify=True (default)
-        result = manager._git_commit(Path("/repo"), "feat: test", no_verify=True)
-        assert result == "abc1234"
-
-        # Verify the commit call included --no-verify
-        commit_call = mock_run.call_args_list[1]
-        assert "--no-verify" in commit_call.args[0]
-
-        # Call with no_verify=False
-        result = manager._git_commit(Path("/repo"), "feat: test", no_verify=False)
-        assert result == "abc1234"
-
-        # Verify the commit call did NOT include --no-verify
-        commit_call_2 = mock_run.call_args_list[3]
-        assert "--no-verify" not in commit_call_2.args[0]
-
-
-def test_git_commit_clean_tree(manager):
-    with patch("subprocess.run") as mock_run:
-        # First call: git add (succeeds)
-        # Second call: git commit (fails with returncode=1, but stdout says nothing to commit)
-        mock_run.side_effect = [
-            MagicMock(returncode=0),
-            MagicMock(
-                returncode=1, stdout="nothing to commit, working tree clean", stderr=""
-            ),
-        ]
-
-        result = manager._git_commit(Path("/repo"), "feat: test")
-        assert result == "no_changes"