voidx 1.0.0__py3-none-any.whl

voidx/memory/session.py

@@ -0,0 +1,272 @@
+"""Session manager — CRUD, message persistence, auto-titling.
+
+Inspired by opencode's session system: typed Info, create/fork/remove,
+timestamp-based listing, message hydration.
+"""
+
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime, timezone
+
+from pydantic import BaseModel, Field
+
+from voidx.memory.store import _execute_commit, _fetch_all, _fetch_one
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _uid() -> str:
+    return uuid.uuid4().hex[:12]
+
+
+# ── models ──────────────────────────────────────────────────────────────
+
+class SessionInfo(BaseModel):
+    id: str
+    title: str = "New session"
+    workspace: str = "."
+    model_provider: str = "anthropic"
+    model_name: str = "claude-sonnet-4-6"
+    created_at: str = Field(default_factory=_now)
+    updated_at: str = Field(default_factory=_now)
+    message_count: int = 0
+
+
+class MessageRow(BaseModel):
+    id: int | None = None  # auto-increment
+    session_id: str
+    role: str  # system | user | assistant | tool
+    content: str = ""
+    content_format: str = "text"  # "text" | "structured" (e.g. DeepSeek thinking blocks)
+    tool_calls: list[dict] | None = None
+    tool_call_id: str | None = None
+    created_at: str = Field(default_factory=_now)
+
+
+# ── session CRUD ────────────────────────────────────────────────────────
+
+async def create_session(
+    workspace: str = ".",
+    provider: str = "anthropic",
+    model: str = "claude-sonnet-4-6",
+) -> SessionInfo:
+    sid = _uid()
+    now = _now()
+    await _execute_commit(
+        """INSERT INTO sessions (id, title, workspace, model_provider, model_name, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)""",
+        (sid, "New session", workspace, provider, model, now, now),
+    )
+    return SessionInfo(
+        id=sid, workspace=workspace, model_provider=provider,
+        model_name=model, created_at=now, updated_at=now,
+    )
+
+
+async def get_session(session_id: str) -> SessionInfo | None:
+    row = await _fetch_one(
+        "SELECT * FROM sessions WHERE id = ?", (session_id,)
+    )
+    if not row:
+        return None
+    count_row = await _fetch_one(
+        "SELECT COUNT(*) as cnt FROM messages WHERE session_id = ?",
+        (session_id,),
+    )
+    return SessionInfo(
+        id=row["id"], title=row["title"], workspace=row["workspace"],
+        model_provider=row["model_provider"], model_name=row["model_name"],
+        created_at=row["created_at"], updated_at=row["updated_at"],
+        message_count=count_row["cnt"] if count_row else 0,
+    )
+
+
+async def list_sessions(limit: int = 50) -> list[SessionInfo]:
+    rows = await _fetch_all(
+        """SELECT s.*, COUNT(m.id) as cnt
+           FROM sessions s
+           LEFT JOIN messages m ON s.id = m.session_id
+           GROUP BY s.id
+           ORDER BY s.updated_at DESC
+           LIMIT ?""",
+        (limit,),
+    )
+    return [
+        SessionInfo(
+            id=row["id"], title=row["title"], workspace=row["workspace"],
+            model_provider=row["model_provider"], model_name=row["model_name"],
+            created_at=row["created_at"], updated_at=row["updated_at"],
+            message_count=row["cnt"] or 0,
+        )
+        for row in rows
+    ]
+
+
+async def latest_session_for_workspace(workspace: str) -> SessionInfo | None:
+    row = await _fetch_one(
+        """SELECT s.*, COUNT(m.id) as cnt
+           FROM sessions s
+           LEFT JOIN messages m ON s.id = m.session_id
+           WHERE s.workspace = ?
+           GROUP BY s.id
+           ORDER BY s.updated_at DESC
+           LIMIT 1""",
+        (workspace,),
+    )
+    if not row:
+        return None
+    return SessionInfo(
+        id=row["id"], title=row["title"], workspace=row["workspace"],
+        model_provider=row["model_provider"], model_name=row["model_name"],
+        created_at=row["created_at"], updated_at=row["updated_at"],
+        message_count=row["cnt"] or 0,
+    )
+
+
+async def update_title(session_id: str, title: str) -> None:
+    await _execute_commit(
+        "UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?",
+        (title, _now(), session_id),
+    )
+
+
+async def update_session_model(session_id: str, provider: str, model: str) -> None:
+    await _execute_commit(
+        "UPDATE sessions SET model_provider = ?, model_name = ?, updated_at = ? WHERE id = ?",
+        (provider, model, _now(), session_id),
+    )
+
+
+async def touch_session(session_id: str) -> None:
+    await _execute_commit(
+        "UPDATE sessions SET updated_at = ? WHERE id = ?",
+        (_now(), session_id),
+    )
+
+
+async def delete_session(session_id: str) -> None:
+    await _execute_commit("DELETE FROM context_frames WHERE session_id = ?", (session_id,))
+    await _execute_commit("DELETE FROM message_runtime_snapshots WHERE session_id = ?", (session_id,))
+    await _execute_commit("DELETE FROM session_task_runs WHERE session_id = ?", (session_id,))
+    await _execute_commit("DELETE FROM session_runtime_state WHERE session_id = ?", (session_id,))
+    await _execute_commit("DELETE FROM transcript_nodes WHERE session_id = ?", (session_id,))
+    await _execute_commit("DELETE FROM turns WHERE session_id = ?", (session_id,))
+    await _execute_commit("DELETE FROM messages WHERE session_id = ?", (session_id,))
+    await _execute_commit("DELETE FROM sessions WHERE id = ?", (session_id,))
+
+
+# ── message persistence ─────────────────────────────────────────────────
+
+async def save_message(msg: MessageRow) -> int:
+    """Save a message row. Returns the auto-generated id."""
+    cur = await _execute_commit(
+        """INSERT INTO messages (session_id, role, content, content_format, tool_calls, tool_call_id, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)""",
+        (
+            msg.session_id,
+            msg.role,
+            msg.content,
+            msg.content_format,
+            json.dumps(msg.tool_calls) if msg.tool_calls else None,
+            msg.tool_call_id,
+            msg.created_at,
+        ),
+    )
+    return cur.lastrowid
+
+
+async def load_messages(session_id: str) -> list[MessageRow]:
+    """Load all messages for a session, ordered by id."""
+    rows = await _fetch_all(
+        "SELECT * FROM messages WHERE session_id = ? ORDER BY id ASC",
+        (session_id,),
+    )
+    return [
+        MessageRow(
+            id=row["id"],
+            session_id=row["session_id"],
+            role=row["role"],
+            content=row["content"],
+            content_format=row["content_format"] if "content_format" in row.keys() else "text",
+            tool_calls=json.loads(row["tool_calls"]) if row["tool_calls"] else None,
+            tool_call_id=row["tool_call_id"],
+            created_at=row["created_at"],
+        )
+        for row in rows
+    ]
+
+
+async def clear_messages(session_id: str) -> None:
+    await _execute_commit(
+        "DELETE FROM context_frames WHERE session_id = ?", (session_id,)
+    )
+    await _execute_commit(
+        "DELETE FROM message_runtime_snapshots WHERE session_id = ?", (session_id,)
+    )
+    await _execute_commit(
+        "DELETE FROM transcript_nodes WHERE session_id = ?", (session_id,)
+    )
+    await _execute_commit(
+        "DELETE FROM turns WHERE session_id = ?", (session_id,)
+    )
+    await _execute_commit(
+        "DELETE FROM messages WHERE session_id = ?", (session_id,)
+    )
+
+
+async def delete_messages_from(session_id: str, first_message_id: int) -> None:
+    await _execute_commit(
+        "DELETE FROM context_frames WHERE session_id = ? AND user_message_id >= ?",
+        (session_id, first_message_id),
+    )
+    await _execute_commit(
+        "DELETE FROM message_runtime_snapshots WHERE session_id = ? AND message_id >= ?",
+        (session_id, first_message_id),
+    )
+    await _execute_commit(
+        "DELETE FROM messages WHERE session_id = ? AND id >= ?",
+        (session_id, first_message_id),
+    )
+    await touch_session(session_id)
+
+
+async def delete_messages_through(session_id: str, last_message_id: int) -> None:
+    await _execute_commit(
+        "DELETE FROM context_frames WHERE session_id = ? AND user_message_id <= ?",
+        (session_id, last_message_id),
+    )
+    await _execute_commit(
+        "DELETE FROM message_runtime_snapshots WHERE session_id = ? AND message_id <= ?",
+        (session_id, last_message_id),
+    )
+    await _execute_commit(
+        "DELETE FROM messages WHERE session_id = ? AND id <= ?",
+        (session_id, last_message_id),
+    )
+    await touch_session(session_id)
+
+
+async def last_messages(session_id: str, n: int = 20) -> list[MessageRow]:
+    """Last N messages for a session."""
+    rows = await _fetch_all(
+        "SELECT * FROM messages WHERE session_id = ? ORDER BY id DESC LIMIT ?",
+        (session_id, n),
+    )
+    rows = list(reversed(rows))
+    return [
+        MessageRow(
+            id=row["id"],
+            session_id=row["session_id"],
+            role=row["role"],
+            content=row["content"],
+            content_format=row["content_format"] if "content_format" in row.keys() else "text",
+            tool_calls=json.loads(row["tool_calls"]) if row["tool_calls"] else None,
+            tool_call_id=row["tool_call_id"],
+            created_at=row["created_at"],
+        )
+        for row in rows
+    ]

