refactor(commands): proxy rag.corpus-info through orchestration runtime (#24)

Phase D1 of the architecture-realignment spec, gui side. The
``rag.corpus-info`` executor body moved to attune-author in
[attune-author#17]. This change shrinks the gui registration to a
proxy CommandSpec whose executor dispatches via
``attune_author.orchestration.run_command(...)``.

New helpers in commands.py:
  _proxy_command(name)          mirror an orchestration spec into a
                                gui CommandSpec.
  _orchestration_dispatcher(n)  build a closure that converts the
                                gui JobContext to the orchestration
                                JobContext and unwraps RunResult.output.

D2 (author.* commands) and D3 (help.* commands) will reuse both.

Bumps gui to 0.6.0; pins attune-author[ai] to >=0.8.1,<0.9.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: silversurfer562

CHANGELOG.md

@@ -3,6 +3,29 @@
 All notable changes to `attune-gui` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.6.0] — 2026-05-08
+
+### Changed
+
+- **`rag.corpus-info` migrated to `attune_author.orchestration`** —
+  Phase D1 of the architecture-realignment spec. The executor body
+  now lives in attune-author; the gui keeps a thin `CommandSpec`
+  whose executor dispatches through
+  `attune_author.orchestration.run_command(...)`. `/api/commands`
+  and the job runner are unchanged from the client's perspective.
+- New helpers in `attune_gui.commands`: `_proxy_command(name)`
+  mirrors an attune-author orchestration spec into a gui
+  `CommandSpec`; `_orchestration_dispatcher(name)` builds the
+  closure that converts gui `JobContext` → orchestration
+  `JobContext` and unwraps `RunResult.output`. Phases D2 / D3 will
+  use the same helpers for the `author.*` and `help.*` migrations.
+
+### Dependencies
+
+- Bumped `attune-author[ai]` constraint from `>=0.5.0,<0.6` to
+  `>=0.8.1,<0.9` (orchestration scaffold + the moved
+  `rag.corpus-info` command).
+
 ## [0.5.4] — 2026-05-06
 
 ### Security

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "attune-gui"
-version = "0.5.4"
+version = "0.6.0"
 description = "Local dashboard for attune-rag / attune-help / attune-author. Server-rendered Jinja2 UI — ships clean via PyPI with no npm step."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -30,7 +30,7 @@ dependencies = [
     "pydantic>=2.0,<3.0",
     "structlog>=24.0,<26.0",
     "attune-rag>=0.1.12,<0.2",
-    "attune-author[ai]>=0.5.0,<0.6",
+    "attune-author[ai]>=0.8.1,<0.9",
     "attune-help>=0.10.0,<1.0",
     "jinja2>=3.1,<4.0",
     "python-frontmatter>=1.1,<2.0",

sidecar/attune_gui/commands.py

@@ -28,6 +28,59 @@
 logger = logging.getLogger(__name__)
 
 
+def _orchestration_dispatcher(orchestration_name: str) -> ExecutorFn:
+    """Build an executor that hands the call off to attune-author's orchestration runtime.
+
+    The gui keeps a thin :class:`CommandSpec` so its profile filtering,
+    job runner, and ``GET /api/commands`` continue to work with no
+    changes. The actual executor body lives in attune-author. The
+    returned closure converts the gui's :class:`JobContext` into the
+    orchestration-runtime equivalent and unwraps ``RunResult.output``
+    so the existing job runner sees a plain dict.
+    """
+
+    async def _dispatch(args: dict[str, Any], ctx: JobContext) -> Any:
+        from attune_author.orchestration import (  # noqa: PLC0415
+            JobContext as AuthorCtx,
+        )
+        from attune_author.orchestration import (
+            run_command,
+        )
+
+        author_ctx = AuthorCtx(job_id=ctx.job_id, log=ctx.log)
+        result = await run_command(orchestration_name, args, author_ctx)
+        return result.output
+
+    _dispatch.__name__ = f"_dispatch_{orchestration_name.replace('.', '_')}"
+    return _dispatch
+
+
+def _proxy_command(orchestration_name: str) -> CommandSpec:
+    """Mirror an attune-author orchestration spec into a gui ``CommandSpec``.
+
+    Importing :mod:`attune_author.orchestration.commands.<ns>` triggers
+    registration on the orchestration registry; this helper then copies
+    the metadata into a gui-shaped ``CommandSpec`` whose executor is a
+    dispatcher closure. Phases D2 and D3 will repeat this pattern for
+    each migrated command, eventually leaving this module with only
+    proxy registrations and the executors removed.
+    """
+
+    from attune_author.orchestration import COMMANDS as _AUTHOR_COMMANDS  # noqa: PLC0415
+
+    src = _AUTHOR_COMMANDS[orchestration_name]
+    return CommandSpec(
+        name=src.name,
+        title=src.title,
+        domain=src.domain,
+        description=src.description,
+        args_schema=src.args_schema,
+        executor=_orchestration_dispatcher(orchestration_name),
+        cancellable=src.cancellable,
+        profiles=src.profiles,
+    )
+
+
 def _require_absolute(field: str, raw: str) -> None:
     """Reject relative paths up-front so users see a clear error.
 
@@ -327,54 +380,15 @@ async def _exec_author_generate(args: dict[str, Any], ctx: JobContext) -> dict[s
 
 
 # ---------------------------------------------------------------------------
-# RAG: corpus-info
+# RAG: corpus-info — owned by attune-author since Phase D1 of the
+# architecture-realignment spec. Importing the orchestration command
+# module triggers registration; we mirror it into this gui registry
+# so /api/commands and the job runner stay unchanged.
 # ---------------------------------------------------------------------------
 
+import attune_author.orchestration.commands.rag  # noqa: F401, E402
 
-async def _exec_rag_corpus_info(args: dict[str, Any], ctx: JobContext) -> dict[str, Any]:
-    from attune_gui.routes.rag import _get_pipeline  # noqa: PLC0415
-    from attune_gui.workspace import get_workspace  # noqa: PLC0415
-
-    project_path_raw = str(args.get("project_path", "")).strip()
-    workspace = (
-        Path(project_path_raw).expanduser().resolve() if project_path_raw else get_workspace()
-    )
-    pipeline = _get_pipeline(workspace)
-    entries = await asyncio.to_thread(list, pipeline.corpus.entries())
-    kinds = sorted({e.path.split("/")[0] for e in entries if "/" in e.path})
-    ctx.log(f"{len(entries)} entries across {len(kinds)} kind(s)")
-    return {
-        "corpus_class": type(pipeline.corpus).__name__,
-        "entry_count": len(entries),
-        "kinds": kinds,
-    }
-
-
-COMMANDS["rag.corpus-info"] = CommandSpec(
-    name="rag.corpus-info",
-    title="Corpus info",
-    domain="rag",
-    description="Show entry count and category breakdown for the loaded attune-rag corpus.",
-    args_schema={
-        "type": "object",
-        "properties": {
-            "project_path": {
-                "type": "string",
-                "title": "Project path",
-                "default": "",
-                "description": (
-                    "Root of the project whose corpus to inspect. "
-                    "Leave blank to use the configured workspace."
-                ),
-                "ui:widget": "path",
-                "ui:browseHint": "project",
-            },
-        },
-    },
-    executor=_exec_rag_corpus_info,
-    cancellable=False,
-    profiles=("developer", "author"),
-)
+COMMANDS["rag.corpus-info"] = _proxy_command("rag.corpus-info")
 
 
 # ---------------------------------------------------------------------------

sidecar/tests/test_commands.py

@@ -25,7 +25,6 @@
     _exec_help_list,
     _exec_help_lookup,
     _exec_help_search,
-    _exec_rag_corpus_info,
     _exec_rag_query,
     _help_engine,
     _require_absolute,
@@ -250,20 +249,34 @@ async def test_query_returns_hits_and_augmented_prompt(
         assert out["augmented_prompt"] == "prompt body"
 
     @pytest.mark.asyncio
-    async def test_corpus_info_summarizes_kinds(self, ctx: FakeJobContext, tmp_path: Path) -> None:
-        entries = [
-            SimpleNamespace(path="security/concept.md"),
-            SimpleNamespace(path="security/task.md"),
-            SimpleNamespace(path="memory/concept.md"),
-        ]
-        pipeline = MagicMock()
-        pipeline.corpus.entries.return_value = iter(entries)
-        with patch("attune_gui.routes.rag._get_pipeline", return_value=pipeline):
-            out = await _exec_rag_corpus_info(
-                {"project_path": str(tmp_path)}, ctx  # type: ignore[arg-type]
+    async def test_corpus_info_dispatches_to_attune_author(
+        self, ctx: FakeJobContext, tmp_path: Path
+    ) -> None:
+        # Phase D1: rag.corpus-info now lives in attune_author.orchestration.
+        # The gui keeps a thin proxy CommandSpec; this test verifies the
+        # dispatcher converts the gui ctx, calls run_command, and returns
+        # the unwrapped output dict so the job runner sees a plain payload.
+        from attune_author.orchestration import RunResult
+
+        spec = get_command("rag.corpus-info")
+        assert spec is not None
+
+        async def fake_run_command(name, args, author_ctx):  # noqa: ARG001
+            author_ctx.log("dispatched")
+            return RunResult(
+                success=True,
+                output={"entry_count": 3, "kinds": ["memory", "security"]},
+                elapsed_ms=1,
             )
-        assert out["entry_count"] == 3
-        assert out["kinds"] == ["memory", "security"]
+
+        with patch("attune_author.orchestration.run_command", side_effect=fake_run_command):
+            out = await spec.executor(
+                {"project_path": str(tmp_path)},
+                ctx,  # type: ignore[arg-type]
+            )
+
+        assert out == {"entry_count": 3, "kinds": ["memory", "security"]}
+        assert "dispatched" in ctx.lines
 
 
 # ---------------------------------------------------------------------------