ouroboros-ai 0.28.7.dev28__tar.gz → 0.28.7.dev34__tar.gz

{ouroboros_ai-0.28.7.dev28 → ouroboros_ai-0.28.7.dev34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ouroboros-ai
-Version: 0.28.7.dev28
+Version: 0.28.7.dev34
 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.28.7.dev28 → ouroboros_ai-0.28.7.dev34}/src/ouroboros/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.28.7.dev28'
-__version_tuple__ = version_tuple = (0, 28, 7, 'dev28')
+__version__ = version = '0.28.7.dev34'
+__version_tuple__ = version_tuple = (0, 28, 7, 'dev34')
 
 __commit_id__ = commit_id = None

{ouroboros_ai-0.28.7.dev28 → ouroboros_ai-0.28.7.dev34}/src/ouroboros/cli/commands/setup.py

@@ -30,6 +30,7 @@ from ouroboros.cli.formatters.panels import (
     print_success,
     print_warning,
 )
+from ouroboros.cli.opencode_config import find_opencode_config
 from ouroboros.persistence.brownfield import BrownfieldStore
 
 # Canonical MCP args for Claude Code uvx installs — single source of truth.
@@ -385,21 +386,13 @@ def _strip_jsonc(text: str) -> str:
 def _find_opencode_config() -> Path:
     """Locate the existing OpenCode config file, or return a default path.
 
-    OpenCode checks (in order): ``opencode.jsonc``, ``opencode.json``,
-    ``config.json`` — all inside ``~/.config/opencode/``.  On Windows
-    ``Path.home()`` resolves to ``%USERPROFILE%`` which matches the
-    ``xdg-basedir`` fallback that OpenCode uses.
-
-    Returns the first file that exists, or ``opencode.json`` as the
-    default for new installations (plain JSON is the safer default
-    since we write with ``json.dump``).
+    Delegates to :func:`ouroboros.cli.opencode_config.find_opencode_config`
+    with ``allow_default=True`` so that new installations get a sensible
+    default path (``opencode.json``) to write to.
     """
-    config_dir = Path.home() / ".config" / "opencode"
-    for name in ("opencode.jsonc", "opencode.json"):
-        candidate = config_dir / name
-        if candidate.exists():
-            return candidate
-    return config_dir / "opencode.json"
+    result = find_opencode_config(allow_default=True)
+    assert result is not None  # allow_default=True always returns a Path
+    return result
 
 
 def _ensure_opencode_mcp_entry() -> None:
@@ -500,6 +493,17 @@ def _ensure_opencode_mcp_entry() -> None:
             existing["timeout"] = 300000
         print_info("MCP server already registered — verified config.")
 
+    # Warn if we're about to overwrite a .jsonc file that contained comments.
+    if config_path.suffix == ".jsonc":
+        try:
+            original_text = config_path.read_text(encoding="utf-8")
+        except OSError:
+            original_text = ""
+        if "//" in original_text or "/*" in original_text:
+            print_warning(
+                f"Note: JSONC comments in {config_path} were removed during config update."
+            )
+
     # Write back as plain JSON.  This intentionally discards JSONC
     # comments — the same approach Claude and Codex setup use for their
     # respective config files.  A comment-preserving JSONC writer is out

{ouroboros_ai-0.28.7.dev28 → ouroboros_ai-0.28.7.dev34}/src/ouroboros/cli/commands/uninstall.py

@@ -28,6 +28,7 @@ from ouroboros.cli.formatters.panels import (
     print_success,
     print_warning,
 )
