pulice 0.1.0__py3-none-any.whl

pulice/__init__.py

@@ -0,0 +1,19 @@
+__version__ = '0.1.0'
+
+from pulice.cli.app import PuliceCLI
+from pulice.core.base import ComponentArgs, ManagedComponent
+from pulice.core.controllers import ComponentController, WorkspaceController
+from pulice.core.protocol import PuliceApp
+from pulice.core.tasks import TaskBackend, TaskResult, TaskStatus
+
+__all__ = [
+    'ComponentArgs',
+    'ComponentController',
+    'ManagedComponent',
+    'PuliceApp',
+    'PuliceCLI',
+    'TaskBackend',
+    'TaskResult',
+    'TaskStatus',
+    'WorkspaceController',
+]

pulice/admin/__init__.py

@@ -0,0 +1,13 @@
+"""Pulice Admin TUI — terminal and browser dashboard."""
+
+from __future__ import annotations
+
+
+def create_admin_app(
+    state_dir: str | None = None,
+    refresh_interval: int = 5,
+) -> 'PuliceAdmin':  # noqa: F821  # pyrefly: ignore
+    """Create and return the admin TUI application."""
+    from pulice.admin.app import PuliceAdmin
+
+    return PuliceAdmin(state_dir=state_dir, refresh_interval=refresh_interval)

pulice/admin/__main__.py

@@ -0,0 +1,8 @@
+"""Allow running the admin TUI with: python -m pulice.admin"""
+
+import sys
+from pulice.admin.app import PuliceAdmin
+
+state_dir = sys.argv[1] if len(sys.argv) > 1 else None
+app = PuliceAdmin(state_dir=state_dir)
+app.run()

pulice/admin/app.py

