agentic-devtools 0.2.44__tar.gz → 0.2.45__tar.gz

{agentic_devtools-0.2.44 → agentic_devtools-0.2.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-devtools
-Version: 0.2.44
+Version: 0.2.45
 Summary: Agentic devtools integrate Jira, DevOps & more
 Author: ayaiayorg
 License-Expression: MIT

{agentic_devtools-0.2.44 → agentic_devtools-0.2.45}/agentic_devtools/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.44'
-__version_tuple__ = version_tuple = (0, 2, 44)
+__version__ = version = '0.2.45'
+__version_tuple__ = version_tuple = (0, 2, 45)
 
 __commit_id__ = commit_id = None

{agentic_devtools-0.2.44 → agentic_devtools-0.2.45}/agentic_devtools/cli/setup/pr_workflow.py

@@ -285,9 +285,7 @@ def run_setup_with_pr_workflow(
             # their original branch.
             stash_before_emergency = run_git("stash", "list", check=False)
             before_emergency_count = (
-                len(stash_before_emergency.stdout.strip().splitlines())
-                if stash_before_emergency.stdout.strip()
-                else 0
+                len(stash_before_emergency.stdout.strip().splitlines()) if stash_before_emergency.stdout.strip() else 0
             )
             emergency_stash = run_git(
                 "stash",

{agentic_devtools-0.2.44 → agentic_devtools-0.2.45}/agentic_devtools/cli/workflows/worktree_setup.py

@@ -2535,35 +2535,44 @@ def _maybe_inject_auto_start_before_vscode(
 
     from ..copilot import build_copilot_args
 
-    # Read the current run ID from state to pass through to the task.
-    try:
-        from agentic_devtools.state import get_value
+    # Read the run ID from the TARGET worktree's state context,
+    # not the parent process's state.
+    state_file_path, run_id = _resolve_state_context_in_worktree(worktree_path, include_run_id=True)
 
-        run_id = get_value("agdt_run_id")
-        # If model was not provided, read it from state.
-        if model is None:
-            state_model = get_value("copilot.model_id")
-            if isinstance(state_model, str) and state_model.strip():
-                model = state_model.strip()
-    except Exception:
-        # Missing or unreadable run ID is a hard stop for auto-start injection.
-        print("Auto-start injection skipped: could not read agdt_run_id from state.")
+    if state_file_path is None:
+        # _resolve_state_context_in_worktree failed (unreadable state).
+        print(f"Auto-start injection skipped: could not read agdt_run_id from state in {worktree_path}.")
         return False
 
-    if not isinstance(run_id, str):
-        # Do not inject an auto-start task without a valid, non-empty string run ID.
-        print("Auto-start injection skipped: agdt_run_id is not a string.")
+    if not run_id:
+        # run_id is empty — the agdt_run_id value is missing or was
+        # whitespace-only in the target worktree's state.
+        print(f"Auto-start injection skipped: missing or empty agdt_run_id in {worktree_path}.")
         return False
 
-    run_id_stripped = run_id.strip()
-    if not run_id_stripped:
-        # Do not inject an auto-start task when the run ID is whitespace-only.
-        print("Auto-start injection skipped: agdt_run_id is empty or whitespace.")
-        return False
+    # If model was not provided, read it from the target worktree's state file
+    # that was already resolved by _resolve_state_context_in_worktree.
+    if model is None:
+        try:
+            with state_file_path.open("r", encoding="utf-8") as f:
+                state_data = json.load(f)
+        except (OSError, json.JSONDecodeError):
+            # Best-effort only; leave model as None if we can't read the state.
+            state_data = None
+
+        if isinstance(state_data, dict):
+            # State files written via set_value/get_value store dot-notation
+            # keys as nested objects, e.g. {"copilot": {"model_id": "..."}}.
+            state_model = None
+            copilot_obj = state_data.get("copilot")
+            if isinstance(copilot_obj, dict):
+                state_model = copilot_obj.get("model_id")
+            if isinstance(state_model, str) and state_model.strip():
+                model = state_model.strip()
 
     copilot_args = build_copilot_args(start_prompt, interactive=True, model=model)
     if copilot_args is not None:
-        injected = inject_auto_start_task(worktree_path, start_prompt, run_id=run_id_stripped, model=model)
+        injected = inject_auto_start_task(worktree_path, start_prompt, run_id=run_id, model=model)
         if injected:
             print("   VS Code auto-start task injected (will run on window open).")
         else:

{agentic_devtools-0.2.44 → agentic_devtools-0.2.45}/tests/unit/cli/workflows/worktree_setup/test__maybe_inject_auto_start_before_vscode.py

@@ -1,5 +1,6 @@
 """Tests for _maybe_inject_auto_start_before_vscode."""
 
+import json
 from unittest.mock import patch
 
 from agentic_devtools.cli.workflows.worktree_setup import (
@@ -26,15 +27,15 @@ class TestMaybeInjectAutoStartBeforeVscode:
         capsys,
     ):
         """When copilot args are available and run_id is present, inject the auto-start task."""
-
-        def _get_value_side_effect(key, **kwargs):
-            if key == "agdt_run_id":
-                return "run-123"
-            return None
-
-        with patch("agentic_devtools.state.get_value", side_effect=_get_value_side_effect):
+        state_file = tmp_path / "state.json"
+        state_file.write_text("{}", encoding="utf-8")
+        with patch(
+            f"{_MODULE}._resolve_state_context_in_worktree",
+            return_value=(state_file, "run-123"),
+        ) as mock_resolve:
             result = _maybe_inject_auto_start_before_vscode(str(tmp_path))
 
+        mock_resolve.assert_called_once_with(str(tmp_path), include_run_id=True)
         mock_build_args.assert_called_once_with(COPILOT_SESSION_START_PROMPT, interactive=True, model=None)
         mock_inject.assert_called_once_with(str(tmp_path), COPILOT_SESSION_START_PROMPT, run_id="run-123", model=None)
         captured = capsys.readouterr()
@@ -53,7 +54,12 @@ class TestMaybeInjectAutoStartBeforeVscode:
         capsys,
     ):
         """When build_copilot_args returns None (prompt too large), skip injection."""
-        with patch("agentic_devtools.state.get_value", return_value="run-123"):
+        state_file = tmp_path / "state.json"
+        state_file.write_text("{}", encoding="utf-8")
+        with patch(
+            f"{_MODULE}._resolve_state_context_in_worktree",
+            return_value=(state_file, "run-123"),
+        ):
             result = _maybe_inject_auto_start_before_vscode(str(tmp_path))
 
         mock_build_args.assert_called_once()
@@ -74,7 +80,12 @@ class TestMaybeInjectAutoStartBeforeVscode:
         capsys,
     ):
         """When inject_auto_start_task returns False, a warning message should be printed."""
-        with patch("agentic_devtools.state.get_value", return_value="run-123"):
+        state_file = tmp_path / "state.json"
+        state_file.write_text("{}", encoding="utf-8")
+        with patch(
+            f"{_MODULE}._resolve_state_context_in_worktree",
+            return_value=(state_file, "run-123"),
+        ):
             result = _maybe_inject_auto_start_before_vscode(str(tmp_path))
 
         mock_inject.assert_called_once()
@@ -94,13 +105,12 @@ class TestMaybeInjectAutoStartBeforeVscode:
         tmp_path,
     ):
         """When a custom start_prompt is provided, it is forwarded to build_copilot_args."""
-
-        def _get_value_side_effect(key, **kwargs):
-            if key == "agdt_run_id":
-                return "run-123"
-            return None
-
-        with patch("agentic_devtools.state.get_value", side_effect=_get_value_side_effect):
+        state_file = tmp_path / "state.json"
+        state_file.write_text("{}", encoding="utf-8")
+        with patch(
+            f"{_MODULE}._resolve_state_context_in_worktree",
+            return_value=(state_file, "run-123"),
+        ):
             _maybe_inject_auto_start_before_vscode(
                 str(tmp_path),
                 start_prompt=COPILOT_SESSION_START_PROMPT_WORK_ON_JIRA_ISSUE,
@@ -126,7 +136,7 @@ class TestMaybeInjectAutoStartBeforeVscode:
     @patch(f"{_MODULE}.inject_auto_start_task", return_value=True)
     @patch("agentic_devtools.cli.copilot.build_copilot_args", return_value=["copilot", "-i", "prompt"])
     @patch(f"{_MODULE}._in_test_environment", return_value=False)
-    def test_skips_injection_when_get_value_raises(
+    def test_skips_injection_when_resolve_returns_none_state_path(
         self,
         mock_in_test,
         mock_build_args,
@@ -134,8 +144,11 @@ class TestMaybeInjectAutoStartBeforeVscode:
         tmp_path,
         capsys,
     ):
-        """When get_value raises, injection is skipped and False is returned."""
-        with patch("agentic_devtools.state.get_value", side_effect=RuntimeError("state unavailable")):
+        """When _resolve_state_context_in_worktree returns None state path, injection is skipped."""
+        with patch(
+            f"{_MODULE}._resolve_state_context_in_worktree",
+            return_value=(None, ""),
+        ):
             result = _maybe_inject_auto_start_before_vscode(str(tmp_path))
 
         mock_build_args.assert_not_called()
@@ -143,11 +156,12 @@ class TestMaybeInjectAutoStartBeforeVscode:
         assert result is False
         captured = capsys.readouterr()
         assert "could not read agdt_run_id" in captured.out
+        assert str(tmp_path) in captured.out
 
     @patch(f"{_MODULE}.inject_auto_start_task")
     @patch("agentic_devtools.cli.copilot.build_copilot_args")
     @patch(f"{_MODULE}._in_test_environment", return_value=False)
-    def test_skips_injection_when_run_id_is_not_string(
+    def test_skips_injection_when_run_id_is_empty(
         self,
         mock_in_test,
         mock_build_args,
@@ -155,83 +169,111 @@ class TestMaybeInjectAutoStartBeforeVscode:
         tmp_path,
         capsys,
     ):
-        """When agdt_run_id is not a string, helper returns False before building args."""
-        with patch("agentic_devtools.state.get_value", return_value=123):
+        """When agdt_run_id is empty (missing or whitespace-only, normalized by resolver), helper returns False."""
+        state_file = tmp_path / "state.json"
+        state_file.write_text("{}", encoding="utf-8")
+        with patch(
+            f"{_MODULE}._resolve_state_context_in_worktree",
+            return_value=(state_file, ""),
+        ):
             result = _maybe_inject_auto_start_before_vscode(str(tmp_path))
 
         mock_build_args.assert_not_called()
         mock_inject.assert_not_called()
         assert result is False
         captured = capsys.readouterr()
-        assert "agdt_run_id is not a string" in captured.out
+        assert "missing or empty agdt_run_id" in captured.out
 
-    @patch(f"{_MODULE}.inject_auto_start_task")
-    @patch("agentic_devtools.cli.copilot.build_copilot_args")
+    @patch(f"{_MODULE}.inject_auto_start_task", return_value=True)
+    @patch("agentic_devtools.cli.copilot.build_copilot_args", return_value=["copilot", "-i", "prompt"])
     @patch(f"{_MODULE}._in_test_environment", return_value=False)
-    def test_skips_injection_when_run_id_is_whitespace_only(
+    def test_forwards_model_to_inject_auto_start_task(
         self,
         mock_in_test,
         mock_build_args,
         mock_inject,
         tmp_path,
-        capsys,
     ):
-        """When agdt_run_id is only whitespace, helper returns False before building args."""
-        with patch("agentic_devtools.state.get_value", return_value="   "):
-            result = _maybe_inject_auto_start_before_vscode(str(tmp_path))
+        """When model is provided, it is forwarded to inject_auto_start_task."""
+        state_file = tmp_path / "state.json"
+        state_file.write_text("{}", encoding="utf-8")
+        with patch(
+            f"{_MODULE}._resolve_state_context_in_worktree",
+            return_value=(state_file, "run-123"),
+        ):
+            _maybe_inject_auto_start_before_vscode(str(tmp_path), model="gpt-4")
 
-        mock_build_args.assert_not_called()
-        mock_inject.assert_not_called()
-        assert result is False
-        captured = capsys.readouterr()
-        assert "agdt_run_id is empty or whitespace" in captured.out
+        mock_inject.assert_called_once_with(
+            str(tmp_path), COPILOT_SESSION_START_PROMPT, run_id="run-123", model="gpt-4"
+        )
 
     @patch(f"{_MODULE}.inject_auto_start_task", return_value=True)
     @patch("agentic_devtools.cli.copilot.build_copilot_args", return_value=["copilot", "-i", "prompt"])
     @patch(f"{_MODULE}._in_test_environment", return_value=False)
-    def test_forwards_model_to_inject_auto_start_task(
+    def test_reads_model_from_state_when_not_provided(
         self,
         mock_in_test,
         mock_build_args,
         mock_inject,
         tmp_path,
     ):
-        """When model is provided, it is forwarded to inject_auto_start_task."""
-
-        def _get_value_side_effect(key, **kwargs):
-            if key == "agdt_run_id":
-                return "run-123"
-            return None
-
-        with patch("agentic_devtools.state.get_value", side_effect=_get_value_side_effect):
-            _maybe_inject_auto_start_before_vscode(str(tmp_path), model="gpt-4")
+        """When model is not provided, reads copilot.model_id from target worktree state file."""
+        state_file = tmp_path / "state.json"
+        state_file.write_text(json.dumps({"copilot": {"model_id": "claude-3.5-sonnet"}}), encoding="utf-8")
+
+        with patch(
+            f"{_MODULE}._resolve_state_context_in_worktree",
+            return_value=(state_file, "run-123"),
+        ):
+            _maybe_inject_auto_start_before_vscode(str(tmp_path))
 
         mock_inject.assert_called_once_with(
-            str(tmp_path), COPILOT_SESSION_START_PROMPT, run_id="run-123", model="gpt-4"
+            str(tmp_path), COPILOT_SESSION_START_PROMPT, run_id="run-123", model="claude-3.5-sonnet"
         )
 
     @patch(f"{_MODULE}.inject_auto_start_task", return_value=True)
     @patch("agentic_devtools.cli.copilot.build_copilot_args", return_value=["copilot", "-i", "prompt"])
     @patch(f"{_MODULE}._in_test_environment", return_value=False)
-    def test_reads_model_from_state_when_not_provided(
+    def test_model_fallback_handles_unreadable_state_file(
         self,
         mock_in_test,
         mock_build_args,
         mock_inject,
         tmp_path,
     ):
-        """When model is not provided, reads copilot.model_id from state."""
-
-        def _get_value_side_effect(key, **kwargs):
-            if key == "agdt_run_id":
-                return "run-123"
-            if key == "copilot.model_id":
-                return "claude-3.5-sonnet"
-            return None
-
-        with patch("agentic_devtools.state.get_value", side_effect=_get_value_side_effect):
+        """When state file has invalid JSON, model fallback gracefully leaves model as None."""
+        state_file = tmp_path / "state.json"
+        state_file.write_text("not valid json{{{", encoding="utf-8")
+
+        with patch(
+            f"{_MODULE}._resolve_state_context_in_worktree",
+            return_value=(state_file, "run-123"),
+        ):
             _maybe_inject_auto_start_before_vscode(str(tmp_path))
 
         mock_inject.assert_called_once_with(
-            str(tmp_path), COPILOT_SESSION_START_PROMPT, run_id="run-123", model="claude-3.5-sonnet"
+            str(tmp_path), COPILOT_SESSION_START_PROMPT, run_id="run-123", model=None
         )
+
+    @patch(f"{_MODULE}.inject_auto_start_task", return_value=True)
+    @patch("agentic_devtools.cli.copilot.build_copilot_args", return_value=["copilot", "-i", "prompt"])
+    @patch(f"{_MODULE}._in_test_environment", return_value=False)
+    def test_reads_run_id_from_target_worktree_state_context(
+        self,
+        mock_in_test,
+        mock_build_args,
+        mock_inject,
+        tmp_path,
+    ):
+        """Verifies _resolve_state_context_in_worktree is called with correct worktree_path."""
+        state_file = tmp_path / "state.json"
+        state_file.write_text("{}", encoding="utf-8")
+        with patch(
+            f"{_MODULE}._resolve_state_context_in_worktree",
+            return_value=(state_file, "run-456"),
+        ) as mock_resolve:
+            result = _maybe_inject_auto_start_before_vscode(str(tmp_path))
+
+        mock_resolve.assert_called_once_with(str(tmp_path), include_run_id=True)
+        mock_inject.assert_called_once_with(str(tmp_path), COPILOT_SESSION_START_PROMPT, run_id="run-456", model=None)
+        assert result is True