agentic-devtools 0.2.13__tar.gz → 0.2.15__tar.gz

{agentic_devtools-0.2.13 → agentic_devtools-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-devtools
-Version: 0.2.13
+Version: 0.2.15
 Summary: AI assistant helper commands for the Dragonfly platform
 Author: Dragonfly Team
 License-Expression: MIT

{agentic_devtools-0.2.13 → agentic_devtools-0.2.15}/agentic_devtools/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.13'
-__version_tuple__ = version_tuple = (0, 2, 13)
+__version__ = version = '0.2.15'
+__version_tuple__ = version_tuple = (0, 2, 15)
 
 __commit_id__ = commit_id = None

{agentic_devtools-0.2.13 → agentic_devtools-0.2.15}/agentic_devtools/background_tasks.py

@@ -333,6 +333,8 @@ def main():
                     self.log.flush()
                 def flush(self):
                     self.log.flush()
+                def isatty(self):
+                    return False
 
             log_writer = LogWriter(log)
 

{agentic_devtools-0.2.13 → agentic_devtools-0.2.15}/agentic_devtools/cli/copilot/session.py

@@ -54,6 +54,12 @@ _PROMPT_FILE_PATTERN = "copilot-session-{session_id}-prompt.md"
 # Managed install path for the standalone copilot binary
 _MANAGED_COPILOT = Path.home() / ".agdt" / "bin" / ("copilot.exe" if sys.platform == "win32" else "copilot")
 
+# Maximum prompt length (in characters) that can safely be passed as a
+# positional argument to ``gh copilot suggest``.  Windows' CreateProcess
+# imposes a 32,767-character limit on the entire command line; we leave
+# headroom for the ``gh copilot suggest`` prefix and OS overhead.
+_MAX_GH_COPILOT_ARGV_LENGTH = 30_000
+
 
 # ---------------------------------------------------------------------------
 # Public dataclass
@@ -180,25 +186,34 @@ def _get_log_file_path(session_id: str, start_time: str) -> Path:
     return state_dir / _LOG_DIR_NAME / filename
 
 
-def _build_copilot_args(prompt_file: str) -> list[str]:
+def _build_copilot_args(prompt: str, prompt_file: str) -> Optional[list[str]]:
     """Build the copilot argument list.
 
     Uses the standalone ``copilot`` binary when available (preferred), falling
     back to the ``gh copilot`` extension for backward compatibility.
 
-    The prompt is passed via the ``--file`` flag so that large prompts do not
-    hit shell argument-length limits.
+    The standalone binary receives the prompt via ``--file`` to avoid shell
+    argument-length limits.  The ``gh copilot`` extension does **not** support
+    ``--file``; the prompt text is passed as the positional ``[subject]``
+    argument instead.  When the prompt exceeds
+    :data:`_MAX_GH_COPILOT_ARGV_LENGTH` on the extension path, ``None`` is
+    returned so the caller can use a fallback.
 
     Args:
-        prompt_file: Absolute path to the file containing the prompt.
+        prompt: The full prompt text (used as subject for ``gh copilot``).
+        prompt_file: Absolute path to the file containing the prompt (used
+            with the standalone binary).
 
     Returns:
-        List of strings suitable for :func:`subprocess.Popen`.
+        List of strings suitable for :func:`subprocess.Popen`, or ``None``
+        when the prompt is too large for the ``gh copilot`` argv path.
     """
     standalone = _get_copilot_binary()
     if standalone:
         return [standalone, "suggest", "--file", prompt_file]
-    return ["gh", "copilot", "suggest", "--file", prompt_file]
+    if len(prompt) > _MAX_GH_COPILOT_ARGV_LENGTH:
+        return None
+    return ["gh", "copilot", "suggest", prompt]
 
 
 def _persist_session_state(result: CopilotSessionResult) -> None:
@@ -251,7 +266,9 @@ def start_copilot_session(
     - Generates (or reuses) a unique session ID.
     - Writes *prompt* to a temporary file so that large prompts do not
       exceed CLI argument-length limits.
-    - Starts ``gh copilot suggest --file <prompt_file>``.
+    - Starts ``copilot suggest --file <prompt_file>`` (standalone binary) or
+      ``gh copilot suggest <prompt>`` (extension fallback, which does not
+      support ``--file``).
     - In **interactive** mode the child process inherits the current
       terminal (stdin / stdout / stderr), so the user can interact with
       it directly.  This call blocks until the interactive session ends.
@@ -311,7 +328,26 @@ def start_copilot_session(
         return result
 
     # --- Build command -------------------------------------------------------
-    args = _build_copilot_args(prompt_file)
+    args = _build_copilot_args(prompt, prompt_file)
+
+    # When the prompt is too large for the gh copilot argv path (no
+    # standalone binary available), fall back to printing the prompt.
+    if args is None:
+        warnings.warn(
+            "Prompt too large for gh copilot argv; printing prompt to stdout as fallback.",
+            stacklevel=2,
+        )
+        _print_fallback_prompt(prompt)
+        result = CopilotSessionResult(
+            session_id=session_id,
+            mode=mode,
+            prompt_file=prompt_file,
+            start_time=start_time,
+            pid=None,
+            process=None,
+        )
+        _persist_session_state(result)
+        return result
 
     # --- Launch process -------------------------------------------------------
     if interactive:

{agentic_devtools-0.2.13 → agentic_devtools-0.2.15}/agentic_devtools/cli/workflows/worktree_setup.py

@@ -1013,7 +1013,7 @@ def _start_copilot_session_for_pr_review(
     # Non-interactive mode when VS Code is not available (pipeline scenario),
     # or when there is no TTY attached (e.g. running inside run_function_in_background
     # where stdin/stdout are redirected to DEVNULL/log files).
-    has_tty = sys.stdin.isatty() and sys.stdout.isatty()
+    has_tty = getattr(sys.stdin, "isatty", lambda: False)() and getattr(sys.stdout, "isatty", lambda: False)()
     effective_interactive = interactive and is_vscode_available() and has_tty
 
     print(

{agentic_devtools-0.2.13 → agentic_devtools-0.2.15}/tests/unit/cli/copilot/session/test_start_copilot_session.py

@@ -145,17 +145,17 @@ class TestStartCopilotSessionInteractive:
         assert call_kwargs.get("shell") is False
 
     def test_popen_called_with_correct_args(self, temp_state, mock_available, mock_popen_interactive):
-        """Popen is called with the gh copilot suggest --file <prompt_file> args."""
+        """Popen is called with gh copilot suggest <prompt> args when no standalone binary is available."""
         mock_popen, _ = mock_popen_interactive
-        result = start_copilot_session(
+        start_copilot_session(
             prompt="Do something",
             working_directory=str(temp_state),
             interactive=True,
         )
         call_args = mock_popen.call_args
         cmd = call_args[0][0]
-        assert cmd[:4] == ["gh", "copilot", "suggest", "--file"]
-        assert cmd[4] == result.prompt_file
+        assert cmd[:3] == ["gh", "copilot", "suggest"]
+        assert cmd[3] == "Do something"
 
     def test_wait_is_called(self, temp_state, mock_available, mock_popen_interactive):
         """process.wait() is called for interactive mode."""
@@ -327,3 +327,69 @@ class TestStartCopilotSessionWithStandaloneBinary:
         assert cmd[1] == "suggest"
         assert cmd[2] == "--file"
         assert cmd[3] == result.prompt_file
+
+
+class TestStartCopilotSessionLargePromptFallback:
+    """Tests for start_copilot_session fallback when prompt exceeds argv limits."""
+
+    def test_falls_back_when_prompt_exceeds_argv_limit(self, temp_state, mock_available, capsys):
+        """Falls back to printing the prompt when it exceeds the argv length limit."""
+        large_prompt = "x" * (session_module._MAX_GH_COPILOT_ARGV_LENGTH + 1)
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            result = start_copilot_session(
+                prompt=large_prompt,
+                working_directory=str(temp_state),
+            )
+
+        assert result.process is None
+        assert result.pid is None
+        assert any("too large" in str(warning.message) for warning in w)
+
+    def test_prints_prompt_to_stdout_on_large_prompt(self, temp_state, mock_available, capsys):
+        """Prints the prompt to stdout when it exceeds the argv length limit."""
+        large_prompt = "x" * (session_module._MAX_GH_COPILOT_ARGV_LENGTH + 1)
+
+        with warnings.catch_warnings(record=True):
+            start_copilot_session(
+                prompt=large_prompt,
+                working_directory=str(temp_state),
+            )
+
+        captured = capsys.readouterr()
+        assert large_prompt in captured.out
+
+    def test_prompt_file_still_written_on_large_prompt(self, temp_state, mock_available):
+        """Prompt file is written even when falling back due to large prompt."""
+        from pathlib import Path
+
+        large_prompt = "x" * (session_module._MAX_GH_COPILOT_ARGV_LENGTH + 1)
+
+        with warnings.catch_warnings(record=True):
+            result = start_copilot_session(
+                prompt=large_prompt,
+                working_directory=str(temp_state),
+            )
+
+        assert Path(result.prompt_file).read_text(encoding="utf-8") == large_prompt
+
+    def test_standalone_binary_handles_large_prompt_via_file(
+        self, temp_state, mock_available, mock_popen_interactive
+    ):
+        """Standalone binary uses --file for large prompts (no argv limit issue)."""
+        mock_popen, _ = mock_popen_interactive
+        large_prompt = "x" * (session_module._MAX_GH_COPILOT_ARGV_LENGTH + 1)
+
+        with patch.object(session_module, "_get_copilot_binary", return_value="/usr/local/bin/copilot"):
+            result = start_copilot_session(
+                prompt=large_prompt,
+                working_directory=str(temp_state),
+                interactive=True,
+            )
+
+        call_args = mock_popen.call_args
+        cmd = call_args[0][0]
+        assert cmd[0] == "/usr/local/bin/copilot"
+        assert cmd[2] == "--file"
+        assert result.process is None  # Interactive session already exited

{agentic_devtools-0.2.13 → agentic_devtools-0.2.15}/tests/unit/cli/workflows/worktree_setup/test__start_copilot_session_for_pr_review.py

@@ -296,3 +296,48 @@ class TestStartCopilotSessionForPrReview:
             working_directory=str(tmp_path),
             interactive=False,
         )
+
+    @patch("agentic_devtools.cli.copilot.session.start_copilot_session")
+    @patch("agentic_devtools.cli.workflows.worktree_setup.is_vscode_available")
+    @patch("agentic_devtools.config.load_review_focus_areas")
+    @patch("agentic_devtools.cli.workflows.worktree_setup._wait_for_prompt_file")
+    def test_forces_non_interactive_when_stdout_has_no_isatty(
+        self,
+        mock_wait,
+        mock_focus,
+        mock_vscode,
+        mock_copilot,
+        tmp_path,
+        monkeypatch,
+    ):
+        """Test that the session is non-interactive when stdout has no isatty (LogWriter background task scenario)."""
+
+        class _NoIsattyWriter:
+            """Simulates LogWriter from run_function_in_background - no isatty attribute."""
+
+            def write(self, text: str) -> None:
+                pass
+
+            def flush(self) -> None:
+                pass
+
+        prompt_dir = tmp_path / "scripts" / "temp"
+        prompt_dir.mkdir(parents=True)
+        prompt_file = prompt_dir / "temp-pull-request-review-initiate-prompt.md"
+        prompt_file.write_text("# Review prompt", encoding="utf-8")
+
+        mock_wait.return_value = True
+        mock_focus.return_value = None
+        mock_vscode.return_value = True  # VS Code available, but stdout is a LogWriter
+
+        monkeypatch.setattr("sys.stdout", _NoIsattyWriter())
+
+        # Must not raise AttributeError for missing isatty
+        _start_copilot_session_for_pr_review(str(tmp_path), interactive=True)
+
+        # Must be non-interactive because stdout is not a TTY
+        mock_copilot.assert_called_once_with(
+            prompt="# Review prompt",
+            working_directory=str(tmp_path),
+            interactive=False,
+        )