+from ouroboros.cli.opencode_config import find_opencode_config
 
 app = typer.Typer(
     name="uninstall",
@@ -182,15 +183,11 @@ def _strip_jsonc(text: str) -> str:
 def _find_opencode_config() -> Path | None:
     """Locate existing OpenCode config (``opencode.jsonc`` or ``opencode.json``).
 
-    Returns the first file that exists, or ``None`` if neither is present.
-    Mirrors the lookup order that OpenCode itself uses.
+    Delegates to :func:`ouroboros.cli.opencode_config.find_opencode_config`
+    with ``allow_default=False`` so that uninstall skips cleanly when no
+    config file exists.
     """
-    config_dir = Path.home() / ".config" / "opencode"
-    for name in ("opencode.jsonc", "opencode.json"):
-        candidate = config_dir / name
-        if candidate.exists():
-            return candidate
-    return None
+    return find_opencode_config(allow_default=False)
 
 
 def _remove_opencode_mcp(dry_run: bool) -> bool:
@@ -213,6 +210,18 @@ def _remove_opencode_mcp(dry_run: bool) -> bool:
         return True
 
     del mcp["ouroboros"]
+
+    # Warn if we're about to overwrite a .jsonc file that contained comments.
+    if config_path.suffix == ".jsonc":
+        try:
+            original_text = config_path.read_text(encoding="utf-8")
+        except OSError:
+            original_text = ""
+        if "//" in original_text or "/*" in original_text:
+            print_warning(
+                f"Note: JSONC comments in {config_path} were removed during config update."
+            )
+
     try:
         config_path.write_text(json.dumps(data, indent=2) + "\n")
     except OSError:

ouroboros_ai-0.28.7.dev34/src/ouroboros/cli/opencode_config.py

@@ -0,0 +1,39 @@
+"""Shared helpers for locating the OpenCode configuration file.
+
+Both :mod:`~ouroboros.cli.commands.setup` and
+:mod:`~ouroboros.cli.commands.uninstall` need to find the same config file;
+centralising the logic here avoids duplication and keeps the ``PermissionError``
+/ ``OSError`` guard in one place.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def find_opencode_config(*, allow_default: bool = True) -> Path | None:
+    """Locate the existing OpenCode config file.
+
+    OpenCode checks (in order): ``opencode.jsonc``, ``opencode.json`` —
+    both inside ``~/.config/opencode/``.
+
+    Args:
+        allow_default: When ``True`` (setup path), return
+            ``~/.config/opencode/opencode.json`` as a default for new
+            installations if neither file exists.  When ``False``
+            (uninstall path), return ``None`` so the caller can skip
+            cleanly when no config is present.
+
+    Returns:
+        The first existing config path, the default path (when
+        *allow_default* is ``True``), or ``None``.
+    """
+    config_dir = Path.home() / ".config" / "opencode"
+    for name in ("opencode.jsonc", "opencode.json"):
+        candidate = config_dir / name
+        try:
+            if candidate.exists():
+                return candidate
+        except OSError:
+            continue
+    return (config_dir / "opencode.json") if allow_default else None

{ouroboros_ai-0.28.7.dev28 → ouroboros_ai-0.28.7.dev34}/src/ouroboros/orchestrator/adapter.py

@@ -664,6 +664,21 @@ class AgentRuntime(Protocol):
         """Canonical backend identifier (e.g. ``"claude"``, ``"codex_cli"``)."""
         ...
 
+    @property
+    def llm_backend(self) -> str | None:
+        """LLM backend name for dependency analyzer wiring.
+
+        Added in v0.28.6. Legacy runtime implementations without this property
+        are handled via ``getattr()`` fallback at call sites - they degrade to
+        structured-only dependency analysis. New implementations SHOULD define
+        this to enable LLM-assisted dependency inference.
+
+        Returns the canonical LLM backend identifier (e.g. ``"claude"``,
+        ``"codex"``, ``"opencode"``, ``"litellm"``) used for non-runtime LLM
+        tasks, or ``None`` to fall back to ``runtime_backend``.
+        """
+        ...
+
     @property
     def working_directory(self) -> str | None:
         """Working directory for task execution, or ``None`` if unset."""
@@ -800,6 +815,10 @@ class ClaudeAgentAdapter:
     def runtime_backend(self) -> str:
         return self._runtime_handle_backend
 
+    @property
+    def llm_backend(self) -> str | None:
+        return self._runtime_handle_backend  # "claude" → resolved to "claude_code" by factory
+
     @property
     def working_directory(self) -> str | None:
         return self._cwd

{ouroboros_ai-0.28.7.dev28 → ouroboros_ai-0.28.7.dev34}/src/ouroboros/orchestrator/codex_cli_runtime.py

@@ -132,6 +132,10 @@ class CodexCliRuntime:
     def runtime_backend(self) -> str:
         return self._runtime_handle_backend
 
+    @property
+    def llm_backend(self) -> str | None:
+        return self._llm_backend
+
     @property
     def working_directory(self) -> str | None:
         return self._cwd

{ouroboros_ai-0.28.7.dev28 → ouroboros_ai-0.28.7.dev34}/src/ouroboros/orchestrator/opencode_runtime.py

@@ -217,6 +217,10 @@ class OpenCodeRuntime:
         """
         return self._runtime_handle_backend
 
+    @property
+    def llm_backend(self) -> str | None:
+        return self._llm_backend
+
     @property
     def working_directory(self) -> str | None:
         """Return the working directory used by this runtime.

{ouroboros_ai-0.28.7.dev28 → ouroboros_ai-0.28.7.dev34}/src/ouroboros/orchestrator/runner.py

@@ -575,10 +575,28 @@ class OrchestratorRunner:
         return cwd if isinstance(cwd, str) and cwd else None
 
     def _build_dependency_analyzer(self) -> DependencyAnalyzer:
-        """Create a dependency analyzer wired to the active LLM backend when available."""
+        """Create a dependency analyzer wired to the active LLM backend when available.
+
+        Legacy ``AgentRuntime`` implementations (custom runtimes, test mocks)
+        predating the ``llm_backend`` Protocol addition in v0.28.6 may not
+        define the property. We probe it via ``getattr`` and degrade to a
+        structured-only ``DependencyAnalyzer`` when the attribute is absent,
+        preserving pre-v0.28.6 behavior for downstream Protocol implementers.
+        """
         from ouroboros.orchestrator.dependency_analyzer import DependencyAnalyzer
 
-        llm_backend = getattr(self._adapter, "_llm_backend", None)
+        # Legacy-compat: adapters predating the llm_backend Protocol addition
+        # (v0.28.6) lack this attribute. Fall back to structured-only analysis
+        # rather than raising AttributeError.
+        _llm_backend_sentinel = object()
+        llm_backend = getattr(self._adapter, "llm_backend", _llm_backend_sentinel)
+        if llm_backend is _llm_backend_sentinel:
+            log.info(
+                "orchestrator.runner.dependency_analyzer.legacy_adapter_without_llm_backend",
+                adapter_type=type(self._adapter).__name__,
+            )
+            return DependencyAnalyzer()
+
         backend = (
             llm_backend
             if isinstance(llm_backend, str) and llm_backend
@@ -594,7 +612,7 @@ class OrchestratorRunner:
                 cwd=self._effective_cwd(),
                 max_turns=1,
             )
-        except Exception as exc:
+        except (RuntimeError, ImportError, ConnectionError, OSError, ValueError) as exc:
             log.warning(
                 "orchestrator.runner.dependency_analysis_llm_unavailable",
                 backend=backend,

{ouroboros_ai-0.28.7.dev28 → ouroboros_ai-0.28.7.dev34}/tests/e2e/conftest.py

@@ -272,6 +272,10 @@ class MockClaudeAgentAdapter:
     def runtime_backend(self) -> str:
         return "claude"
 
+    @property
+    def llm_backend(self) -> str | None:
+        return "claude"
+
     @property
     def working_directory(self) -> str | None:
         return None

ouroboros_ai-0.28.7.dev34/tests/unit/cli/test_opencode_config.py

@@ -0,0 +1,99 @@
+"""Unit tests for the shared opencode_config helper."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import patch
+
+from ouroboros.cli.opencode_config import find_opencode_config
+
+
+class TestFindOpencodeConfig:
+    """Tests for find_opencode_config()."""
+
+    def test_prefers_jsonc_over_json(self, tmp_path: Path) -> None:
+        """opencode.jsonc takes priority over opencode.json when both exist."""
+        config_dir = tmp_path / ".config" / "opencode"
+        config_dir.mkdir(parents=True)
+        jsonc = config_dir / "opencode.jsonc"
+        json_ = config_dir / "opencode.json"
+        jsonc.write_text("{}")
+        json_.write_text("{}")
+
+        with patch("pathlib.Path.home", return_value=tmp_path):
+            result = find_opencode_config(allow_default=True)
+
+        assert result == jsonc
+
+    def test_falls_back_to_json_when_no_jsonc(self, tmp_path: Path) -> None:
+        """Returns opencode.json when only that file exists."""
+        config_dir = tmp_path / ".config" / "opencode"
+        config_dir.mkdir(parents=True)
+        json_ = config_dir / "opencode.json"
+        json_.write_text("{}")
+
+        with patch("pathlib.Path.home", return_value=tmp_path):
+            result = find_opencode_config(allow_default=True)
+
+        assert result == json_
+
+    def test_allow_default_true_returns_default_when_missing(self, tmp_path: Path) -> None:
+        """Returns default opencode.json path when no config exists and allow_default=True."""
+        with patch("pathlib.Path.home", return_value=tmp_path):
+            result = find_opencode_config(allow_default=True)
+
+        assert result == tmp_path / ".config" / "opencode" / "opencode.json"
+        assert result is not None
+
+    def test_allow_default_false_returns_none_when_missing(self, tmp_path: Path) -> None:
+        """Returns None when no config exists and allow_default=False."""
+        with patch("pathlib.Path.home", return_value=tmp_path):
+            result = find_opencode_config(allow_default=False)
+
+        assert result is None
+
+    def test_allow_default_false_returns_existing_file(self, tmp_path: Path) -> None:
+        """Returns existing file even when allow_default=False."""
+        config_dir = tmp_path / ".config" / "opencode"
+        config_dir.mkdir(parents=True)
+        jsonc = config_dir / "opencode.jsonc"
+        jsonc.write_text("{}")
+
+        with patch("pathlib.Path.home", return_value=tmp_path):
+            result = find_opencode_config(allow_default=False)
+
+        assert result == jsonc
+
+    def test_oserror_on_candidate_is_skipped(self, tmp_path: Path) -> None:
+        """OSError on exists() check is silently skipped — fallback continues."""
+        config_dir = tmp_path / ".config" / "opencode"
+        config_dir.mkdir(parents=True)
+        json_ = config_dir / "opencode.json"
+        json_.write_text("{}")
+
+        original_exists = Path.exists
+
+        def patched_exists(self: Path) -> bool:
+            if self.name == "opencode.jsonc":
+                raise OSError("permission denied")
+            return original_exists(self)
+
+        with (
+            patch("pathlib.Path.home", return_value=tmp_path),
+            patch.object(Path, "exists", patched_exists),
+        ):
+            result = find_opencode_config(allow_default=True)
+
+        # jsonc errored, falls through to json which exists
+        assert result == json_
+
+    def test_returns_jsonc_path_type(self, tmp_path: Path) -> None:
+        """Return value is always a Path instance (not str)."""
+        config_dir = tmp_path / ".config" / "opencode"
+        config_dir.mkdir(parents=True)
+        (config_dir / "opencode.jsonc").write_text("{}")
+
+        with patch("pathlib.Path.home", return_value=tmp_path):
+            result = find_opencode_config(allow_default=True)
+
+        assert isinstance(result, Path)

{ouroboros_ai-0.28.7.dev28 → ouroboros_ai-0.28.7.dev34}/tests/unit/orchestrator/test_runner.py

@@ -1640,6 +1640,166 @@ class TestOrchestratorRunner:
             max_turns=1,
         )
 
