mvgeos-cli 0.6.14__tar.gz

mvgeos_cli-0.6.14/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: mvgeos-cli
+Version: 0.6.14
+Summary: CLI entry point for MvgeOS
+License-Expression: MIT
+Requires-Dist: mvgeos-agent>=0.6.14
+Requires-Dist: mvgeos-core>=0.6.14
+Requires-Dist: mvgeos-provider>=0.6.14
+Requires-Dist: mvgeos-tome>=0.6.14
+Requires-Dist: mvgeos-runes>=0.6.14
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.27.1
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: click>=8.0
+Requires-Python: >=3.13

mvgeos_cli-0.6.14/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "mvgeos-cli"
+version = "0.6.14"
+description = "CLI entry point for MvgeOS"
+requires-python = ">=3.13"
+license = "MIT"
+dependencies = [
+    "mvgeos-agent>=0.6.14",
+    "mvgeos-core>=0.6.14",
+    "mvgeos-provider>=0.6.14",
+    "mvgeos-tome>=0.6.14",
+    "mvgeos-runes>=0.6.14",
+    "rich>=13.0",
+    "typer>=0.27.1",
+    "prompt-toolkit>=3.0",
+    "click>=8.0",
+]
+
+[project.scripts]
+mvgeos = "mvgeos_cli.main:main"
+
+[tool.uv.sources.mvgeos-agent]
+workspace = true
+
+[tool.uv.sources.mvgeos-core]
+workspace = true
+
+[tool.uv.sources.mvgeos-provider]
+workspace = true
+
+[tool.uv.sources.mvgeos-tome]
+workspace = true
+
+[tool.uv.sources.mvgeos-runes]
+workspace = true
+
+[tool.ruff]
+extend = "../pyproject.toml"
+
+[build-system]
+requires = ["uv_build>=0.11.2,<0.13"]
+build-backend = "uv_build"

mvgeos_cli-0.6.14/pyproject.toml.orig

@@ -0,0 +1,36 @@
+[project]
+name = "mvgeos-cli"
+version = "0.6.14"
+description = "CLI entry point for MvgeOS"
+requires-python = ">=3.13"
+license = "MIT"
+dependencies = [
+    # Explicit floors: uv_build does not substitute the workspace version, so
+    # bare names ship as unbounded Requires-Dist. Bumped in lockstep by ci.yml.
+    "mvgeos-agent>=0.6.14",
+    "mvgeos-core>=0.6.14",
+    "mvgeos-provider>=0.6.14",
+    "mvgeos-tome>=0.6.14",
+    "mvgeos-runes>=0.6.14",
+    "rich>=13.0",
+    "typer>=0.27.1",
+    "prompt-toolkit>=3.0",
+    "click>=8.0",
+]
+
+[project.scripts]
+mvgeos = "mvgeos_cli.main:main"
+
+[tool.uv.sources]
+mvgeos-agent = { workspace = true }
+mvgeos-core = { workspace = true }
+mvgeos-provider = { workspace = true }
+mvgeos-tome = { workspace = true }
+mvgeos-runes = { workspace = true }
+
+[build-system]
+requires = ["uv_build>=0.11.2,<0.13"]
+build-backend = "uv_build"
+
+[tool.ruff]
+extend = "../pyproject.toml"

mvgeos_cli-0.6.14/src/mvgeos_cli/__init__.py

@@ -0,0 +1,3 @@
+from mvgeos_core.constants import DEFAULT_MODEL
+
+__all__ = ["DEFAULT_MODEL"]