voidx/memory/store.py

@@ -0,0 +1,245 @@
+"""SQLite persistence layer — async-safe via asyncio.to_thread()."""
+
+from __future__ import annotations
+
+import asyncio
+import sqlite3
+import threading
+from pathlib import Path
+from typing import Callable, TypeVar
+
+DATA_DIR = Path.home() / ".voidx"
+
+_conn: sqlite3.Connection | None = None
+_init_lock = threading.Lock()
+_write_lock = threading.Lock()
+T = TypeVar("T")
+
+
+def _get_db() -> sqlite3.Connection:
+    global _conn
+    if _conn is not None:
+        return _conn
+    with _init_lock:
+        if _conn is not None:
+            return _conn
+        DATA_DIR.mkdir(parents=True, exist_ok=True)
+        db_path = DATA_DIR / "voidx.db"
+        conn = sqlite3.connect(str(db_path), check_same_thread=False)
+        conn.row_factory = sqlite3.Row
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA foreign_keys=ON")
+        _init_schema(conn)
+        _conn = conn
+        return _conn
+
+
+def _init_schema(conn: sqlite3.Connection) -> None:
+    conn.executescript("""
+        CREATE TABLE IF NOT EXISTS sessions (
+            id TEXT PRIMARY KEY,
+            title TEXT NOT NULL DEFAULT 'New session',
+            workspace TEXT NOT NULL DEFAULT '.',
+            model_provider TEXT NOT NULL DEFAULT 'anthropic',
+            model_name TEXT NOT NULL DEFAULT 'claude-sonnet-4-6',
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            role TEXT NOT NULL CHECK(role IN ('system', 'user', 'assistant', 'tool')),
+            content TEXT NOT NULL DEFAULT '',
+            tool_calls TEXT,
+            tool_call_id TEXT,
+            created_at TEXT NOT NULL,
+            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_messages_session
+            ON messages(session_id, id);
+
+        CREATE TABLE IF NOT EXISTS turns (
+            session_id TEXT NOT NULL,
+            turn_id INTEGER NOT NULL,
+            user_message_id INTEGER,
+            created_at TEXT NOT NULL,
+            completed_at TEXT,
+            PRIMARY KEY (session_id, turn_id),
+            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE,
+            FOREIGN KEY (user_message_id) REFERENCES messages(id) ON DELETE SET NULL
+        );
+
+        CREATE TABLE IF NOT EXISTS transcript_nodes (
+            session_id TEXT NOT NULL,
+            turn_id INTEGER NOT NULL,
+            node_id INTEGER NOT NULL,
+            parent_node_id INTEGER,
+            sort_order INTEGER NOT NULL,
+            node_type TEXT NOT NULL,
+            header TEXT NOT NULL DEFAULT '',
+            body_json TEXT NOT NULL DEFAULT '[]',
+            status TEXT NOT NULL DEFAULT 'running',
+            collapsed INTEGER NOT NULL DEFAULT 0,
+            elapsed REAL,
+            message_id INTEGER,
+            tool_call_id TEXT,
+            agent_run_id TEXT,
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            PRIMARY KEY (session_id, turn_id, node_id),
+            FOREIGN KEY (session_id, turn_id) REFERENCES turns(session_id, turn_id) ON DELETE CASCADE,
+            FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE SET NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_transcript_nodes_session
+            ON transcript_nodes(session_id, turn_id, sort_order);
+
+        CREATE TABLE IF NOT EXISTS session_runtime_state (
+            session_id TEXT PRIMARY KEY,
+            interaction_mode TEXT NOT NULL DEFAULT 'auto',
+            current_intent TEXT NOT NULL DEFAULT 'chat',
+            previous_intent TEXT,
+            current_goal TEXT NOT NULL DEFAULT '',
+            awaiting_implementation_approval INTEGER NOT NULL DEFAULT 0,
+            approved_scope TEXT NOT NULL DEFAULT '',
+            last_plan_summary TEXT NOT NULL DEFAULT '',
+            compaction_summary TEXT NOT NULL DEFAULT '',
+            updated_at TEXT NOT NULL,
+            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+        );
+
+        CREATE TABLE IF NOT EXISTS session_task_runs (
+            session_id TEXT PRIMARY KEY,
+            goal TEXT NOT NULL DEFAULT '',
+            phase TEXT NOT NULL DEFAULT 'clarify',
+            status TEXT NOT NULL DEFAULT 'idle',
+            approved_scope TEXT NOT NULL DEFAULT '',
+            awaiting_implementation_approval INTEGER NOT NULL DEFAULT 0,
+            turn_count INTEGER NOT NULL DEFAULT 0,
+            updated_at TEXT NOT NULL,
+            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+        );
+
+        CREATE TABLE IF NOT EXISTS message_runtime_snapshots (
+            message_id INTEGER PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            interaction_mode TEXT NOT NULL DEFAULT 'auto',
+            task_intent TEXT NOT NULL DEFAULT 'chat',
+            implementation_allowed INTEGER NOT NULL DEFAULT 0,
+            intent_resolution_reason TEXT NOT NULL DEFAULT '',
+            goal TEXT NOT NULL DEFAULT '',
+            goal_phase TEXT NOT NULL DEFAULT 'clarify',
+            goal_status TEXT NOT NULL DEFAULT 'idle',
+            goal_turn_count INTEGER NOT NULL DEFAULT 0,
+            awaiting_implementation_approval INTEGER NOT NULL DEFAULT 0,
+            approved_scope TEXT NOT NULL DEFAULT '',
+            created_at TEXT NOT NULL,
+            FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE,
+            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_message_runtime_snapshots_session
+            ON message_runtime_snapshots(session_id, message_id);
+
+        CREATE TABLE IF NOT EXISTS context_frames (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            user_message_id INTEGER,
+            frame_kind TEXT NOT NULL DEFAULT 'main',
+            agent_role TEXT NOT NULL DEFAULT 'orchestrator',
+            provider TEXT NOT NULL,
+            model TEXT NOT NULL,
+            prefix_hash TEXT NOT NULL,
+            frame_hash TEXT NOT NULL,
+            message_count INTEGER NOT NULL,
+            token_estimate INTEGER NOT NULL DEFAULT 0,
+            messages_json TEXT NOT NULL,
+            metadata_json TEXT NOT NULL DEFAULT '{}',
+            created_at TEXT NOT NULL,
+            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE,
+            FOREIGN KEY (user_message_id) REFERENCES messages(id) ON DELETE SET NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_context_frames_session
+            ON context_frames(session_id, id);
+
+        CREATE INDEX IF NOT EXISTS idx_context_frames_prefix
+            ON context_frames(session_id, prefix_hash);
+
+        CREATE TABLE IF NOT EXISTS model_profiles (
+            name TEXT PRIMARY KEY,
+            provider TEXT NOT NULL,
+            model TEXT NOT NULL,
+            api_key TEXT NOT NULL DEFAULT '',
+            base_url TEXT,
+            protocol TEXT,
+            reasoning_effort TEXT,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_model_profiles_provider
+            ON model_profiles(provider);
+    """)
+    # Migration: add content_format column for existing SQLite stores.
+    try:
+        conn.execute(
+            "ALTER TABLE messages ADD COLUMN content_format TEXT NOT NULL DEFAULT 'text'"
+        )
+    except sqlite3.OperationalError:
+        pass
+    try:
+        conn.execute(
+            "ALTER TABLE session_runtime_state ADD COLUMN compaction_summary TEXT NOT NULL DEFAULT ''"
+        )
+    except sqlite3.OperationalError:
+        pass
+
+
+async def _execute(sql: str, params: tuple = ()) -> sqlite3.Cursor:
+    def _run():
+        conn = _get_db()
+        return conn.execute(sql, params)
+    return await asyncio.to_thread(_run)
+
+
+async def _execute_commit(sql: str, params: tuple = ()) -> sqlite3.Cursor:
+    def _run():
+        conn = _get_db()
+        with _write_lock:
+            cur = conn.execute(sql, params)
+            conn.commit()
+        return cur
+    return await asyncio.to_thread(_run)
+
+
+async def _fetch_all(sql: str, params: tuple = ()) -> list[sqlite3.Row]:
+    def _run():
+        conn = _get_db()
+        return conn.execute(sql, params).fetchall()
+    return await asyncio.to_thread(_run)
+
+
+async def _fetch_one(sql: str, params: tuple = ()) -> sqlite3.Row | None:
+    def _run():
+        conn = _get_db()
+        return conn.execute(sql, params).fetchone()
+    return await asyncio.to_thread(_run)
+
+
+async def _write_transaction(callback: Callable[[sqlite3.Connection], T]) -> T:
+    def _run() -> T:
+        conn = _get_db()
+        with _write_lock:
+            try:
+                result = callback(conn)
+                conn.commit()
+                return result
+            except Exception:
+                conn.rollback()
+                raise
+
+    return await asyncio.to_thread(_run)