@@ -0,0 +1,90 @@
+"""PuliceAdmin — main Textual application for the admin TUI."""
+
+from __future__ import annotations
+from pathlib import Path
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.widgets import Footer, Header, TabbedContent, TabPane
+from pulice.admin.data import AdminDataSource
+from pulice.admin.screens.dashboard import DashboardScreen
+from pulice.admin.screens.stacks import StacksScreen
+from pulice.admin.screens.system import SystemScreen
+from pulice.admin.screens.tasks import TasksScreen
+from pulice.admin.screens.tenants import TenantsScreen
+
+CSS_PATH = Path(__file__).parent / 'styles' / 'app.tcss'
+
+
+class PuliceAdmin(App):
+    """Pulice administrative dashboard TUI."""
+
+    TITLE = 'Pulice Admin'
+    CSS_PATH = CSS_PATH
+    BINDINGS = [
+        Binding('1', "switch_tab('dashboard')", 'Dashboard', show=False),
+        Binding('2', "switch_tab('tenants')", 'Tenants', show=False),
+        Binding('3', "switch_tab('stacks')", 'Stacks', show=False),
+        Binding('4', "switch_tab('tasks')", 'Tasks', show=False),
+        Binding('5', "switch_tab('system')", 'System', show=False),
+        Binding('r', 'force_refresh', 'Refresh'),
+        Binding('q', 'quit', 'Quit'),
+    ]
+
+    def __init__(
+        self,
+        state_dir: str | None = None,
+        refresh_interval: int = 5,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._state_dir = state_dir
+        self._refresh_interval = refresh_interval
+        self._data = AdminDataSource(state_dir=state_dir)
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical(id='main'):
+            with TabbedContent(id='tabs'):
+                with TabPane('Dashboard', id='dashboard'):
+                    yield DashboardScreen(self._data)
+                with TabPane('Tenants', id='tenants'):
+                    yield TenantsScreen(self._data)
+                with TabPane('Stacks', id='stacks'):
+                    yield StacksScreen(self._data)
+                with TabPane('Tasks', id='tasks'):
+                    yield TasksScreen(self._data)
+                with TabPane('System', id='system'):
+                    yield SystemScreen(self._data)
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self._do_refresh()
+        if self._refresh_interval > 0:
+            self.set_interval(self._refresh_interval, self._do_refresh)
+
+    def _do_refresh(self) -> None:
+        self.run_worker(self._refresh_worker, exclusive=True)
+
+    async def _refresh_worker(self) -> None:
+        for screen_cls in (
+            DashboardScreen,
+            TenantsScreen,
+            StacksScreen,
+            TasksScreen,
+            SystemScreen,
+        ):
+            try:
+                widget = self.query_one(screen_cls)  # pyrefly: ignore
+                widget.refresh_data()
+            except Exception:  # noseq
+                pass
+
+    def action_switch_tab(self, tab_id: str) -> None:
+        tabs = self.query_one('#tabs', TabbedContent)
+        tabs.active = tab_id  # pyrefly: ignore
+        self._do_refresh()
+
+    def action_force_refresh(self) -> None:
+        self._do_refresh()
+        self.notify('Refreshed')

pulice/admin/data.py

@@ -0,0 +1,112 @@
+"""Read-only data provider for the admin TUI."""
+
+from __future__ import annotations
+import os
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+import pulice
+from pulice.core.stack import (
+    LocalStackReferenceStore,
+    SqliteBackendStorage,
+    StackReference,
+    Tenant,
+)
+from pulice.core.tasks import TaskBackend, TaskResult
+from typing import Any
+
+
+class AdminDataSource:
+    """Read-only data provider for the admin TUI.
+
+    Wraps existing storage APIs to provide data for all admin screens.
+    """
+
+    def __init__(self, state_dir: str | None = None) -> None:
+        self._state_dir = state_dir or os.getenv('PULICE_STATE_DIR')
+        self._storage = SqliteBackendStorage(root_dir=self._state_dir)
+        self._references = LocalStackReferenceStore(root_dir=self._state_dir)
+        self._task_backend: TaskBackend | None = None
+
+    def _get_task_backend(self) -> TaskBackend:
+        if self._task_backend is None:
+            from pulice.core.tasks import get_task_backend
+
+            self._task_backend = get_task_backend(state_dir=self._state_dir)
+        return self._task_backend
+
+    @property
+    def state_dir(self) -> str:
+        return str(self._storage._root)
+
+    def get_tenants(self) -> list[Tenant]:
+        return self._storage.list_tenants()
+
+    def get_stacks(self, tenant_id: str | None = None) -> list[dict[str, Any]]:
+        return self._storage.list_stacks(tenant_id=tenant_id)
+
+    def get_stack_references(self, tenant_id: str | None = None) -> list[StackReference]:
+        return self._references.list(tenant_id=tenant_id)
+
+    def get_locks(self) -> list[dict[str, Any]]:
+        with self._storage._connect() as conn:
+            rows = conn.execute(
+                'SELECT stack_name, holder, operation, locked_at FROM stack_locks'
+            ).fetchall()
+        now = datetime.now(timezone.utc)
+        results = []
+        for r in rows:
+            locked_at = datetime.fromisoformat(r[3])
+            age_seconds = (now - locked_at).total_seconds()
+            results.append(
+                {
+                    'stack_name': r[0],
+                    'holder': r[1],
+                    'operation': r[2],
+                    'locked_at': r[3],
+                    'age_seconds': age_seconds,
+                }
+            )
+        return results
+
+    def get_task_status(self, task_id: str) -> TaskResult:
+        return self._get_task_backend().get_status(task_id)
+
+    def get_system_info(self) -> dict[str, Any]:
+        state_path = Path(self.state_dir)
+        db_path = state_path / 'pulice_stacks.sqlite3'
+
+        total_size = sum(f.stat().st_size for f in state_path.rglob('*') if f.is_file())
+        db_size = db_path.stat().st_size if db_path.exists() else 0
+
+        tenants = self.get_tenants()
+        stacks = self.get_stacks()
+        locks = self.get_locks()
+
+        backend_type = os.getenv('PULICE_TASK_BACKEND', 'huey')
+
+        return {
+            'version': pulice.__version__,
+            'python': sys.version,
+            'state_dir': self.state_dir,
+            'state_dir_size': total_size,
+            'db_size': db_size,
+            'task_backend': backend_type,
+            'tenant_count': len(tenants),
+            'stack_count': len(stacks),
+            'lock_count': len(locks),
+            'locks': locks,
+        }
+
+    def delete_tenant(self, name: str) -> None:
+        self._storage.delete_tenant(name)
+
+    def release_lock(self, stack_name: str) -> None:
+        with self._storage._connect() as conn:
+            conn.execute('DELETE FROM stack_locks WHERE stack_name = ?', (stack_name,))
+
+    def cancel_task(self, task_id: str) -> bool:
+        return self._get_task_backend().cancel(task_id)
+
+    def retry_task(self, task_id: str) -> str:
+        return self._get_task_backend().retry(task_id)

pulice/admin/screens/__init__.py

@@ -0,0 +1,15 @@
+"""Admin TUI screens."""
+
+from pulice.admin.screens.dashboard import DashboardScreen
+from pulice.admin.screens.stacks import StacksScreen
+from pulice.admin.screens.system import SystemScreen
+from pulice.admin.screens.tasks import TasksScreen
+from pulice.admin.screens.tenants import TenantsScreen
+
+__all__ = [
+    'DashboardScreen',
+    'TenantsScreen',
+    'StacksScreen',
+    'TasksScreen',
+    'SystemScreen',
+]

pulice/admin/screens/dashboard.py

@@ -0,0 +1,61 @@
+"""Dashboard screen — summary view with key metrics."""
+
+from __future__ import annotations
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Static
+from pulice.admin.widgets.stat_card import StatCard
+
+if __name__ != '__main__':
+    from typing import TYPE_CHECKING
+
+    if TYPE_CHECKING:
+        from pulice.admin.data import AdminDataSource
+
+
+class DashboardScreen(Static):
+    """Summary dashboard showing key metrics at a glance."""
+
+    DEFAULT_CSS = """
+    DashboardScreen {
+        height: 1fr;
+        padding: 1 2;
+    }
+    DashboardScreen .metrics-row {
+        height: 7;
+        margin-bottom: 1;
+    }
+    DashboardScreen .info-section {
+        height: auto;
+        padding: 1;
+    }
+    """
+
+    def __init__(self, data_source: 'AdminDataSource') -> None:
+        super().__init__()
+        self._data = data_source
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(classes='metrics-row'):
+            yield StatCard('Tenants', '0', id='stat-tenants')
+            yield StatCard('Stacks', '0', id='stat-stacks')
+            yield StatCard('Active Locks', '0', id='stat-locks')
+        with Horizontal(classes='metrics-row'):
+            yield StatCard('Pending Tasks', '—', id='stat-pending')
+            yield StatCard('Running Tasks', '—', id='stat-running')
+            yield StatCard('Failed Tasks', '—', id='stat-failed')
+        with Vertical(classes='info-section'):
+            yield Static(id='system-info')
+
+    def refresh_data(self) -> None:
+        info = self._data.get_system_info()
+        self.query_one('#stat-tenants', StatCard).update_value(str(info['tenant_count']))
+        self.query_one('#stat-stacks', StatCard).update_value(str(info['stack_count']))
+        self.query_one('#stat-locks', StatCard).update_value(str(info['lock_count']))
+
+        info_text = (
+            f'[bold]Pulice[/bold] v{info["version"]}  |  '
+            f'Backend: {info["task_backend"]}  |  '
+            f'State: {info["state_dir"]}'
+        )
+        self.query_one('#system-info', Static).update(info_text)

pulice/admin/screens/stacks.py

@@ -0,0 +1,86 @@
+"""Stacks screen — list and manage stacks."""
+
+from __future__ import annotations
+from textual.app import ComposeResult
+from textual.widgets import DataTable, Static
+from pulice.admin.widgets.confirm import ConfirmModal
+
+if __name__ != '__main__':
+    from typing import TYPE_CHECKING
+
+    if TYPE_CHECKING:
+        from pulice.admin.data import AdminDataSource
+
+
+class StacksScreen(Static):
+    """Table of all stacks with lock management."""
+
+    DEFAULT_CSS = """
+    StacksScreen {
+        height: 1fr;
+        padding: 1 2;
+    }
+    """
+
+    BINDINGS = [
+        ('l', 'release_lock', 'Release Lock'),
+    ]
+
+    def __init__(self, data_source: 'AdminDataSource') -> None:
+        super().__init__()
+        self._data = data_source
+        self._tenant_filter: str | None = None
+
+    def compose(self) -> ComposeResult:
+        table = DataTable(id='stacks-table')
+        table.cursor_type = 'row'
+        table.add_columns('Stack Name', 'Tenant', 'UUID', 'Locked', 'Created')
+        yield table
+
+    def refresh_data(self) -> None:
+        table = self.query_one('#stacks-table', DataTable)
+        table.clear()
+        stacks = self._data.get_stacks(tenant_id=self._tenant_filter)
+        locks = {lock['stack_name']: lock for lock in self._data.get_locks()}
+        tenants = {t.id: t.name for t in self._data.get_tenants()}
+
+        for s in stacks:
+            stack_name = s['stack_name']
+            lock = locks.get(stack_name)
+            lock_display = f'[red]Locked ({lock["operation"]})[/red]' if lock else ''
+            tenant_name = tenants.get(s.get('tenant_id', ''), '—')
+
+            table.add_row(
+                stack_name,
+                tenant_name,
+                s['uuid'][:12],
+                lock_display,
+                s.get('created_at', '')[:19],
+                key=stack_name,
+            )
+
+    def action_release_lock(self) -> None:
+        table = self.query_one('#stacks-table', DataTable)
+        if table.row_count == 0:
+            return
+        row_key, _ = table.coordinate_to_cell_key(table.cursor_coordinate)
+        stack_name = str(row_key)
+
+        locks = {lock['stack_name']: lock for lock in self._data.get_locks()}
+        if stack_name not in locks:
+            self.notify('No lock on this stack', severity='warning')
+            return
+
+        def on_confirm(confirmed: bool) -> None:
+            if confirmed:
+                self._data.release_lock(stack_name)
+                self.notify(f"Released lock on '{stack_name}'")
+                self.refresh_data()
+
+        self.app.push_screen(  # pyrefly: ignore
+            ConfirmModal(
+                f"Release lock on '{stack_name}'?",
+                title='Release Lock',
+            ),
+            on_confirm,
+        )

pulice/admin/screens/system.py

@@ -0,0 +1,67 @@
+"""System screen — read-only information panel."""
+
+from __future__ import annotations
+from textual.app import ComposeResult
+from textual.widgets import Static
+
+if __name__ != '__main__':
+    from typing import TYPE_CHECKING
+
+    if TYPE_CHECKING:
+        from pulice.admin.data import AdminDataSource
+
+
+def _format_bytes(size: int) -> str:
+    for unit in ('B', 'KB', 'MB', 'GB'):
+        if size < 1024:
+            return f'{size:.1f} {unit}'
+        size //= 1024
+    return f'{size:.1f} TB'
+
+
+class SystemScreen(Static):
+    """Read-only system information panel."""
+
+    DEFAULT_CSS = """
+    SystemScreen {
+        height: 1fr;
+        padding: 1 2;
+    }
+    """
+
+    def __init__(self, data_source: 'AdminDataSource') -> None:
+        super().__init__()
+        self._data = data_source
+
+    def compose(self) -> ComposeResult:
+        yield Static(id='system-content')
+
+    def refresh_data(self) -> None:
+        info = self._data.get_system_info()
+
+        locks_text = ''
+        if info['locks']:
+            lock_lines = []
+            for lock in info['locks']:
+                age_min = int(lock['age_seconds']) // 60
+                lock_lines.append(f'  - {lock["stack_name"]} ({lock["operation"]}, {age_min}m ago)')
+            locks_text = '\n'.join(lock_lines)
+        else:
+            locks_text = '  None'
+
+        text = (
+            f'[bold]Version:[/bold]       {info["version"]}\n'
+            f'[bold]Python:[/bold]        {info["python"].split()[0]}\n'
+            f'[bold]State Dir:[/bold]     {info["state_dir"]}\n'
+            f'[bold]State Size:[/bold]    {_format_bytes(info["state_dir_size"])}\n'
+            f'[bold]DB Size:[/bold]       {_format_bytes(info["db_size"])}\n'
+            f'[bold]Task Backend:[/bold]  {info["task_backend"]}\n'
+            f'\n'
+            f'[bold]Database Stats:[/bold]\n'
+            f'  Tenants: {info["tenant_count"]}\n'
+            f'  Stacks:  {info["stack_count"]}\n'
+            f'  Locks:   {info["lock_count"]}\n'
+            f'\n'
+            f'[bold]Active Locks:[/bold]\n{locks_text}'
+        )
+        self.query_one('#system-content', Static).update(text)

pulice/admin/screens/tasks.py

@@ -0,0 +1,92 @@
+"""Tasks screen — list and manage async tasks."""
+
+from __future__ import annotations
+from textual.app import ComposeResult
+from textual.widgets import DataTable, Static
+from pulice.admin.widgets.confirm import ConfirmModal
+
+if __name__ != '__main__':
+    from typing import TYPE_CHECKING
+
+    if TYPE_CHECKING:
+        from pulice.admin.data import AdminDataSource
+
+
+class TasksScreen(Static):
+    """Table of tasks with cancel/retry actions.
+
+    Note: The current HueyTaskBackend does not support listing all tasks.
+    This screen shows a placeholder until a task index is implemented.
+    """
+
+    DEFAULT_CSS = """
+    TasksScreen {
+        height: 1fr;
+        padding: 1 2;
+    }
+    """
+
+    BINDINGS = [
+        ('c', 'cancel_task', 'Cancel'),
+        ('r', 'retry_task', 'Retry'),
+    ]
+
+    def __init__(self, data_source: 'AdminDataSource') -> None:
+        super().__init__()
+        self._data = data_source
+
+    def compose(self) -> ComposeResult:
+        yield Static(
+            '[dim]Task listing requires a task index (not yet implemented in the '
+            'Huey backend). Individual tasks can be queried by ID.[/dim]',
+            id='tasks-notice',
+        )
+        table = DataTable(id='tasks-table')
+        table.cursor_type = 'row'
+        table.add_columns('Task ID', 'Status', 'Error')
+        yield table
+
+    def refresh_data(self) -> None:
+        pass
+
+    def action_cancel_task(self) -> None:
+        table = self.query_one('#tasks-table', DataTable)
+        if table.row_count == 0:
+            return
+        row_key, _ = table.coordinate_to_cell_key(table.cursor_coordinate)
+        task_id = str(row_key)
+
+        def on_confirm(confirmed: bool) -> None:
+            if confirmed:
+                success = self._data.cancel_task(task_id)
+                if success:
+                    self.notify(f"Cancelled task '{task_id[:12]}'")
+                else:
+                    self.notify('Could not cancel task', severity='error')
+                self.refresh_data()
+
+        self.app.push_screen(  # pyrefly: ignore
+            ConfirmModal(f"Cancel task '{task_id[:12]}'?", title='Cancel Task'),
+            on_confirm,
+        )
+
+    def action_retry_task(self) -> None:
+        table = self.query_one('#tasks-table', DataTable)
+        if table.row_count == 0:
+            return
+        row_key, _ = table.coordinate_to_cell_key(table.cursor_coordinate)
+        task_id = str(row_key)
+
+        def on_confirm(confirmed: bool) -> None:
+            if confirmed:
+                try:
+                    new_id = self._data.retry_task(task_id)
+                    self.notify(f"Retried as '{new_id[:12]}'")
+                    self.refresh_data()
+                except ValueError as e:
+                    self.notify(str(e), severity='error')
+
+        self.app.push_screen(  # pyrefly: ignore
+            ConfirmModal(f"Retry task '{task_id[:12]}'?", title='Retry Task'),
+            on_confirm,
+        )

pulice/admin/screens/tenants.py

@@ -0,0 +1,78 @@
+"""Tenants screen — list and manage tenants."""
+
+from __future__ import annotations
+from textual.app import ComposeResult
+from textual.widgets import DataTable, Static
+from pulice.admin.widgets.confirm import ConfirmModal
+
+if __name__ != '__main__':
+    from typing import TYPE_CHECKING
+
+    if TYPE_CHECKING:
+        from pulice.admin.data import AdminDataSource
+
+
+class TenantsScreen(Static):
+    """Table of all tenants with actions."""
+
+    DEFAULT_CSS = """
+    TenantsScreen {
+        height: 1fr;
+        padding: 1 2;
+    }
+    """
+
+    BINDINGS = [
+        ('d', 'delete_tenant', 'Delete'),
+    ]
+
+    def __init__(self, data_source: 'AdminDataSource') -> None:
+        super().__init__()
+        self._data = data_source
+
+    def compose(self) -> ComposeResult:
+        table = DataTable(id='tenants-table')
+        table.cursor_type = 'row'
+        table.add_columns('Name', 'ID', 'Stacks', 'Created')
+        yield table
+
+    def refresh_data(self) -> None:
+        table = self.query_one('#tenants-table', DataTable)
+        table.clear()
+        tenants = self._data.get_tenants()
+        stacks = self._data.get_stacks()
+
+        stack_counts: dict[str, int] = {}
+        for s in stacks:
+            tid = s.get('tenant_id', '')
+            stack_counts[tid] = stack_counts.get(tid, 0) + 1
+
+        for t in tenants:
+            table.add_row(
+                t.name,
+                t.id[:12],
+                str(stack_counts.get(t.id, 0)),
+                t.created_at[:19],
+                key=t.name,
+            )
+
+    def action_delete_tenant(self) -> None:
+        table = self.query_one('#tenants-table', DataTable)
+        if table.row_count == 0:
+            return
+        row_key, _ = table.coordinate_to_cell_key(table.cursor_coordinate)
+        tenant_name = str(row_key)
+
+        def on_confirm(confirmed: bool) -> None:
+            if confirmed:
+                try:
+                    self._data.delete_tenant(tenant_name)
+                    self.notify(f"Deleted tenant '{tenant_name}'")
+                    self.refresh_data()
+                except ValueError as e:
+                    self.notify(str(e), severity='error')
+
+        self.app.push_screen(  # pyrefly: ignore
+            ConfirmModal(f"Delete tenant '{tenant_name}'?", title='Delete Tenant'),
+            on_confirm,
+        )