+    def test_build_dependency_analyzer_uses_public_llm_backend_property(
+        self,
+        mock_adapter: MagicMock,
+        mock_event_store: AsyncMock,
+        mock_console: MagicMock,
+    ) -> None:
+        """_build_dependency_analyzer must use the public llm_backend property, not _llm_backend."""
+        mock_adapter.runtime_backend = "opencode"
+        mock_adapter.llm_backend = "codex"  # override via public property
+        runner = OrchestratorRunner(mock_adapter, mock_event_store, mock_console)
+
+        llm_adapter = object()
+        dependency_analyzer_cls = MagicMock()
+
+        with (
+            patch(
+                "ouroboros.orchestrator.runner.create_llm_adapter",
+                return_value=llm_adapter,
+            ) as mock_create_llm_adapter,
+            patch(
+                "ouroboros.orchestrator.dependency_analyzer.DependencyAnalyzer",
+                dependency_analyzer_cls,
+            ),
+        ):
+            analyzer = runner._build_dependency_analyzer()
+
+        assert analyzer is dependency_analyzer_cls.return_value
+        # llm_backend="codex" takes precedence over runtime_backend="opencode"
+        mock_create_llm_adapter.assert_called_once_with(
+            backend="codex",
+            permission_mode="acceptEdits",
+            cli_path=None,
+            cwd="/tmp/project",
+            max_turns=1,
+        )
+
+    def test_build_dependency_analyzer_falls_back_to_runtime_backend_when_llm_backend_none(
+        self,
+        mock_adapter: MagicMock,
+        mock_event_store: AsyncMock,
+        mock_console: MagicMock,
+    ) -> None:
+        """When llm_backend is None, runtime_backend is used as the LLM backend."""
+        mock_adapter.runtime_backend = "opencode"
+        mock_adapter.llm_backend = None
+        runner = OrchestratorRunner(mock_adapter, mock_event_store, mock_console)
+
+        llm_adapter = object()
+        dependency_analyzer_cls = MagicMock()
+
+        with (
+            patch(
+                "ouroboros.orchestrator.runner.create_llm_adapter",
+                return_value=llm_adapter,
+            ) as mock_create_llm_adapter,
+            patch(
+                "ouroboros.orchestrator.dependency_analyzer.DependencyAnalyzer",
+                dependency_analyzer_cls,
+            ),
+        ):
+            analyzer = runner._build_dependency_analyzer()
+
+        assert analyzer is dependency_analyzer_cls.return_value
+        mock_create_llm_adapter.assert_called_once_with(
+            backend="opencode",
+            permission_mode="acceptEdits",
+            cli_path=None,
+            cwd="/tmp/project",
+            max_turns=1,
+        )
+
+    def test_build_dependency_analyzer_catches_expected_exceptions(
+        self,
+        mock_adapter: MagicMock,
+        mock_event_store: AsyncMock,
+        mock_console: MagicMock,
+    ) -> None:
+        """RuntimeError from create_llm_adapter is caught and returns a no-LLM analyzer."""
+        from ouroboros.orchestrator.dependency_analyzer import DependencyAnalyzer
+
+        runner = OrchestratorRunner(mock_adapter, mock_event_store, mock_console)
+
+        with patch(
+            "ouroboros.orchestrator.runner.create_llm_adapter",
+            side_effect=RuntimeError("CLI not found"),
+        ):
+            analyzer = runner._build_dependency_analyzer()
+
+        assert isinstance(analyzer, DependencyAnalyzer)
+
+    def test_build_dependency_analyzer_does_not_catch_type_error(
+        self,
+        mock_adapter: MagicMock,
+        mock_event_store: AsyncMock,
+        mock_console: MagicMock,
+    ) -> None:
+        """TypeError from create_llm_adapter propagates uncaught (programming error)."""
+        runner = OrchestratorRunner(mock_adapter, mock_event_store, mock_console)
+
+        with (
+            patch(
+                "ouroboros.orchestrator.runner.create_llm_adapter",
+                side_effect=TypeError("unexpected keyword argument"),
+            ),
+            pytest.raises(TypeError),
+        ):
+            runner._build_dependency_analyzer()
+
+    def test_build_dependency_analyzer_does_not_catch_attribute_error(
+        self,
+        mock_adapter: MagicMock,
+        mock_event_store: AsyncMock,
+        mock_console: MagicMock,
+    ) -> None:
+        """AttributeError from create_llm_adapter propagates uncaught (programming error)."""
+        runner = OrchestratorRunner(mock_adapter, mock_event_store, mock_console)
+
+        with (
+            patch(
+                "ouroboros.orchestrator.runner.create_llm_adapter",
+                side_effect=AttributeError("object has no attribute"),
+            ),
+            pytest.raises(AttributeError),
+        ):
+            runner._build_dependency_analyzer()
+
+    def test_legacy_adapter_without_llm_backend_degrades_gracefully(
+        self,
+        mock_event_store: AsyncMock,
+        mock_console: MagicMock,
+    ) -> None:
+        """Legacy adapters predating v0.28.6 (no llm_backend attr) fall back to structured-only.
+
+        Protects downstream Protocol implementers (custom runtimes, test mocks)
+        from the v0.28.6 AgentRuntime Protocol addition. Instead of raising
+        AttributeError at the call site, _build_dependency_analyzer returns a
+        structured-only DependencyAnalyzer, preserving pre-v0.28.6 behavior.
+        """
+        from ouroboros.orchestrator.dependency_analyzer import DependencyAnalyzer
+
+        class LegacyAdapter:
+            """Pre-v0.28.6 adapter stub without llm_backend attribute."""
+
+            runtime_backend = "opencode"
+            working_directory = "/tmp/project"
+            permission_mode = "acceptEdits"
+
+        legacy_adapter = LegacyAdapter()
+        assert not hasattr(legacy_adapter, "llm_backend")
+
+        runner = OrchestratorRunner(legacy_adapter, mock_event_store, mock_console)  # type: ignore[arg-type]
+
+        with patch("ouroboros.orchestrator.runner.create_llm_adapter") as mock_create_llm_adapter:
+            analyzer = runner._build_dependency_analyzer()
+
+        # Must not attempt to wire an LLM adapter when the legacy runtime
+        # lacks llm_backend - that path is the breaking-change path.
+        mock_create_llm_adapter.assert_not_called()
+        assert isinstance(analyzer, DependencyAnalyzer)
+
     @pytest.mark.asyncio
     async def test_execute_seed_uses_inherited_runtime_handle(
         self,