ouroboros-ai 0.26.5.dev5__tar.gz → 0.26.5.dev6__tar.gz

{ouroboros_ai-0.26.5.dev5 → ouroboros_ai-0.26.5.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.26.5.dev5
+Version: 0.26.5.dev6
 Summary: Specification-first workflow engine for AI coding agents. Works with Claude Code and Codex CLI.
 Author-email: Q00 <jqyu.lee@gmail.com>
 License-File: LICENSE

{ouroboros_ai-0.26.5.dev5 → ouroboros_ai-0.26.5.dev6}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.26.5.dev5'
-__version_tuple__ = version_tuple = (0, 26, 5, 'dev5')
+__version__ = version = '0.26.5.dev6'
+__version_tuple__ = version_tuple = (0, 26, 5, 'dev6')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.26.5.dev5 → ouroboros_ai-0.26.5.dev6}/src/ouroboros/cli/commands/pm.py

@@ -24,9 +24,14 @@ from ouroboros.bigbang.pm_completion import (
 from ouroboros.cli.formatters import console
 from ouroboros.cli.formatters.panels import print_error, print_info, print_success, print_warning
 from ouroboros.cli.formatters.prompting import multiline_prompt_async
-from ouroboros.config import get_clarification_model
+from ouroboros.config import get_clarification_model, get_llm_backend
 from ouroboros.core.types import Result
 from ouroboros.observability import LoggingConfig, configure_logging
+from ouroboros.providers.factory import (
+    create_llm_adapter,
+    resolve_llm_backend,
+    resolve_llm_permission_mode,
+)
 
 app = typer.Typer(
     name="pm",
@@ -58,6 +63,18 @@ def _create_pm_litellm_adapter() -> Any:
     return LiteLLMAdapter()
 
 
+def _raise_missing_litellm_dependency(exc: ModuleNotFoundError) -> None:
+    """Convert a missing optional LiteLLM import into install guidance."""
+    if exc.name == "litellm" or "litellm" in str(exc):
+        msg = (
+            "PM interviews require the optional LiteLLM dependency. "
+            "Reinstall with `ouroboros-ai[litellm]`, or if you use uv tool: "
+            "`uv tool install --force --with litellm ouroboros-ai`."
+        )
+        raise RuntimeError(msg) from exc
+    raise exc
+
+
 @app.callback(invoke_without_command=True)
 def pm_command(
     ctx: typer.Context,
@@ -111,9 +128,6 @@ def pm_command(
     if ctx.invoked_subcommand is not None:
         return
 
-    if model is None:
-        model = get_clarification_model()
-
     if debug:
         configure_logging(LoggingConfig(log_level="DEBUG"))
         print_info("Debug mode enabled - showing verbose logs")
@@ -125,17 +139,36 @@ def pm_command(
     else:
         print_info("Starting new PM interview session...")
 
-    console.print(f"  Model: [dim]{model}[/]\n")
-
     try:
+        resolved_backend = resolve_llm_backend(get_llm_backend())
+        resolved_model = model or get_clarification_model(resolved_backend)
+        permission_mode = resolve_llm_permission_mode(
+            backend=resolved_backend,
+            use_case="interview",
+        )
+
+        console.print(f"  Model: [dim]{resolved_model}[/]\n")
+        if permission_mode == "bypassPermissions":
+            print_warning(
+                "Interview backend "
+                f"'{resolved_backend}' uses bypassPermissions for question generation."
+            )
+
         asyncio.run(
             _run_pm_interview(
                 resume_id=resume,
-                model=model,
+                model=resolved_model,
+                backend=resolved_backend,
                 debug=debug,
                 output_dir=output,
             )
         )
+    except ValueError as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1) from exc
+    except RuntimeError as exc:
+        print_error(str(exc))
+        raise typer.Exit(code=1) from exc
     except KeyboardInterrupt:
         print_info("\nPM interview interrupted. Progress has been saved.")
         raise typer.Exit(code=0)
@@ -334,10 +367,28 @@ def _save_cli_pm_meta(session_id: str, engine: Any) -> None:
     meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")
 
 
+def _make_message_callback(debug: bool):
+    """Create a debug callback for streaming local agent status."""
+    if not debug:
+        return None
+
+    def callback(msg_type: str, content: str) -> None:
+        if msg_type == "thinking":
+            first_line = content.split("\n")[0].strip()
+            display = first_line[:100] + "..." if len(first_line) > 100 else first_line
+            if display:
+                console.print(f"  [dim]thinking:[/] {display}")
+        elif msg_type == "tool":
+            console.print(f"  [yellow]tool:[/] {content}")
+
+    return callback
+
+
 async def _run_pm_interview(
     resume_id: str | None,
     model: str,
-    debug: bool,  # noqa: ARG001
+    backend: str | None,
+    debug: bool,
     output_dir: str | None = None,
 ) -> None:
     """Run the PM interview loop.
@@ -348,16 +399,25 @@ async def _run_pm_interview(
     Args:
         resume_id: Optional session ID to resume.
         model: LLM model identifier.
+        backend: Resolved LLM backend name.
         debug: Enable debug output.
         output_dir: Optional output directory for the generated PM document.
     """
     from ouroboros.bigbang.pm_interview import PMInterviewEngine
 
     try:
-        adapter = _create_pm_litellm_adapter()
-    except RuntimeError as exc:
-        print_error(str(exc))
-        raise typer.Exit(code=1) from exc
+        adapter = create_llm_adapter(
+            backend=backend,
+            use_case="interview",
+            allowed_tools=None,
+            max_turns=5,
+            on_message=_make_message_callback(debug),
+            cwd=Path.cwd(),
+        )
+    except ModuleNotFoundError as exc:
+        if backend == "litellm":
+            _raise_missing_litellm_dependency(exc)
+        raise
     engine = PMInterviewEngine.create(llm_adapter=adapter, model=model)
 
     # Check for existing PM seeds before starting a new session

{ouroboros_ai-0.26.5.dev5 → ouroboros_ai-0.26.5.dev6}/tests/unit/cli/test_pm.py

@@ -2,6 +2,7 @@
 
 from unittest.mock import patch
 
+import pytest
 from typer.testing import CliRunner
 
 from ouroboros.cli.main import app
@@ -9,16 +10,35 @@ from ouroboros.cli.main import app
 runner = CliRunner()
 
 
-@patch("ouroboros.cli.commands.pm._run_pm_interview")
-@patch("ouroboros.cli.commands.pm.get_clarification_model", return_value="default")
+@pytest.mark.parametrize(
+    ("configured_backend", "resolved_backend"),
+    [
+        ("codex", "codex"),
+        ("claude_code", "claude_code"),
+        ("litellm", "litellm"),
+    ],
+)
 def test_pm_uses_configured_clarification_model_when_option_omitted(
-    mock_get_clarification_model, mock_run_pm_interview
+    configured_backend: str,
+    resolved_backend: str,
 ) -> None:
     """The bare `pm` command should resolve its model from config."""
-    result = runner.invoke(app, ["pm"], input="n\n")
+    with (
+        patch("ouroboros.cli.commands.pm.get_llm_backend", return_value=configured_backend),
+        patch(
+            "ouroboros.cli.commands.pm.resolve_llm_backend",
+            return_value=resolved_backend,
+        ),
+        patch(
+            "ouroboros.cli.commands.pm.get_clarification_model",
+            return_value="default",
+        ) as mock_get_clarification_model,
+        patch("ouroboros.cli.commands.pm._run_pm_interview") as mock_run_pm_interview,
+    ):
+        result = runner.invoke(app, ["pm"], input="n\n")
 
     assert result.exit_code == 0
-    mock_get_clarification_model.assert_called_once_with()
+    mock_get_clarification_model.assert_called_once_with(resolved_backend)
     mock_run_pm_interview.assert_called_once()
     assert mock_run_pm_interview.call_args.kwargs["model"] == "default"
     assert "Model:" in result.output

{ouroboros_ai-0.26.5.dev5 → ouroboros_ai-0.26.5.dev6}/tests/unit/cli/test_pm_interactive_logging.py

@@ -100,7 +100,7 @@ async def test_run_pm_interview_new_session_uses_multiline_prompt_and_shows_prog
 
     with (
         patch.object(Path, "home", return_value=tmp_path),
-        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", return_value=object()),
+        patch("ouroboros.cli.commands.pm.create_llm_adapter", return_value=object()),
         patch("ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine),
         patch("ouroboros.cli.commands.pm._check_existing_pm_seeds", return_value=True),
         patch("ouroboros.cli.commands.pm._load_brownfield_from_db", return_value=[]),
@@ -113,7 +113,7 @@ async def test_run_pm_interview_new_session_uses_multiline_prompt_and_shows_prog
         patch("ouroboros.cli.commands.pm.print_info") as mock_print_info,
         patch("ouroboros.cli.commands.pm.print_success"),
     ):
-        await _run_pm_interview(resume_id=None, model="test-model", debug=False)
+        await _run_pm_interview(resume_id=None, model="test-model", backend="codex", debug=False)
 
     engine.ask_opening_and_start.assert_awaited_once()
     engine.ask_next_question.assert_awaited_once_with(initial_state)
@@ -153,7 +153,7 @@ async def test_run_pm_interview_resume_with_pending_question_skips_generation_me
 
     with (
         patch.object(Path, "home", return_value=tmp_path),
-        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", return_value=object()),
+        patch("ouroboros.cli.commands.pm.create_llm_adapter", return_value=object()),
         patch("ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine),
         patch("ouroboros.cli.commands.pm._save_cli_pm_meta"),
         patch(
@@ -163,7 +163,12 @@ async def test_run_pm_interview_resume_with_pending_question_skips_generation_me
         patch("ouroboros.cli.commands.pm.print_success"),
         patch("ouroboros.cli.commands.pm.console.print"),
     ):
-        await _run_pm_interview(resume_id="resume_123", model="test-model", debug=False)
+        await _run_pm_interview(
+            resume_id="resume_123",
+            model="test-model",
+            backend="codex",
+            debug=False,
+        )
 
     engine.ask_next_question.assert_not_awaited()
     engine._install_pm_steering.assert_called_once()
@@ -199,7 +204,7 @@ async def test_run_pm_interview_preserves_pending_question_across_interrupt_and_
 
     with (
         patch.object(Path, "home", return_value=tmp_path),
-        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", return_value=object()),
+        patch("ouroboros.cli.commands.pm.create_llm_adapter", return_value=object()),
         patch("ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine),
         patch("ouroboros.cli.commands.pm._check_existing_pm_seeds", return_value=True),
         patch("ouroboros.cli.commands.pm._load_brownfield_from_db", return_value=[]),
@@ -213,13 +218,23 @@ async def test_run_pm_interview_preserves_pending_question_across_interrupt_and_
         patch("ouroboros.cli.commands.pm.console.print"),
     ):
         with pytest.raises(KeyboardInterrupt):
-            await _run_pm_interview(resume_id=None, model="test-model", debug=False)
+            await _run_pm_interview(
+                resume_id=None,
+                model="test-model",
+                backend="codex",
+                debug=False,
+            )
 
         saved_question_state = engine.save_state.await_args_list[0].args[0]
         assert saved_question_state.rounds[-1].question == "What is the first workflow?"
         assert saved_question_state.rounds[-1].user_response is None
 
-        await _run_pm_interview(resume_id="resume_123", model="test-model", debug=False)
+        await _run_pm_interview(
+            resume_id="resume_123",
+            model="test-model",
+            backend="codex",
+            debug=False,
+        )
 
     engine.ask_next_question.assert_awaited_once_with(interrupted_state)
     engine.load_state.assert_awaited_once_with("resume_123")

ouroboros_ai-0.26.5.dev6/tests/unit/cli/test_pm_runtime_adapter.py

@@ -0,0 +1,226 @@
+"""Tests for PM CLI adapter selection and runtime wiring."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, Mock, patch
+
+import typer
+
+from ouroboros.cli.commands.pm import _run_pm_interview, pm_command
+from ouroboros.core.types import Result
+
+
+def test_run_pm_interview_uses_factory_for_interview_adapter_on_resume() -> None:
+    """Resume mode should build the adapter through the shared interview factory."""
+    sentinel_adapter = object()
+    engine = SimpleNamespace(
+        load_state=AsyncMock(return_value=SimpleNamespace(is_err=True, error="boom")),
+    )
+
+    with (
+        patch(
+            "ouroboros.cli.commands.pm.create_llm_adapter", return_value=sentinel_adapter
+        ) as mock_factory,
+        patch(
+            "ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine
+        ) as mock_create,
+    ):
+        try:
+            asyncio.run(
+                _run_pm_interview(
+                    resume_id="session-123",
+                    model="default",
+                    backend="codex",
+                    debug=False,
+                    output_dir=None,
+                )
+            )
+        except typer.Exit:
+            pass
+        else:
+            raise AssertionError("Expected typer.Exit when mocked load_state returns an error")
+
+    mock_factory.assert_called_once_with(
+        backend="codex",
+        use_case="interview",
+        allowed_tools=None,
+        max_turns=5,
+        on_message=None,
+        cwd=Path.cwd(),
+    )
+    mock_create.assert_called_once_with(llm_adapter=sentinel_adapter, model="default")
+
+
+def test_run_pm_interview_uses_interview_runtime_options_on_new_session() -> None:
+    """New sessions should pass backend-aware interview options into the factory."""
+    sentinel_adapter = object()
+    state = SimpleNamespace(
+        interview_id="pm-session-123",
+        is_complete=True,
+        rounds=[],
+    )
+    engine = SimpleNamespace(
+        get_opening_question=lambda: "What do you want to build?",
+        ask_opening_and_start=AsyncMock(return_value=Result.ok(state)),
+        deferred_items=[],
+        decide_later_items=[],
+        codebase_context="",
+        format_decide_later_summary=lambda: "",
+        _reframe_map={},
+        _selected_brownfield_repos=[],
+        classifications=[],
+    )
+
+    with (
+        patch(
+            "ouroboros.cli.commands.pm.create_llm_adapter", return_value=sentinel_adapter
+        ) as mock_factory,
+        patch(
+            "ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine
+        ) as mock_create,
+        patch("ouroboros.cli.commands.pm._check_existing_pm_seeds", return_value=True),
+        patch("ouroboros.cli.commands.pm._load_brownfield_from_db", return_value=[]),
+        patch("ouroboros.cli.commands.pm._select_repos", return_value=[]),
+        patch("ouroboros.cli.commands.pm._save_cli_pm_meta"),
+        patch(
+            "ouroboros.cli.commands.pm.multiline_prompt_async",
+            new=AsyncMock(return_value="Build a PM workflow"),
+        ),
+    ):
+        asyncio.run(
+            _run_pm_interview(
+                resume_id=None,
+                model="default",
+                backend="codex",
+                debug=True,
+                output_dir=None,
+            )
+        )
+
+    mock_factory.assert_called_once()
+    factory_kwargs = mock_factory.call_args.kwargs
+    assert factory_kwargs["backend"] == "codex"
+    assert factory_kwargs["use_case"] == "interview"
+    assert factory_kwargs["allowed_tools"] is None
+    assert factory_kwargs["max_turns"] == 5
+    assert callable(factory_kwargs["on_message"])
+    assert factory_kwargs["cwd"] == Path.cwd()
+    mock_create.assert_called_once_with(llm_adapter=sentinel_adapter, model="default")
+    engine.ask_opening_and_start.assert_called_once_with(
+        user_response="Build a PM workflow",
+        brownfield_repos=None,
+    )
+
+
+def test_pm_command_uses_backend_safe_default_model() -> None:
+    """CLI entrypoint should normalize the default model for the configured backend."""
+    ctx = SimpleNamespace(invoked_subcommand=None)
+
+    with (
+        patch("ouroboros.cli.commands.pm.get_llm_backend", return_value="codex"),
+        patch(
+            "ouroboros.cli.commands.pm.get_clarification_model",
+            side_effect=lambda backend=None: (
+                "backend-safe-default" if backend == "codex" else "generic-default"
+            ),
+        ) as mock_get_model,
+        patch("ouroboros.cli.commands.pm.resolve_llm_backend", return_value="codex"),
+        patch(
+            "ouroboros.cli.commands.pm.resolve_llm_permission_mode",
+            return_value="bypassPermissions",
+        ),
+        patch(
+            "ouroboros.cli.commands.pm._run_pm_interview", new=Mock(return_value=object())
+        ) as mock_run,
+        patch("ouroboros.cli.commands.pm.asyncio.run"),
+        patch("ouroboros.cli.commands.pm.print_warning") as mock_warning,
+    ):
+        pm_command(
+            ctx=ctx,
+            resume=None,
+            output=None,
+            model=None,
+            debug=False,
+        )
+
+    mock_run.assert_called_once_with(
+        resume_id=None,
+        model="backend-safe-default",
+        backend="codex",
+        debug=False,
+        output_dir=None,
+    )
+    mock_get_model.assert_called_once_with("codex")
+    mock_warning.assert_called_once()
+    assert "bypassPermissions" in mock_warning.call_args.args[0]
+
+
+def test_pm_command_formats_factory_errors() -> None:
+    """Backend/config errors should exit cleanly instead of surfacing a traceback."""
+    ctx = SimpleNamespace(invoked_subcommand=None)
+
+    with (
+        patch("ouroboros.cli.commands.pm.get_llm_backend", return_value="opencode"),
+        patch("ouroboros.cli.commands.pm.get_clarification_model", return_value="default"),
+        patch("ouroboros.cli.commands.pm.print_error") as mock_error,
+    ):
+        try:
+            pm_command(
+                ctx=ctx,
+                resume=None,
+                output=None,
+                model=None,
+                debug=False,
+            )
+        except typer.Exit as exc:
+            assert exc.exit_code == 1
+        else:
+            raise AssertionError("Expected typer.Exit for backend configuration errors")
+
+    mock_error.assert_called_once_with(
+        "OpenCode LLM adapter is not yet available. Supported backends: claude_code, codex, litellm"
+    )
+
+
+def test_pm_command_formats_missing_litellm_dependency() -> None:
+    """LiteLLM installs should fail with actionable guidance instead of a traceback."""
+    ctx = SimpleNamespace(invoked_subcommand=None)
+
+    with (
+        patch("ouroboros.cli.commands.pm.get_llm_backend", return_value="litellm"),
+        patch(
+            "ouroboros.cli.commands.pm.get_clarification_model",
+            side_effect=lambda backend=None: "litellm-model" if backend else "generic-default",
+        ),
+        patch("ouroboros.cli.commands.pm.resolve_llm_backend", return_value="litellm"),
+        patch(
+            "ouroboros.cli.commands.pm.resolve_llm_permission_mode",
+            return_value="default",
+        ),
+        patch(
+            "ouroboros.cli.commands.pm.create_llm_adapter",
+            side_effect=ModuleNotFoundError("No module named 'litellm'"),
+        ),
+        patch("ouroboros.cli.commands.pm.print_error") as mock_error,
+    ):
+        try:
+            pm_command(
+                ctx=ctx,
+                resume=None,
+                output=None,
+                model=None,
+                debug=False,
+            )
+        except typer.Exit as exc:
+            assert exc.exit_code == 1
+        else:
+            raise AssertionError("Expected typer.Exit for missing optional litellm dependency")
+
+    mock_error.assert_called_once_with(
+        "PM interviews require the optional LiteLLM dependency. "
+        "Reinstall with `ouroboros-ai[litellm]`, or if you use uv tool: "
+        "`uv tool install --force --with litellm ouroboros-ai`."
+    )