agentic-devtools 0.2.112__tar.gz → 0.2.113__tar.gz

{agentic_devtools-0.2.112 → agentic_devtools-0.2.113}/PKG-INFO

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

{agentic_devtools-0.2.112 → agentic_devtools-0.2.113}/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.112'
-__version_tuple__ = version_tuple = (0, 2, 112)
+__version__ = version = '0.2.113'
+__version_tuple__ = version_tuple = (0, 2, 113)
 
 __commit_id__ = commit_id = None

{agentic_devtools-0.2.112 → agentic_devtools-0.2.113}/agentic_devtools/cli/workflows/commands.py

@@ -564,6 +564,9 @@ def initiate_work_on_jira_issue_workflow(
     Usage:
         agdt-initiate-work-on-jira-issue-workflow [--issue-key PROJECT-1234]
         agdt-initiate-work-on-jira-issue-workflow --issue-key PROJECT-1234 --interactive true
+        agdt-initiate-work-on-jira-issue-workflow --issue-key PROJECT-1234 --engine langchain
+        agdt-initiate-work-on-jira-issue-workflow --issue-key PROJECT-1234 --use-langchain
+        agdt-initiate-work-on-jira-issue-workflow --issue-key PROJECT-1234 --engine langchain --resume
 
     Args:
         issue_key: Jira issue key (e.g., PROJECT-1234). If not provided, uses jira.issue_key from state.
@@ -602,6 +605,33 @@ def initiate_work_on_jira_issue_workflow(
         default=False,
         help="Skip starting a Copilot session (used by auto-execute to avoid duplicate sessions).",
     )
+    parser.add_argument(
+        "--engine",
+        dest="engine",
+        choices=["langchain"],
+        default=None,
+        help="Orchestration engine to use. 'langchain' routes to the LangGraph-based implementation.",
+    )
+    parser.add_argument(
+        "--use-langchain",
+        dest="use_langchain",
+        action="store_true",
+        default=False,
+        help="Alias for --engine langchain. Routes to the LangGraph-based implementation.",
+    )
+    parser.add_argument(
+        "--resume",
+        dest="resume",
+        action="store_true",
+        default=False,
+        help="Resume from an existing LangGraph checkpoint. Requires --engine langchain or --use-langchain.",
+    )
+    parser.add_argument(
+        "--resume-data",
+        dest="resume_data",
+        default=None,
+        help="JSON string with structured resume payload for gate nodes. Requires --resume.",
+    )
     args = parser.parse_args(_effective_argv(_argv, issue_key, interactive, model, skip_copilot_session))
 
     # CLI values override programmatic values only when not already set
@@ -620,6 +650,32 @@ def initiate_work_on_jira_issue_workflow(
     if not skip_copilot_session and args.skip_copilot_session:
         skip_copilot_session = True
 
+    # Resolve engine selection: --use-langchain is an alias for --engine langchain
+    engine = args.engine
+    if args.use_langchain:
+        engine = "langchain"
+
+    # Validate --resume requires LangChain engine selection
+    if args.resume and engine != "langchain":
+        print("ERROR: --resume requires --engine langchain or --use-langchain.", file=sys.stderr)
+        sys.exit(1)
+
+    # Validate --resume-data requires --resume
+    resume_data = None
+    if args.resume_data is not None:
+        if not args.resume:
+            print("ERROR: --resume-data requires --resume.", file=sys.stderr)
+            sys.exit(1)
+        # Parse and validate resume data JSON
+        try:
+            resume_data = json.loads(args.resume_data)
+        except json.JSONDecodeError as e:
+            print(f"ERROR: --resume-data is not valid JSON: {e}", file=sys.stderr)
+            sys.exit(1)
+        if not isinstance(resume_data, dict):
+            print("ERROR: --resume-data must be a JSON object.", file=sys.stderr)
+            sys.exit(1)
+
     # Resolve identity/scope and clear state in the correct order.
     issue_key = _ensure_scoped_bootstrap_and_clear(issue_key)
     set_value("copilot.model_id", model)
@@ -641,6 +697,19 @@ def initiate_work_on_jira_issue_workflow(
         if isinstance(issue_key, str):
             set_value("jira.issue_key", issue_key)
 
+    # Route to LangGraph-based workflow when --engine langchain is selected.
+    if engine == "langchain":
+        from ...orchestration.runner import run_langchain_workflow
+
+        run_langchain_workflow(
+            issue_key,
+            interactive=interactive,
+            model=model,
+            resume=args.resume,
+            resume_data=resume_data,
+        )
+        return
+
     # Run pre-flight checks
     preflight_result = check_worktree_and_branch(issue_key)
 

agentic_devtools-0.2.113/agentic_devtools/orchestration/runner.py

@@ -0,0 +1,143 @@
+"""LangGraph workflow runner for the work-on-jira-issue workflow.
+
+This module provides the entry point for running the LangGraph-based
+work-on-jira-issue workflow when ``--engine langchain`` is selected.
+"""
+
+import sys
+
+
+def run_langchain_workflow(
+    issue_key: str,
+    *,
+    interactive: bool = False,
+    model: str | None = None,
+    resume: bool = False,
+    resume_data: dict | None = None,
+) -> None:
+    """Run the LangGraph-based work-on-jira-issue workflow.
+
+    This is invoked when ``--engine langchain`` (or ``--use-langchain``) is
+    provided on the CLI.  It builds and invokes the compiled StateGraph with
+    real tool integrations.
+
+    Args:
+        issue_key: Jira issue key (e.g., PROJECT-1234).
+        interactive: Whether to start the Copilot session interactively.
+        model: Copilot model to use.
+        resume: Whether to resume from an existing checkpoint.
+        resume_data: Structured resume payload for gate nodes.
+    """
+    # FR-009: Dependency guard — surface actionable install message.
+    try:
+        from langgraph.graph.state import CompiledStateGraph  # noqa: F401
+    except ImportError:  # pragma: no cover
+        print(
+            "ERROR: LangGraph dependencies are not available.\n\nInstall them with:\n  pip install agentic-devtools\n",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    try:
+        from langgraph.checkpoint.sqlite import SqliteSaver  # noqa: F401
+    except ImportError:  # pragma: no cover
+        print(
+            "ERROR: LangGraph checkpoint dependencies are not available.\n"
+            "\n"
+            "Install them with:\n"
+            "  pip install agentic-devtools\n",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    from .checkpointing import get_checkpointer
+    from .graph_builder import build_work_on_issue_graph
+
+    # Build the thread ID for checkpoint scoping.
+    thread_id = f"work-on-issue-{issue_key}"
+
+    # Initialize checkpointer and build graph.
+    checkpointer = get_checkpointer()
+    try:
+        compiled = build_work_on_issue_graph(checkpointer=checkpointer)
+
+        config = {"configurable": {"thread_id": thread_id}}
+
+        if resume:
+            # Resume from existing checkpoint.
+            from langgraph.types import Command
+
+            # Check if there is an existing checkpoint to resume from.
+            checkpoint = checkpointer.get(config)
+            if checkpoint is None:
+                print(
+                    f"ERROR: No existing checkpoint found for issue {issue_key}.\n"
+                    "Cannot resume without a prior interrupted workflow run.\n"
+                    "\n"
+                    "Start a fresh run without --resume.",
+                    file=sys.stderr,
+                )
+                sys.exit(1)
+
+            # Determine resume payload based on gate type.
+            if resume_data is not None:
+                resume_value = resume_data
+            else:
+                resume_value = True
+
+            print(f"[langchain] Resuming workflow for {issue_key}...")
+            try:
+                result = compiled.invoke(Command(resume=resume_value), config=config)
+            except Exception as e:
+                if type(e).__name__ == "GraphInterrupt":
+                    _print_pause_message(issue_key)
+                    return
+                print(f"ERROR: Workflow resume failed: {e}", file=sys.stderr)
+                sys.exit(1)
+        else:
+            # Fresh invocation.
+            initial_state = {
+                "issue_key": issue_key,
+                "step": "",
+                "status": "",
+                "plan": "",
+                "error": None,
+                "retry_count": 0,
+                "events": [],
+                "human_approved": False,
+                "agent_context": {
+                    "interactive": interactive,
+                    "model": model,
+                },
+                "affected_paths": [],
+            }
+
+            print(f"[langchain] Starting workflow for {issue_key}...")
+            try:
+                result = compiled.invoke(initial_state, config=config)
+            except Exception as e:
+                if type(e).__name__ == "GraphInterrupt":
+                    _print_pause_message(issue_key)
+                    return
+                print(f"ERROR: Workflow execution failed: {e}", file=sys.stderr)
+                sys.exit(1)
+
+        # Report completion.
+        final_step = result.get("step", "unknown")
+        final_status = result.get("status", "unknown")
+        print(f"[langchain] Workflow completed: step={final_step}, status={final_status}")
+    finally:
+        # Close the checkpointer's underlying SQLite connection to avoid
+        # leaking file descriptors / holding the DB file locked.
+        if hasattr(checkpointer, "conn"):
+            checkpointer.conn.close()
+
+
+def _print_pause_message(issue_key: str) -> None:
+    """Print human-in-the-loop pause instructions to stderr."""
+    print(
+        f"\n[langchain] Workflow paused — waiting for human input.\n"
+        f"Resume with: agdt-initiate-work-on-jira-issue-workflow "
+        f"--issue-key {issue_key} --engine langchain --resume",
+        file=sys.stderr,
+    )

{agentic_devtools-0.2.112 → agentic_devtools-0.2.113}/tests/unit/cli/workflows/commands/test_initiate_work_on_jira_issue_workflow.py

@@ -431,3 +431,175 @@ class TestSkipCopilotSession:
 
         mock_session = self._setup_and_mock_preflight_pass("PROJECT-1234", argv=["--skip-copilot-session"])
         mock_session.assert_not_called()
+
+
+class TestEngineLangchainFlag:
+    """Tests for --engine langchain and --use-langchain flags."""
+
+    def test_engine_langchain_routes_to_langchain_runner(
+        self, temp_state_dir, clear_state_before, mock_workflow_state_clearing, capsys
+    ):
+        """--engine langchain routes to run_langchain_workflow instead of existing workflow."""
+        state.set_value("jira.issue_key", "PROJECT-1234")
+
+        import agentic_devtools.orchestration.runner as runner_mod
+
+        with patch.object(runner_mod, "run_langchain_workflow") as mock_runner:
+            commands.initiate_work_on_jira_issue_workflow(_argv=["--engine", "langchain"])
+
+        mock_runner.assert_called_once()
+        call_args = mock_runner.call_args
+        assert call_args[0][0] == "PROJECT-1234"
+        assert call_args[1]["resume"] is False
+        assert call_args[1]["resume_data"] is None
+
+    def test_use_langchain_alias_routes_to_langchain_runner(
+        self, temp_state_dir, clear_state_before, mock_workflow_state_clearing, capsys
+    ):
+        """--use-langchain is an alias for --engine langchain."""
+        state.set_value("jira.issue_key", "PROJECT-1234")
+
+        import agentic_devtools.orchestration.runner as runner_mod
+
+        with patch.object(runner_mod, "run_langchain_workflow") as mock_runner:
+            commands.initiate_work_on_jira_issue_workflow(_argv=["--use-langchain"])
+
+        mock_runner.assert_called_once()
+        call_kwargs = mock_runner.call_args[1]
+        assert call_kwargs["resume"] is False
+
+    def test_no_engine_flag_routes_to_existing_workflow(
+        self, temp_state_dir, clear_state_before, mock_workflow_state_clearing, capsys
+    ):
+        """Without --engine flag, the existing workflow is used (not LangChain)."""
+        state.set_value("jira.issue_key", "PROJECT-1234")
+
+        import agentic_devtools.orchestration.runner as runner_mod
+
+        with patch.object(runner_mod, "run_langchain_workflow") as mock_runner:
+            with patch("agentic_devtools.cli.workflows.commands.check_worktree_and_branch") as mock_preflight:
+                from agentic_devtools.cli.workflows.preflight import PreflightResult
+
+                mock_preflight.return_value = PreflightResult(
+                    folder_valid=False,
+                    branch_valid=False,
+                    folder_name="wrong",
+                    branch_name="main",
+                    issue_key="PROJECT-1234",
+                )
+                with patch("agentic_devtools.cli.workflows.preflight.perform_auto_setup") as mock_setup:
+                    mock_setup.return_value = True
+                    commands.initiate_work_on_jira_issue_workflow(_argv=[])
+
+        # LangChain runner should NOT have been called
+        mock_runner.assert_not_called()
+
+    def test_resume_without_engine_langchain_exits(
+        self, temp_state_dir, clear_state_before, mock_workflow_state_clearing, capsys
+    ):
+        """--resume without --engine langchain exits with error."""
+        state.set_value("jira.issue_key", "PROJECT-1234")
+
+        with pytest.raises(SystemExit) as exc_info:
+            commands.initiate_work_on_jira_issue_workflow(_argv=["--resume"])
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "--resume requires --engine langchain" in captured.err
+
+    def test_resume_with_engine_langchain_passes_resume_flag(
+        self, temp_state_dir, clear_state_before, mock_workflow_state_clearing, capsys
+    ):
+        """--resume with --engine langchain passes resume=True to runner."""
+        state.set_value("jira.issue_key", "PROJECT-1234")
+
+        import agentic_devtools.orchestration.runner as runner_mod
+
+        with patch.object(runner_mod, "run_langchain_workflow") as mock_runner:
+            commands.initiate_work_on_jira_issue_workflow(_argv=["--engine", "langchain", "--resume"])
+
+        mock_runner.assert_called_once()
+        call_kwargs = mock_runner.call_args[1]
+        assert call_kwargs["resume"] is True
+
+    def test_resume_data_without_resume_exits(
+        self, temp_state_dir, clear_state_before, mock_workflow_state_clearing, capsys
+    ):
+        """--resume-data without --resume exits with error."""
+        state.set_value("jira.issue_key", "PROJECT-1234")
+
+        with pytest.raises(SystemExit) as exc_info:
+            commands.initiate_work_on_jira_issue_workflow(
+                _argv=["--engine", "langchain", "--resume-data", '{"completed": true}']
+            )
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "--resume-data requires --resume" in captured.err
+
+    def test_resume_data_invalid_json_exits(
+        self, temp_state_dir, clear_state_before, mock_workflow_state_clearing, capsys
+    ):
+        """--resume-data with invalid JSON exits with error."""
+        state.set_value("jira.issue_key", "PROJECT-1234")
+
+        with pytest.raises(SystemExit) as exc_info:
+            commands.initiate_work_on_jira_issue_workflow(
+                _argv=["--engine", "langchain", "--resume", "--resume-data", "not-json"]
+            )
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "not valid JSON" in captured.err
+
+    def test_resume_data_non_object_exits(
+        self, temp_state_dir, clear_state_before, mock_workflow_state_clearing, capsys
+    ):
+        """--resume-data with non-object JSON (e.g., array) exits with error."""
+        state.set_value("jira.issue_key", "PROJECT-1234")
+
+        with pytest.raises(SystemExit) as exc_info:
+            commands.initiate_work_on_jira_issue_workflow(
+                _argv=["--engine", "langchain", "--resume", "--resume-data", "[1, 2, 3]"]
+            )
+
+        assert exc_info.value.code == 1
+        captured = capsys.readouterr()
+        assert "must be a JSON object" in captured.err
+
+    def test_resume_data_valid_json_passes_to_runner(
+        self, temp_state_dir, clear_state_before, mock_workflow_state_clearing, capsys
+    ):
+        """--resume-data with valid JSON object passes parsed data to runner."""
+        state.set_value("jira.issue_key", "PROJECT-1234")
+
+        import agentic_devtools.orchestration.runner as runner_mod
+
+        with patch.object(runner_mod, "run_langchain_workflow") as mock_runner:
+            commands.initiate_work_on_jira_issue_workflow(
+                _argv=[
+                    "--engine",
+                    "langchain",
+                    "--resume",
+                    "--resume-data",
+                    '{"completed": true, "summary": "Work done"}',
+                ]
+            )
+
+        mock_runner.assert_called_once()
+        call_kwargs = mock_runner.call_args[1]
+        assert call_kwargs["resume_data"] == {"completed": True, "summary": "Work done"}
+
+    def test_auto_execute_command_preserves_engine_langchain(
+        self, temp_state_dir, clear_state_before, mock_workflow_state_clearing, capsys
+    ):
+        """When engine=langchain, the LangChain runner is invoked."""
+        state.set_value("jira.issue_key", "PROJECT-1234")
+
+        import agentic_devtools.orchestration.runner as runner_mod
+
+        with patch.object(runner_mod, "run_langchain_workflow") as mock_runner:
+            commands.initiate_work_on_jira_issue_workflow(_argv=["--engine", "langchain"])
+
+        # The LangChain path handles its own preflight internally
+        mock_runner.assert_called_once()