mvgeos_cli-0.6.14/src/mvgeos_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Entrypoint for python -m mvgeos_cli."""
+
+from mvgeos_cli.main import main
+
+if __name__ == "__main__":
+    main()

mvgeos_cli-0.6.14/src/mvgeos_cli/agent_factory.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+from mvgeos_agent import Mvge
+from mvgeos_agent.environment import MvgeEnvironment
+from mvgeos_agent.protocol import AgentFactory, MvgeAgent
+from mvgeos_core.constants import DEFAULT_AGENT_NAME
+from mvgeos_core.layers import agent_dir
+
+from mvgeos_cli.dynamic_commands import cli_project_dir
+
+_global_default_factory: AgentFactory | None = None
+
+
+def validate_api_key(api_key: str, model_id: str | None = None) -> None:
+    """Validate API key format. Raises ValueError if invalid."""
+    if model_id and model_id.startswith("ollama/"):
+        return
+    if api_key.startswith("sk-or-") or api_key.startswith("AIza"):
+        return
+    if model_id and model_id.startswith("google/") and api_key.strip():
+        return
+    if not api_key:
+        raise ValueError("API key is required.")
+    raise ValueError(
+        "Invalid API key format. OpenRouter keys start with 'sk-or-', "
+        "and Google keys start with 'AIza'."
+    )
+
+
+def default_agent_factory(
+    *,
+    api_key: str = "",
+    name: str = DEFAULT_AGENT_NAME,
+    custom_system_prompt: str = "",
+    extension_dir: str | None = None,
+    tome_dir: Path | None = None,
+    tome_resume: str | None = None,
+    provider_name: str | None = None,
+    environment: MvgeEnvironment | None = None,
+    strict_resume: bool = False,
+    force_fork_resume: bool = False,
+    **kwargs: Any,
+) -> MvgeAgent:
+    """Default agent factory using Mvge."""
+    resolved_name = name
+    if resolved_name == DEFAULT_AGENT_NAME and agent_dir("coding_mvge").is_dir():
+        resolved_name = "coding_mvge"
+
+    return Mvge(
+        api_key=api_key or None,
+        name=resolved_name,
+        spells=kwargs.get("spells"),
+        custom_system_prompt=custom_system_prompt,
+        extension_dir=extension_dir,
+        tome_dir=tome_dir,
+        tome_resume=tome_resume,
+        provider_name=provider_name,
+        environment=environment,
+        strict_resume=strict_resume,
+        force_fork_resume=force_fork_resume,
+        provider_registry=kwargs.get("provider_registry"),
+    )
+
+
+def get_default_agent_factory() -> AgentFactory:
+    """Return the currently registered default agent factory."""
+    return _global_default_factory or default_agent_factory
+
+
+def set_default_agent_factory(factory: AgentFactory | None) -> None:
+    """Set or reset the global default agent factory."""
+    global _global_default_factory
+    _global_default_factory = factory
+
+
+def resolve_agent_factory(agent_factory: AgentFactory | None = None) -> AgentFactory:
+    """Resolve an agent factory, falling back to registered default."""
+    return agent_factory or get_default_agent_factory()
+
+
+async def create_agent(
+    model: str = "",
+    api_key: str = "",
+    spells: str | Sequence[str] | None = None,
+    extension_dir: str | None = None,
+    tome_dir: str | None = None,
+    resume: str | None = None,
+    provider: str | None = None,
+    temperature: float = 0.7,
+    max_tokens: int = 4096,
+    contemplation: str = "medium",
+    agent_name: str = DEFAULT_AGENT_NAME,
+    agent_factory: AgentFactory | None = None,
+    **kwargs: Any,
+) -> MvgeAgent:
+    """Resolve environment, create an agent via factory, and initialize it."""
+    if api_key or (model and not model.startswith("ollama/")):
+        validate_api_key(api_key, model_id=model)
+    spells_list: list[str] | None = None
+    if isinstance(spells, str):
+        spells_list = [s.strip() for s in spells.split(",") if s.strip()]
+    elif isinstance(spells, Sequence):
+        spells_list = list(spells)
+
+    overrides: dict[str, Any] = {}
+    if model:
+        overrides["model"] = model
+    if temperature is not None:
+        overrides["temperature"] = temperature
+    if max_tokens is not None:
+        overrides["max_tokens"] = max_tokens
+    if contemplation:
+        overrides["contemplation_level"] = contemplation
+
+    env = MvgeEnvironment.resolve(
+        agent_name,
+        extension_dir=extension_dir,
+        overrides=overrides if overrides else None,
+        project_dir=cli_project_dir(),
+    )
+    factory = resolve_agent_factory(agent_factory)
+    factory_kwargs: dict[str, Any] = {
+        "api_key": api_key,
+        "name": agent_name,
+        "model": model,
+        "extension_dir": extension_dir,
+        "tome_dir": Path(tome_dir) if tome_dir else None,
+        "tome_resume": resume,
+        "provider_name": provider,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "contemplation": contemplation,
+        "environment": env,
+        **kwargs,
+    }
+    if spells_list is not None:
+        factory_kwargs["spells"] = spells_list
+
+    agent = factory(**factory_kwargs)
+    await agent.initialize()
+    return agent

mvgeos_cli-0.6.14/src/mvgeos_cli/approval_binding.py

@@ -0,0 +1,145 @@
+"""Host-side bind/unbind adapter for the Approval Rune presenter slot.
+
+Canonical engine slot shape (``RuneRunner`` in ``mvgeos_runes``; this
+adapter duck-types against it)::
+
+    runner.set_approval_presenter(presenter) -> None
+    runner.clear_approval_presenter() -> None
+
+where ``presenter`` satisfies ``mvgeos_core.approval.ApprovalPresenter``
+(``await presenter(request)``). Binding is host-privileged: only the host
+(CLI/GUI) calls the setter. It is never exposed through ``RuneAPI`` —
+otherwise any rune could install an auto-approver. With no presenter
+bound, the rune's ``request_approval`` denies (fail closed).
+
+Also carries the one-run ``--approval-mode`` helpers: the flag is never
+persisted, and a warning prints before channeling begins whenever it is
+explicitly set to a non-deny value. Environment variables never grant
+approval and are not consulted here.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager, suppress
+from typing import Any
+
+from mvgeos_cli.approval_types import ApprovalMode, ApprovalPresenter
+
+__all__ = [
+    "NO_SLOT_WARNING",
+    "approval_mode_notice",
+    "approval_presenter_bound",
+    "bind_approval_presenter",
+    "resolve_approval_mode",
+    "unbind_approval_presenter",
+]
+
+#: Warned when the engine runner has no approval slot yet. Execution stays
+#: fail-closed: with no presenter bound the rune denies gated casts.
+NO_SLOT_WARNING = (
+    "Approval presenter could not bind: the engine runner has no approval "
+    "slot. Gated spell casts will be denied."
+)
+
+_VALID_MODES: tuple[ApprovalMode, ...] = ("deny", "prompt", "allow-all")
+
+
+def resolve_approval_mode(value: str | None) -> ApprovalMode:
+    """Resolve the one-run ``--approval-mode`` flag value.
+
+    ``None`` (flag not passed) means ``"prompt"``: the spec default is prompt
+    on a TTY and deny without one, and the presenter itself denies when
+    there is no terminal. Unknown values are a loud error, never a guess.
+    """
+    if value is None:
+        return "prompt"
+    if value in _VALID_MODES:
+        return value
+    raise ValueError(
+        f"Unknown approval mode: {value!r} (expected one of: {', '.join(_VALID_MODES)})"
+    )
+
+
+def approval_mode_notice(mode: ApprovalMode) -> str | None:
+    """Human-readable notice for an explicitly set approval mode.
+
+    Printed before channeling begins. Always returns a line for explicit
+    modes so the Summoner sees what the run will do.
+    """
+    if mode == "allow-all":
+        return (
+            "WARNING: --approval-mode=allow-all: every mutating spell cast "
+            "will be approved automatically for this run only. "
+            "This is never persisted."
+        )
+    if mode == "deny":
+        return "Approval mode: deny. All gated spell casts will be denied for this run."
+    return (
+        "Approval mode: prompt. Each mutating spell cast asks for approval; "
+        "without a terminal, casts are denied."
+    )
+
+
+def bind_approval_presenter(runner: Any, presenter: ApprovalPresenter) -> bool:
+    """Bind ``presenter`` to the engine-owned runner's approval slot.
+
+    Returns True when bound. Returns False (no raise) when the runner has
+    no slot yet; the caller warns and execution stays fail-closed because
+    the rune denies with no presenter bound.
+    """
+    setter = getattr(runner, "set_approval_presenter", None)
+    if not callable(setter):
+        return False
+    setter(presenter)
+    return True
+
+
+def unbind_approval_presenter(
+    runner: Any, presenter: ApprovalPresenter | None = None
+) -> bool:
+    """Unbind the presenter, resolving pending requests as denied.
+
+    Closes ``presenter`` when given (its ``close()`` denies all further
+    requests) before clearing the slot; the engine also fails every
+    in-flight approval as denied when the slot changes. Returns True when
+    a slot was present, False otherwise.
+    """
+    clearer = getattr(runner, "clear_approval_presenter", None)
+    setter = getattr(runner, "set_approval_presenter", None)
+    if not callable(clearer):
+        if not callable(setter):
+            return False
+        # Legacy slot without clear: None-ing the setter is best-effort.
+        if presenter is not None:
+            close = getattr(presenter, "close", None)
+            if callable(close):
+                with suppress(Exception):
+                    close()
+        with suppress(Exception):
+            setter(None)
+        return True
+    if presenter is not None:
+        close = getattr(presenter, "close", None)
+        if callable(close):
+            with suppress(Exception):
+                close()
+    clearer()
+    return True
+
+
+@contextmanager
+def approval_presenter_bound(
+    runner: Any, presenter: ApprovalPresenter
+) -> Iterator[bool]:
+    """Bind the presenter for the wrapped run; unbind on exit.
+
+    Yields True when the presenter was bound, False when the runner has no
+    approval slot (execution stays fail-closed). Unbinds even on error.
+    """
+    bound = bind_approval_presenter(runner, presenter)
+    try:
+        yield bound
+    finally:
+        if bound:
+            unbind_approval_presenter(runner, presenter)