ouroboros-ai 0.26.5.dev1__tar.gz → 0.26.5.dev2__tar.gz

{ouroboros_ai-0.26.5.dev1 → ouroboros_ai-0.26.5.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.26.5.dev1
+Version: 0.26.5.dev2
 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.dev1 → ouroboros_ai-0.26.5.dev2}/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.dev1'
-__version_tuple__ = version_tuple = (0, 26, 5, 'dev1')
+__version__ = version = '0.26.5.dev2'
+__version_tuple__ = version_tuple = (0, 26, 5, 'dev2')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.26.5.dev1 → ouroboros_ai-0.26.5.dev2}/src/ouroboros/cli/commands/init.py

@@ -10,8 +10,6 @@ from pathlib import Path
 from typing import Annotated
 
 import click
-from prompt_toolkit import PromptSession
-from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
 from rich.prompt import Confirm, Prompt
 import typer
 import yaml
@@ -26,6 +24,7 @@ from ouroboros.bigbang.interview import (
 from ouroboros.bigbang.seed_generator import SeedGenerator
 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.observability import LoggingConfig, configure_logging
 from ouroboros.providers import create_llm_adapter
@@ -104,46 +103,6 @@ def _make_message_callback(debug: bool):
     return callback
 
 
-async def _multiline_prompt_async(prompt_text: str) -> str:
-    """Get multiline input with proper paste handling.
-
-    Behavior:
-    - Enter: Submit input
-    - Ctrl+J: Insert newline
-    - Paste: Multiline text is preserved (via bracketed paste mode)
-
-    Args:
-        prompt_text: The prompt to display.
-
-    Returns:
-        The user's input (may contain newlines from paste).
-
-    Raises:
-        EOFError: If end-of-file is reached (e.g., stdin closed).
-        KeyboardInterrupt: If user presses Ctrl+C.
-    """
-    bindings = KeyBindings()
-
-    @bindings.add("c-j")
-    def insert_newline(event: KeyPressEvent) -> None:
-        event.current_buffer.insert_text("\n")
-
-    @bindings.add("c-m")
-    def submit(event: KeyPressEvent) -> None:
-        event.current_buffer.validate_and_handle()
-
-    console.print(f"[bold green]{prompt_text}[/] [dim](Enter: submit, Ctrl+J: newline)[/]")
-
-    session: PromptSession[str] = PromptSession(
-        message="> ",
-        multiline=True,
-        prompt_continuation="  ",
-        key_bindings=bindings,
-    )
-
-    return await session.prompt_async()
-
-
 def _get_adapter(
     use_orchestrator: bool,
     backend: str | None = None,
@@ -219,7 +178,7 @@ async def _run_interview_loop(
         console.print()
 
         # Get user response (multiline-safe for paste)
-        response = await _multiline_prompt_async("Your response")
+        response = await multiline_prompt_async("Your response")
 
         if not response.strip():
             print_error("Response cannot be empty. Please try again.")
@@ -791,7 +750,7 @@ def start(
             )
             console.print()
 
-            context = asyncio.run(_multiline_prompt_async("What would you like to build?"))
+            context = asyncio.run(multiline_prompt_async("What would you like to build?"))
 
     if not resume and not context:
         print_error("Initial context is required when not resuming.")

{ouroboros_ai-0.26.5.dev1 → ouroboros_ai-0.26.5.dev2}/src/ouroboros/cli/commands/pm.py

@@ -19,8 +19,10 @@ import typer
 from ouroboros.bigbang.interview import InterviewRound
 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.core.types import Result
+from ouroboros.observability import LoggingConfig, configure_logging
 
 app = typer.Typer(
     name="pm",
@@ -108,6 +110,10 @@ def pm_command(
     if model is None:
         model = get_clarification_model()
 
+    if debug:
+        configure_logging(LoggingConfig(log_level="DEBUG"))
+        print_info("Debug mode enabled - showing verbose logs")
+
     console.print("\n[bold cyan]Ouroboros PM Generator[/] - Product Requirements Document\n")
 
     if resume:
@@ -392,12 +398,13 @@ async def _run_pm_interview(
         opening = engine.get_opening_question()
         console.print(f"\n[bold yellow]?[/] {opening}\n")
 
-        user_answer = console.input("[bold green]> [/]")
+        user_answer = await multiline_prompt_async("Your response")
 
         if not user_answer.strip():
             print_error("No response provided. Exiting.")
             raise typer.Exit(code=1)
 
+        print_info("Starting interview...")
         state_result = await engine.ask_opening_and_start(
             user_response=user_answer,
             brownfield_repos=brownfield_repos if brownfield_repos else None,
@@ -417,6 +424,7 @@ async def _run_pm_interview(
         if state.rounds and state.rounds[-1].user_response is None:
             question = state.rounds[-1].question
         else:
+            print_info("Generating next question...")
             q_result = await engine.ask_next_question(state)
             if q_result.is_err:
                 print_error(f"Question generation failed: {q_result.error}")
@@ -448,7 +456,7 @@ async def _run_pm_interview(
             break
         _save_cli_pm_meta(state.interview_id, engine)
 
-        user_response = console.input("[bold green]> [/]")
+        user_response = await multiline_prompt_async("Your response")
 
         # Allow early exit
         if user_response.strip().lower() in ("done", "exit", "quit", "/done"):
@@ -460,6 +468,8 @@ async def _run_pm_interview(
             complete_result = await engine.complete_interview(state)
             if isinstance(complete_result, Result) and complete_result.is_err:
                 print_error(f"Failed to complete interview: {complete_result.error}")
+            elif isinstance(complete_result, Result):
+                state = complete_result.value
             save_result = await engine.save_state(state)
             if isinstance(save_result, Result) and save_result.is_err:
                 print_error(f"Failed to save completed state: {save_result.error}")
@@ -475,6 +485,8 @@ async def _run_pm_interview(
         if isinstance(record_result, Result) and record_result.is_err:
             print_error(f"Failed to record response: {record_result.error}")
             break
+        if isinstance(record_result, Result):
+            state = record_result.value
         save_result = await engine.save_state(state)
         if isinstance(save_result, Result) and save_result.is_err:
             print_error(f"Failed to save state: {save_result.error}")

ouroboros_ai-0.26.5.dev2/src/ouroboros/cli/formatters/prompting.py

@@ -0,0 +1,38 @@
+"""Prompt helpers for interactive CLI input."""
+
+from __future__ import annotations
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
+from prompt_toolkit.patch_stdout import patch_stdout
+
+from ouroboros.cli.formatters import console
+
+
+async def multiline_prompt_async(prompt_text: str) -> str:
+    """Get multiline-safe input while allowing logs above the active prompt."""
+    bindings = KeyBindings()
+
+    @bindings.add("c-j")
+    def insert_newline(event: KeyPressEvent) -> None:
+        event.current_buffer.insert_text("\n")
+
+    @bindings.add("c-m")
+    def submit(event: KeyPressEvent) -> None:
+        event.current_buffer.validate_and_handle()
+
+    console.print(f"[bold green]{prompt_text}[/] [dim](Enter: submit, Ctrl+J: newline)[/]")
+
+    session: PromptSession[str] = PromptSession(
+        message="> ",
+        multiline=True,
+        prompt_continuation="  ",
+        key_bindings=bindings,
+    )
+
+    # prompt_toolkit proxies both stdout and stderr above the prompt.
+    with patch_stdout(raw=True):
+        return await session.prompt_async()
+
+
+__all__ = ["multiline_prompt_async"]

ouroboros_ai-0.26.5.dev2/tests/unit/cli/formatters/test_prompting.py

@@ -0,0 +1,45 @@
+"""Tests for interactive prompt helpers."""
+
+from __future__ import annotations
+
+import sys
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from ouroboros.cli.formatters.prompting import multiline_prompt_async
+
+
+@pytest.mark.asyncio
+async def test_multiline_prompt_async_patches_stdout_and_stderr() -> None:
+    """The shared prompt helper should proxy both stdout and stderr during input."""
+    session = MagicMock()
+    session.prompt_async = AsyncMock()
+
+    async def fake_prompt_async() -> str:
+        assert sys.stdout is not sys.__stdout__
+        assert sys.stderr is not sys.__stderr__
+        return "line 1\nline 2"
+
+    session.prompt_async.side_effect = fake_prompt_async
+
+    with (
+        patch(
+            "ouroboros.cli.formatters.prompting.PromptSession", return_value=session
+        ) as mock_session,
+        patch("ouroboros.cli.formatters.prompting.console.print"),
+    ):
+        result = await multiline_prompt_async("Prompt here")
+
+    assert result == "line 1\nline 2"
+    session.prompt_async.assert_awaited_once()
+
+    kwargs = mock_session.call_args.kwargs
+    assert kwargs["message"] == "> "
+    assert kwargs["multiline"] is True
+    assert kwargs["prompt_continuation"] == "  "
+
+    key_bindings = kwargs["key_bindings"]
+    bound_keys = {tuple(binding.keys) for binding in key_bindings.bindings}
+    assert ("c-j",) in bound_keys
+    assert ("c-m",) in bound_keys

ouroboros_ai-0.26.5.dev2/tests/unit/cli/test_pm_interactive_logging.py

@@ -0,0 +1,212 @@
+"""Unit tests for interactive PM prompt behavior."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+import typer
+
+from ouroboros.bigbang.interview import InterviewRound
+from ouroboros.cli.commands.pm import _run_pm_interview, pm_command
+from ouroboros.core.types import Result
+
+
+def _build_ctx() -> MagicMock:
+    """Build a Typer context mock for direct callback testing."""
+    ctx = MagicMock()
+    ctx.invoked_subcommand = None
+    return ctx
+
+
+def _build_state(*, pending_question: str | None = None) -> SimpleNamespace:
+    """Create the minimal interview state shape used by the PM CLI."""
+    rounds = []
+    if pending_question is not None:
+        rounds.append(
+            InterviewRound(
+                round_number=1,
+                question=pending_question,
+                user_response=None,
+            )
+        )
+
+    return SimpleNamespace(
+        is_complete=False,
+        rounds=rounds,
+        current_round_number=1,
+        interview_id="interview_123",
+        mark_updated=MagicMock(),
+    )
+
+
+def test_pm_command_exits_cleanly_on_keyboard_interrupt() -> None:
+    """The PM command should surface Ctrl+C as a normal CLI exit."""
+
+    def fake_run(coro: object) -> None:
+        coro.close()  # type: ignore[union-attr]
+        raise KeyboardInterrupt
+
+    with patch("ouroboros.cli.commands.pm.asyncio.run", side_effect=fake_run):
+        with pytest.raises(typer.Exit) as exc_info:
+            pm_command(_build_ctx(), model="test-model", debug=False)
+
+    assert exc_info.value.exit_code == 0
+
+
+def test_pm_command_enables_debug_logging_when_requested() -> None:
+    """The PM debug flag should enable verbose logging for the session."""
+
+    def fake_run(coro: object) -> None:
+        coro.close()  # type: ignore[union-attr]
+
+    with (
+        patch("ouroboros.cli.commands.pm.asyncio.run", side_effect=fake_run),
+        patch("ouroboros.cli.commands.pm.configure_logging") as mock_configure,
+        patch("ouroboros.cli.commands.pm.print_info") as mock_print_info,
+    ):
+        pm_command(_build_ctx(), model="test-model", debug=True)
+
+    mock_configure.assert_called_once()
+    config = mock_configure.call_args.args[0]
+    assert config.log_level == "DEBUG"
+    messages = [call.args[0] for call in mock_print_info.call_args_list]
+    assert "Debug mode enabled - showing verbose logs" in messages
+
+
+@pytest.mark.asyncio
+async def test_run_pm_interview_new_session_uses_multiline_prompt_and_shows_progress(
+    tmp_path: Path,
+) -> None:
+    """New PM sessions should use the multiline prompt for both answers."""
+    initial_state = _build_state()
+    recorded_state = _build_state()
+    recorded_state.is_complete = True
+    engine = MagicMock()
+    engine.get_opening_question.return_value = "What do you want to build?"
+    engine.ask_opening_and_start = AsyncMock(return_value=Result.ok(initial_state))
+    engine.ask_next_question = AsyncMock(return_value=Result.ok("What is the first workflow?"))
+    engine.save_state = AsyncMock(return_value=Result.ok(tmp_path / "state.json"))
+    engine.record_response = AsyncMock(return_value=Result.ok(recorded_state))
+    engine.complete_interview = AsyncMock()
+    engine.format_decide_later_summary.return_value = ""
+
+    with (
+        patch.object(Path, "home", return_value=tmp_path),
+        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", 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=[]),
+        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",
+            side_effect=["Initial context", "Actual answer"],
+        ) as mock_prompt,
+        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)
+
+    engine.ask_opening_and_start.assert_awaited_once()
+    engine.ask_next_question.assert_awaited_once_with(initial_state)
+    assert mock_prompt.await_count == 2
+    engine.record_response.assert_awaited_once_with(
+        initial_state,
+        "Actual answer",
+        "What is the first workflow?",
+    )
+    engine.complete_interview.assert_not_called()
+    assert engine.save_state.await_args_list[-1].args[0] is recorded_state
+
+    messages = [call.args[0] for call in mock_print_info.call_args_list]
+    assert "Starting interview..." in messages
+    assert "Generating next question..." in messages
+    assert messages.index("Starting interview...") < messages.index("Generating next question...")
+
+
+@pytest.mark.asyncio
+async def test_run_pm_interview_resume_with_pending_question_skips_generation_message(
+    tmp_path: Path,
+) -> None:
+    """Resume should reuse the saved pending question instead of generating a new one."""
+    state = _build_state(pending_question="Saved question?")
+    completed_state = _build_state()
+    completed_state.is_complete = True
+    engine = MagicMock()
+    engine.load_state = AsyncMock(return_value=Result.ok(state))
+    engine.ask_next_question = AsyncMock()
+    engine.save_state = AsyncMock(return_value=Result.ok(tmp_path / "state.json"))
+    engine.complete_interview = AsyncMock(return_value=Result.ok(completed_state))
+    engine.format_decide_later_summary.return_value = ""
+    engine._install_pm_steering = MagicMock()
+
+    with (
+        patch.object(Path, "home", return_value=tmp_path),
+        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", return_value=object()),
+        patch("ouroboros.bigbang.pm_interview.PMInterviewEngine.create", return_value=engine),
+        patch("ouroboros.cli.commands.pm._save_cli_pm_meta"),
+        patch(
+            "ouroboros.cli.commands.pm.multiline_prompt_async", return_value="done"
+        ) as mock_prompt,
+        patch("ouroboros.cli.commands.pm.print_info") as mock_print_info,
+        patch("ouroboros.cli.commands.pm.print_success"),
+    ):
+        await _run_pm_interview(resume_id="resume_123", model="test-model", debug=False)
+
+    engine.ask_next_question.assert_not_awaited()
+    engine._install_pm_steering.assert_called_once()
+    mock_prompt.assert_awaited_once()
+    engine.complete_interview.assert_awaited_once_with(state)
+    assert engine.save_state.await_args_list[-1].args[0] is completed_state
+
+    messages = [call.args[0] for call in mock_print_info.call_args_list]
+    assert "Generating next question..." not in messages
+
+
+@pytest.mark.asyncio
+async def test_run_pm_interview_preserves_pending_question_across_interrupt_and_resume(
+    tmp_path: Path,
+) -> None:
+    """A saved pending question should be re-displayed after an interrupted session."""
+    interrupted_state = _build_state()
+    resumed_state = _build_state(pending_question="What is the first workflow?")
+    engine = MagicMock()
+    engine.get_opening_question.return_value = "What do you want to build?"
+    engine.ask_opening_and_start = AsyncMock(return_value=Result.ok(interrupted_state))
+    engine.ask_next_question = AsyncMock(return_value=Result.ok("What is the first workflow?"))
+    engine.save_state = AsyncMock(return_value=Result.ok(tmp_path / "state.json"))
+    engine.load_state = AsyncMock(return_value=Result.ok(resumed_state))
+    engine.complete_interview = AsyncMock(
+        return_value=Result.ok(SimpleNamespace(**{**resumed_state.__dict__, "is_complete": True}))
+    )
+    engine.format_decide_later_summary.return_value = ""
+    engine._install_pm_steering = MagicMock()
+
+    with (
+        patch.object(Path, "home", return_value=tmp_path),
+        patch("ouroboros.providers.litellm_adapter.LiteLLMAdapter", 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=[]),
+        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",
+            side_effect=["Initial context", KeyboardInterrupt, "done"],
+        ),
+        patch("ouroboros.cli.commands.pm.print_success"),
+    ):
+        with pytest.raises(KeyboardInterrupt):
+            await _run_pm_interview(resume_id=None, model="test-model", 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)
+
+    engine.ask_next_question.assert_awaited_once_with(interrupted_state)
+    engine.load_state.assert_awaited_once_with("resume_123")