voodoo-framework 3.1.0__tar.gz → 3.2.0__tar.gz

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voodoo-framework
-Version: 3.1.0
+Version: 3.2.0
 Summary: The programmable runtime for adaptive applications and operational systems — from web and AI to distributed and physical systems.
 Author-email: Helder Perez <contact@helderperez.com>
 Maintainer-email: Helder Perez <contact@helderperez.com>
@@ -45,6 +45,8 @@ Requires-Dist: anthropic; extra == "ai"
 Requires-Dist: google-generativeai; extra == "ai"
 Requires-Dist: ollama; extra == "ai"
 Provides-Extra: mcp
+Provides-Extra: browser
+Requires-Dist: playwright; extra == "browser"
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"
@@ -142,7 +144,7 @@ Voodoo requires Python 3.12+.
 ```bash
 pip install voodoo-framework
 
-voodoo create my_app
+voodoo new my_app
 cd my_app
 voodoo dev
 ```

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/README.md

@@ -71,7 +71,7 @@ Voodoo requires Python 3.12+.
 ```bash
 pip install voodoo-framework
 
-voodoo create my_app
+voodoo new my_app
 cd my_app
 voodoo dev
 ```

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/pyproject.toml

@@ -76,6 +76,9 @@ ai = [
     "ollama"
 ]
 mcp = []
+browser = [
+    "playwright",
+]
 dev = [
     "pytest",
     "pytest-asyncio",

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/src/voodoo/__init__.py

@@ -12,7 +12,7 @@ from .core import App, page, state
 from .data import Model
 from .runtime.scheduling.tasks import task
 
-__version__ = "3.1.0"
+__version__ = "3.2.0"
 
 __all__ = [
     "Agent",

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/src/voodoo/adapters/tailwind.py

@@ -750,6 +750,34 @@ _STYLES: dict[str, Callable[[dict[str, Any], Theme], str]] = {
     "avatar": _avatar,
     "avatar.img": _avatar_img,
     "avatar.fallback": _avatar_fallback,
+    "user-badge": lambda props, theme: (
+        "inline-flex items-center gap-2 rounded-full border "
+        "border-[var(--vd-color-border)] bg-[var(--vd-color-surface)] "
+        "px-2.5 py-1 text-sm text-[var(--vd-color-text)] shadow-sm"
+    ),
+    "user-badge.avatar": lambda props, theme: (
+        "inline-flex size-7 shrink-0 items-center justify-center rounded-full "
+        "bg-[var(--vd-color-secondary)] text-xs font-semibold text-white"
+    ),
+    "user-badge.copy": lambda props, theme: "grid min-w-0 gap-0.5 text-left",
+    "user-badge.name": lambda props, theme: (
+        "truncate text-sm font-medium leading-tight"
+    ),
+    "user-badge.meta": lambda props, theme: (
+        "text-xs capitalize text-[var(--vd-color-text-muted)]"
+    ),
+    "user-badge.action": lambda props, theme: (
+        "ml-1 text-xs text-[var(--vd-color-text-muted)] no-underline "
+        "hover:text-[var(--vd-color-danger)]"
+    ),
+    "auth-guard": lambda props, theme: (
+        "p-3 text-center text-sm "
+        + (
+            "font-medium text-[var(--vd-color-danger)]"
+            if props.get("variant") == "error"
+            else "text-[var(--vd-color-text-muted)]"
+        )
+    ),
     "divider": _divider,
     "dialog": _dialog,
     "modal": _modal,

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/src/voodoo/adapters/voodoo_css.py

@@ -605,9 +605,12 @@ button, input, select, textarea {{ font: inherit; color: inherit; }}
     border: 1px solid var(--vd-color-border); background: var(--vd-color-surface);
     border-radius: {r}xl); box-shadow: {sh}lg);
     padding: {s}xl); width: 100%; max-width: 32rem;