voidx/memory/transcript.py

@@ -0,0 +1,137 @@
+"""Persisted UI transcript rows for restoring terminal output trees."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from voidx.memory.store import _fetch_all, _write_transaction
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class TranscriptTurnRow(BaseModel):
+    session_id: str
+    turn_id: int
+    user_message_id: int | None = None
+    created_at: str = Field(default_factory=_now)
+    completed_at: str | None = None
+
+
+class TranscriptNodeRow(BaseModel):
+    session_id: str
+    turn_id: int
+    node_id: int
+    parent_node_id: int | None = None
+    sort_order: int
+    node_type: str
+    header: str = ""
+    body_lines: list[str] = Field(default_factory=list)
+    status: str = "running"
+    collapsed: bool = False
+    elapsed: float | None = None
+    message_id: int | None = None
+    tool_call_id: str | None = None
+    agent_run_id: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    created_at: str = Field(default_factory=_now)
+    updated_at: str = Field(default_factory=_now)
+
+
+async def replace_transcript(
+    session_id: str,
+    nodes: list[TranscriptNodeRow],
+    *,
+    turn_count: int | None = None,
+) -> None:
+    """Replace a session transcript snapshot atomically."""
+    now = _now()
+    if turn_count is None:
+        turn_ids = sorted({node.turn_id for node in nodes})
+    else:
+        turn_ids = list(range(turn_count))
+
+    def _run(conn):
+        conn.execute("DELETE FROM transcript_nodes WHERE session_id = ?", (session_id,))
+        conn.execute("DELETE FROM turns WHERE session_id = ?", (session_id,))
+        for turn_id in turn_ids:
+            conn.execute(
+                """INSERT INTO turns (session_id, turn_id, created_at, completed_at)
+                   VALUES (?, ?, ?, ?)""",
+                (session_id, turn_id, now, now),
+            )
+        for node in nodes:
+            conn.execute(
+                """INSERT INTO transcript_nodes (
+                       session_id, turn_id, node_id, parent_node_id, sort_order,
+                       node_type, header, body_json, status, collapsed, elapsed,
+                       message_id, tool_call_id, agent_run_id, metadata_json,
+                       created_at, updated_at
+                   )
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                (
+                    session_id,
+                    node.turn_id,
+                    node.node_id,
+                    node.parent_node_id,
+                    node.sort_order,
+                    node.node_type,
+                    node.header,
+                    json.dumps(node.body_lines, ensure_ascii=False),
+                    node.status,
+                    1 if node.collapsed else 0,
+                    node.elapsed,
+                    node.message_id,
+                    node.tool_call_id,
+                    node.agent_run_id,
+                    json.dumps(node.metadata, ensure_ascii=False),
+                    node.created_at,
+                    node.updated_at,
+                ),
+            )
+
+    await _write_transaction(_run)
+
+
+async def load_transcript(session_id: str) -> list[TranscriptNodeRow]:
+    rows = await _fetch_all(
+        """SELECT * FROM transcript_nodes
+           WHERE session_id = ?
+           ORDER BY turn_id ASC, sort_order ASC, node_id ASC""",
+        (session_id,),
+    )
+    return [
+        TranscriptNodeRow(
+            session_id=row["session_id"],
+            turn_id=row["turn_id"],
+            node_id=row["node_id"],
+            parent_node_id=row["parent_node_id"],
+            sort_order=row["sort_order"],
+            node_type=row["node_type"],
+            header=row["header"],
+            body_lines=json.loads(row["body_json"] or "[]"),
+            status=row["status"],
+            collapsed=bool(row["collapsed"]),
+            elapsed=row["elapsed"],
+            message_id=row["message_id"],
+            tool_call_id=row["tool_call_id"],
+            agent_run_id=row["agent_run_id"],
+            metadata=json.loads(row["metadata_json"] or "{}"),
+            created_at=row["created_at"],
+            updated_at=row["updated_at"],
+        )
+        for row in rows
+    ]
+
+
+async def clear_transcript(session_id: str) -> None:
+    def _run(conn):
+        conn.execute("DELETE FROM transcript_nodes WHERE session_id = ?", (session_id,))
+        conn.execute("DELETE FROM turns WHERE session_id = ?", (session_id,))
+
+    await _write_transaction(_run)

voidx/permission/__init__.py

@@ -0,0 +1,28 @@
+"""Permission system — aligned with opencode/Claude Code architecture."""
+
+from voidx.permission.schema import Action, Rule, Ruleset
+from voidx.permission.wildcard import match as wildcard_match
+from voidx.permission.evaluate import evaluate, from_config, merge
+from voidx.permission.service import PermissionService
+from voidx.permission.sandbox import check_sandbox_filepath, check_sandbox_bash
+from voidx.permission.engine import (
+    PermissionCapability,
+    PermissionContext,
+    PermissionDecision,
+    authorize_tool_call,
+    classify_tool_call,
+)
+
+__all__ = [
+    "Action", "Rule", "Ruleset",
+    "wildcard_match",
+    "evaluate", "from_config", "merge",
+    "PermissionService",
+    "check_sandbox_filepath",
+    "check_sandbox_bash",
+    "PermissionCapability",
+    "PermissionContext",
+    "PermissionDecision",
+    "authorize_tool_call",
+    "classify_tool_call",
+]