-    margin: auto; display: flex; flex-direction: column; gap: {s}md);
-    color: var(--vd-color-text);
+    margin: auto; color: var(--vd-color-text);
+}}
+.vd-modal[open] {{
+    display: flex; flex-direction: column; gap: {s}md);
 }}
+.vd-modal:not([open]) {{ display: none; }}
 .vd-modal::backdrop {{ background: rgb(0 0 0 / 0.6); }}
 
 /* Link */
@@ -1187,8 +1190,22 @@ button, input, select, textarea {{ font: inherit; color: inherit; }}
     font-size: {t}xs); font-weight: var(--vd-weight-semibold);
     text-transform: uppercase;
 }}
-.vd-user-badge-name {{ line-height: 1; font-size: {t}sm); }}
-.vd-user-badge-meta {{ font-size: {t}xs); color: var(--vd-color-text-muted); }}
+.vd-user-badge-copy {{
+    display: grid; gap: 0.125rem; min-width: 0; text-align: left;
+}}
+.vd-user-badge-name {{
+    line-height: 1.1; font-size: {t}sm);
+    overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+}}
+.vd-user-badge-meta {{
+    font-size: {t}xs); color: var(--vd-color-text-muted);
+    text-transform: capitalize;
+}}
+.vd-user-badge-action {{
+    margin-left: {s}xs); color: var(--vd-color-text-muted);
+    font-size: {t}xs); text-decoration: none;
+}}
+.vd-user-badge-action:hover {{ color: var(--vd-color-danger); }}
 
 /* Auth guard */
 .vd-auth-guard {{

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/src/voodoo/agents/registry.py

@@ -1,7 +1,7 @@
-"""Agent registry — Protocol, in-memory, and SQLite implementations (Sprint 17).
+"""Agent registry persistence.
 
-The registry persists agent identity and links every run to its execution
-history. The default backend is SQLite (WAL mode, busy_timeout=5000).
+Voodoo Store is the canonical durable backend. SQLite remains an explicit
+compatibility adapter; the in-memory implementation is intended for tests.
 """
 
 from __future__ import annotations
@@ -16,6 +16,7 @@ from voodoo.agents.models import AgentEntity, AgentRunRecord
 __all__ = [
     "AgentRegistry",
     "InMemoryAgentRegistry",
+    "VoodooStoreAgentRegistry",
     "SQLiteAgentRegistry",
 ]
 
@@ -133,6 +134,124 @@ class InMemoryAgentRegistry:
         return len(self._runs.get(agent_id, []))
 
 
+# ---------------------------------------------------------------------------
+# Voodoo Store implementation
+# ---------------------------------------------------------------------------
+
+_AGENT_PREFIX = b"runtime:agent:entity:"
+_RUN_PREFIX = b"runtime:agent:run:"
+
+
+class VoodooStoreAgentRegistry:
+    """Durable agent registry backed by the active application RuntimeStore."""
+
+    def __init__(self) -> None:
+        from voodoo.core.errors import ConfigurationError
+        from voodoo.runtime.store import get_active_runtime_store
+
+        runtime_store = get_active_runtime_store()
+        if runtime_store is None:
+            raise ConfigurationError(
+                "Agent registry requires the active application RuntimeStore."
+            )
+        provider = runtime_store.provider or runtime_store.start()
+        native = None if provider is None else getattr(provider, "native", None)
+        if native is None:
+            raise ConfigurationError(
+                "The active Voodoo Store provider does not expose durable storage."
+            )
+        self._store = native
+
+    @staticmethod
+    def _agent_key(agent_id: str) -> bytes:
+        return _AGENT_PREFIX + agent_id.encode("utf-8")
+
+    @staticmethod
+    def _run_prefix(agent_id: str) -> bytes:
+        return _RUN_PREFIX + agent_id.encode("utf-8") + b":"
+
+    @classmethod
+    def _run_key(cls, record: AgentRunRecord) -> bytes:
+        return cls._run_prefix(record.agent_id) + (
+            f"{record.started_at:020.6f}:{record.run_id}".encode()
+        )
+
+    @staticmethod
+    def _encode(data: dict[str, Any]) -> bytes:
+        return json.dumps(data, separators=(",", ":"), default=str).encode("utf-8")
+
+    @staticmethod
+    def _decode(raw: bytes) -> dict[str, Any]:
+        return json.loads(bytes(raw).decode("utf-8"))
+
+    async def register(self, entity: AgentEntity) -> None:
+        self._store.put(
+            self._agent_key(entity.agent_id), self._encode(entity.to_dict())
+        )
+
+    async def get(self, agent_id: str) -> AgentEntity | None:
+        raw = self._store.get(self._agent_key(agent_id))
+        if raw is None:
+            return None
+        return AgentEntity.from_dict(self._decode(raw))
+
+    async def list_agents(
+        self,
+        state: str | None = None,
+        limit: int = 100,
+    ) -> list[AgentEntity]:
+        agents = [
+            AgentEntity.from_dict(self._decode(raw))
+            for _key, raw in self._store.scan_prefix(_AGENT_PREFIX)
+        ]
+        if state is not None:
+            agents = [agent for agent in agents if agent.state == state]
+        agents.sort(key=lambda agent: agent.updated_at, reverse=True)
+        return agents[:limit]
+
+    async def update(self, entity: AgentEntity) -> None:
+        if await self.get(entity.agent_id) is None:
+            raise KeyError(f"Agent '{entity.agent_id}' not found")
+        await self.register(entity)
+
+    async def delete(self, agent_id: str) -> bool:
+        if await self.get(agent_id) is None:
+            return False
+        tx = self._store.transaction()
+        tx.delete(self._agent_key(agent_id))
+        for key, _raw in tx.scan_prefix(self._run_prefix(agent_id)):
+            tx.delete(bytes(key))
+        tx.commit()
+        return True
+
+    async def record_run(self, record: AgentRunRecord) -> None:
+        self._store.put(self._run_key(record), self._encode(record.to_dict()))
+
+    async def get_runs(
+        self,
+        agent_id: str,
+        limit: int = 50,
+    ) -> list[AgentRunRecord]:
+        runs = [
+            AgentRunRecord.from_dict(self._decode(raw))
+            for _key, raw in self._store.scan_prefix(self._run_prefix(agent_id))
+        ]
+        runs.sort(key=lambda run: run.started_at, reverse=True)
+        return runs[:limit]
+
+    async def count_agents(self, state: str | None = None) -> int:
+        return len(await self.list_agents(state=state, limit=1_000_000))
+
+    async def count_runs(self, agent_id: str) -> int:
+        return sum(
+            1 for _key, _raw in self._store.scan_prefix(self._run_prefix(agent_id))
+        )
+
+    def close(self) -> None:
+        """No-op: RuntimeStore owns the shared Store lifecycle."""
+        return None
+
+
 # ---------------------------------------------------------------------------
 # SQLite implementation
 # ---------------------------------------------------------------------------

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/src/voodoo/cli/__init__.py

@@ -36,7 +36,7 @@ app = typer.Typer(
 )
 
 app.command()(new.new)
-app.command()(create.create)
+app.command("create", hidden=True)(create.create)
 app.command()(dev.dev)
 app.command()(start.start)
 app.command()(generate.generate)

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/src/voodoo/cli/agents.py

@@ -1,8 +1,4 @@
-"""voodoo agents — list and inspect registered agents.
-
-Reads from the agent registry (SQLite by default). Falls back to
-in-memory state when no durable store is available.
-"""
+"""voodoo agents — list and inspect agents from application persistence."""
 
 from __future__ import annotations
 
@@ -19,15 +15,12 @@ agents_app = typer.Typer(
 
 
 def _get_registry():
-    """Return an AgentRegistry — SQLite by default."""
-    from voodoo.agents.registry import SQLiteAgentRegistry
-    from voodoo.config import config
+    """Return the application agent registry (Voodoo Store by default)."""
+    from voodoo.cli.context import acquire_agent_registry
 
-    db_path = config.db_path.replace(":memory:", ".voodoo/state/data.db").replace(
-        "data.db", "agents.db"
-    )
     try:
-        return SQLiteAgentRegistry(db_path)
+        registry, _store_path = acquire_agent_registry()
+        return registry
     except Exception:
         return None
 

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/src/voodoo/cli/approvals.py

@@ -2,7 +2,7 @@
 
 Sprint 18: human approval is an execution state that survives process
 death. This CLI reads and decides approvals directly from the durable
-execution store (SQLite by default), so a decision can be made on any
+canonical execution store (Voodoo Store by default), so a decision can be made on any
 machine — the waiting execution resumes on whichever worker picks it up.
 
     voodoo approvals list [--pending] [--json]
@@ -34,19 +34,17 @@ approvals_app = typer.Typer(
 
 
 def _resolve_store(store_path: str | None):
-    """Return the configured execution store (SQLite by default)."""
-    from voodoo.config import config
+    """Return canonical execution storage unless a legacy path is explicit."""
+    from voodoo.cli.context import acquire_execution_store
     from voodoo.runtime.persistence import JSONFileExecutionStore
     from voodoo.storage.execution import SQLiteExecutionStore
 
-    if store_path is None:
-        store_path = os.environ.get("VOODOO_EXECUTION_STORE", config.db_path).replace(
-            ":memory:", ".voodoo/state/data.db"
-        )
-
-    if Path(store_path).suffix == ".jsonl":
-        return JSONFileExecutionStore(store_path), store_path
-    return SQLiteExecutionStore(store_path), store_path
+    explicit = store_path or os.environ.get("VOODOO_EXECUTION_STORE")
+    if explicit is None:
+        return acquire_execution_store()
+    if Path(explicit).suffix == ".jsonl":
+        return JSONFileExecutionStore(explicit), explicit
+    return SQLiteExecutionStore(explicit), explicit
 
 
 def _load_app(app_str: str | None) -> None:
@@ -76,7 +74,9 @@ def list_approvals(
         False, "--pending", help="Only show pending approvals"
     ),
     store_path: str = typer.Option(
-        None, "--store", help="Path to the execution store (SQLite by default)"
+        None,
+        "--store",
+        help="Legacy execution-store path; default uses application.vstore",
     ),
     app_str: str = typer.Option(
         None, "--app", help="App instance (e.g. main:app) to import first"
@@ -120,7 +120,9 @@ def list_approvals(
 def show_approval(
     execution_id: str = typer.Argument(..., help="Execution id of the approval"),
     store_path: str = typer.Option(
-        None, "--store", help="Path to the execution store (SQLite by default)"
+        None,
+        "--store",
+        help="Legacy execution-store path; default uses application.vstore",
     ),
     json_mode: bool = typer.Option(
         False, "--json", help="Machine-readable JSON output"
@@ -235,7 +237,9 @@ def approve_cmd(
     by: str = typer.Option("human", "--by", help="Who is approving"),
     note: str = typer.Option(None, "--note", help="Optional note"),
     store_path: str = typer.Option(
-        None, "--store", help="Path to the execution store (SQLite by default)"
+        None,
+        "--store",
+        help="Legacy execution-store path; default uses application.vstore",
     ),
     app_str: str = typer.Option(
         None, "--app", help="App instance (e.g. main:app) to import first"
@@ -262,7 +266,9 @@ def deny_cmd(
     by: str = typer.Option("human", "--by", help="Who is denying"),
     reason: str = typer.Option(None, "--reason", help="Denial reason"),
     store_path: str = typer.Option(
-        None, "--store", help="Path to the execution store (SQLite by default)"
+        None,
+        "--store",
+        help="Legacy execution-store path; default uses application.vstore",
     ),
     app_str: str = typer.Option(
         None, "--app", help="App instance (e.g. main:app) to import first"

voodoo_framework-3.2.0/src/voodoo/cli/context.py

@@ -0,0 +1,195 @@
+"""Canonical Store-first operational context for Voodoo CLI commands.
+
+CLI commands must observe the same application infrastructure contract as the
+Runtime. The default path opens exactly one application RuntimeStore and binds
+it for domain adapters; SQL adapters are resolved only when explicitly
+configured by the application.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any
+
+from voodoo.config import VoodooConfig, get_config
+from voodoo.data.store_backend import bind_runtime_store
+from voodoo.runtime.store import (
+    RuntimeStore,
+    StoreConfig,
+    activate_runtime_store,
+    bind_active_runtime_store,
+)
+
+
+@dataclass(slots=True)
+class CLIApplicationContext:
+    """Operational view of the current Voodoo application."""
+
+    config: VoodooConfig
+    runtime_store: RuntimeStore
+
+    @property
+    def store_path(self) -> str:
+        return str(self.runtime_store.config.path)
+
+    def execution_store(self):
+        """Return the configured execution store.
+
+        Voodoo Store is the default. SQLite/PostgreSQL are compatibility
+        adapters and are imported only when the user explicitly selects them.
+        """
+        provider = self.config.database.provider.strip().lower()
+        if provider == "voodoo":
+            from voodoo.storage.execution import VoodooStoreExecutionStore
+
+            return VoodooStoreExecutionStore()
+        if provider == "sqlite":
+            from voodoo.storage.execution import SQLiteExecutionStore
+
+            path = self.config.database.path or self.config.db_path
+            if not path:
+                raise RuntimeError(
+                    "database.provider='sqlite' requires database.path or VOODOO_DB_PATH"
+                )
+            return SQLiteExecutionStore(path)
+        if provider in {"postgres", "postgresql"}:
+            from voodoo.storage.execution import PostgresExecutionStore
+
+            url = self.config.database.url or self.config.db_path
+            if not url:
+                raise RuntimeError(
+                    "database.provider='postgres' requires database.url or DATABASE_URL"
+                )
+            return PostgresExecutionStore(url)
+        raise RuntimeError(
+            f"Unknown execution provider {self.config.database.provider!r}. "
+            "Use 'voodoo' (default), 'sqlite', or 'postgres'."
+        )
+
+    def schedule_store(self):
+        from voodoo.storage.scheduler import create_schedule_store
+
+        return create_schedule_store()
+
+    def object_store(self):
+        provider = self.config.objects.provider.strip().lower()
+        if provider == "voodoo":
+            from voodoo.storage.objects import VoodooStoreObjectStore
+
+            return VoodooStoreObjectStore()
+        if provider == "local":
+            from voodoo.storage.objects import LocalObjectStore
+
+            return LocalObjectStore(self.config.objects.base_dir or ".voodoo/objects")
+        if provider == "s3":
+            from voodoo.storage.objects import S3ObjectStore
+
+            return S3ObjectStore()
+        raise RuntimeError(
+            f"Unknown object provider {self.config.objects.provider!r}. "
+            "Use 'voodoo' (default), 'local', or 's3'."
+        )
+
+    def agent_registry(self):
+        provider = self.config.database.provider.strip().lower()
+        if provider == "voodoo":
+            from voodoo.agents.registry import VoodooStoreAgentRegistry
+
+            return VoodooStoreAgentRegistry()
+        if provider == "sqlite":
+            from voodoo.agents.registry import SQLiteAgentRegistry
+
+            base = self.config.database.path or self.config.db_path
+            if not base:
+                raise RuntimeError(
+                    "database.provider='sqlite' requires database.path or VOODOO_DB_PATH"
+                )
+            path = base.replace("data.db", "agents.db")
+            return SQLiteAgentRegistry(path)
+        raise RuntimeError(
+            "Agent registry currently supports the default Voodoo Store or an "
+            "explicit SQLite compatibility adapter."
+        )
+
+
+@contextmanager
+def open_application_context() -> Iterator[CLIApplicationContext]:
+    """Open the current application using the Runtime's canonical Store lifecycle."""
+    config = get_config()
+    runtime_store = activate_runtime_store(
+        StoreConfig.from_mapping(config.store.model_dump())
+    )
+    bind_runtime_store(runtime_store)
+    try:
+        yield CLIApplicationContext(config=config, runtime_store=runtime_store)
+    finally:
+        bind_runtime_store(None)
+        bind_active_runtime_store(None)
+        runtime_store.stop()
+
+
+class ManagedCLIResource:
+    """Proxy that keeps the canonical CLI application context alive."""
+
+    def __init__(self, resource: Any, context_manager: Any) -> None:
+        self._resource = resource
+        self._context_manager = context_manager
+        self._closed = False
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._resource, name)
+
+    def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        try:
+            close = getattr(self._resource, "close", None)
+            if close is not None:
+                close()
+        finally:
+            self._context_manager.__exit__(None, None, None)
+
+
+def _acquire_resource(factory: str) -> tuple[ManagedCLIResource, str]:
+    manager = open_application_context()
+    context = manager.__enter__()
+    try:
+        resource = getattr(context, factory)()
+    except Exception as exc:
+        manager.__exit__(type(exc), exc, exc.__traceback__)
+        raise
+    return ManagedCLIResource(resource, manager), context.store_path
+
+
+def acquire_execution_store() -> tuple[ManagedCLIResource, str]:
+    """Open execution persistence through the canonical application context."""
+    return _acquire_resource("execution_store")
+
+
+def acquire_schedule_store() -> tuple[ManagedCLIResource, str]:
+    """Open scheduler persistence through the canonical application context."""
+    return _acquire_resource("schedule_store")
+
+
+def acquire_object_store() -> tuple[ManagedCLIResource, str]:
+    """Open object persistence through the canonical application context."""
+    return _acquire_resource("object_store")
+
+
+def acquire_agent_registry() -> tuple[ManagedCLIResource, str]:
+    """Open the agent registry through the canonical application context."""
+    return _acquire_resource("agent_registry")
+
+
+__all__ = [
+    "CLIApplicationContext",
+    "ManagedCLIResource",
+    "open_application_context",
+    "acquire_execution_store",
+    "acquire_schedule_store",
+    "acquire_object_store",
+    "acquire_agent_registry",
+]

{voodoo_framework-3.1.0 → voodoo_framework-3.2.0}/src/voodoo/cli/dev.py

@@ -130,13 +130,14 @@ def _print_runtime_banner() -> None:
 
     # Providers
     terminal.heading("providers")
-    db_provider = cfg.database.provider.lower()
-    terminal.status("database", db_provider)
+    terminal.status("store", cfg.store.provider.lower())
+    terminal.muted(f"  {cfg.store.path}")
 
-    queue_provider = cfg.queue.provider.lower()
-    terminal.status("queue", queue_provider)
+    db_provider = cfg.database.provider.lower()
+    if db_provider != "voodoo":
+        terminal.status("database", db_provider)
 
-    # Object store
+    terminal.status("queue", cfg.queue.provider.lower())
     terminal.status("objects", cfg.objects.provider.lower())
 
     # Agent runtime
@@ -163,11 +164,7 @@ def _print_runtime_banner() -> None:
     except Exception:
         terminal.label_value("workers", "none")
 
-    # Schedules DB
-    schedule_path = Path(".voodoo/state/schedules.db")
-    if schedule_path.exists():
-        terminal.status("scheduler", "ready")
-    else:
-        terminal.status("scheduler", "will be created")
+    # Schedules share the application Store by default.
+    terminal.status("scheduler", cfg.store.provider.lower())
 
     terminal.blank()