codeframe-ai 0.9.0__py3-none-any.whl

codeframe/tui/app.py

@@ -0,0 +1,256 @@
+"""CodeFRAME TUI Dashboard — live terminal dashboard.
+
+A Textual application showing tasks, events, and blockers
+with auto-refresh and keyboard navigation.
+"""
+
+from typing import Optional
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.reactive import reactive
+from textual.widgets import DataTable, Footer, Header, RichLog, Static
+
+from codeframe.core.workspace import Workspace
+from codeframe.tui.data_service import DashboardData, load_dashboard_data
+
+
+# Status → color mapping for task rows
+_STATUS_COLORS: dict[str, str] = {
+    "DONE": "green",
+    "IN_PROGRESS": "cyan",
+    "READY": "yellow",
+    "BACKLOG": "dim",
+    "BLOCKED": "red",
+    "FAILED": "red bold",
+    "MERGED": "green dim",
+}
+
+
+class StatusBar(Static):
+    """Top status bar showing task counts and workspace info."""
+
+    def update_from_data(self, data: DashboardData) -> None:
+        counts = data.task_counts
+        total = sum(counts.values())
+        done = counts.get("DONE", 0) + counts.get("MERGED", 0)
+        active = counts.get("IN_PROGRESS", 0)
+        blocked = counts.get("BLOCKED", 0) + counts.get("FAILED", 0)
+        ready = counts.get("READY", 0) + counts.get("BACKLOG", 0)
+
+        parts = [
+            f"[bold]{data.workspace_name}[/bold]",
+            f"Tasks: {total}",
+            f"[green]{done} done[/green]",
+            f"[cyan]{active} active[/cyan]",
+            f"[yellow]{ready} ready[/yellow]",
+        ]
+        if blocked > 0:
+            parts.append(f"[red]{blocked} blocked/failed[/red]")
+        if data.blocker_count > 0:
+            parts.append(f"[red bold]{data.blocker_count} blockers[/red bold]")
+        if data.open_obligation_count > 0:
+            parts.append(f"[yellow bold]{data.open_obligation_count} open obligations[/yellow bold]")
+
+        self.update(" | ".join(parts))
+
+
+class DashboardApp(App):
+    """CodeFRAME TUI Dashboard."""
+
+    CSS = """
+    Screen {
+        layout: vertical;
+    }
+    #status-bar {
+        height: 1;
+        background: $surface;
+        padding: 0 1;
+    }
+    #main-content {
+        height: 1fr;
+    }
+    #task-panel {
+        width: 2fr;
+        border: solid $primary;
+    }
+    #right-panel {
+        width: 1fr;
+    }
+    #event-log {
+        height: 2fr;
+        border: solid $secondary;
+    }
+    #blocker-panel {
+        height: 1fr;
+        border: solid $error;
+    }
+    #proof-panel {
+        height: 1fr;
+        border: solid $warning;
+    }
+    DataTable {
+        height: 1fr;
+    }
+    RichLog {
+        height: 1fr;
+    }
+    .panel-title {
+        background: $surface;
+        padding: 0 1;
+        text-style: bold;
+    }
+    """
+
+    TITLE = "CodeFRAME Dashboard"
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("r", "refresh", "Refresh"),
+        Binding("tab", "focus_next", "Next Panel"),
+        Binding("shift+tab", "focus_previous", "Prev Panel"),
+    ]
+
+    workspace: Optional[Workspace] = None
+    refresh_interval: int = 2
+    data: reactive[Optional[DashboardData]] = reactive(None)
+
+    def __init__(
+        self,
+        workspace: Workspace,
+        refresh_interval: int = 2,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.workspace = workspace
+        self.refresh_interval = refresh_interval
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield StatusBar(id="status-bar")
+        with Horizontal(id="main-content"):
+            with Vertical(id="task-panel"):
+                yield Static("Tasks", classes="panel-title")
+                yield DataTable(id="task-table")
+            with Vertical(id="right-panel"):
+                with Vertical(id="event-log"):
+                    yield Static("Recent Events", classes="panel-title")
+                    yield RichLog(id="event-log-content", highlight=True, markup=True)
+                with Vertical(id="blocker-panel"):
+                    yield Static("Open Blockers", classes="panel-title")
+                    yield RichLog(id="blocker-log", highlight=True, markup=True)
+                with Vertical(id="proof-panel"):
+                    yield Static("PROOF9 Obligations", classes="panel-title")
+                    yield RichLog(id="proof-log", highlight=True, markup=True)
+        yield Footer()
+
+    def on_mount(self) -> None:
+        # Set up task table columns
+        table = self.query_one("#task-table", DataTable)
+        table.add_columns("ID", "Title", "Status", "Priority")
+        table.cursor_type = "row"
+
+        # Initial data load
+        self._refresh_data()
+
+        # Auto-refresh
+        self.set_interval(self.refresh_interval, self._refresh_data)
+
+    def _refresh_data(self) -> None:
+        """Load fresh data from the workspace and update all widgets."""
+        if not self.workspace:
+            return
+
+        data = load_dashboard_data(self.workspace)
+        self.data = data
+
+        self._update_status_bar(data)
+        self._update_task_table(data)
+        self._update_event_log(data)
+        self._update_blocker_panel(data)
+        self._update_proof_panel(data)
+
+        if data.error:
+            self.notify(f"Data loading error: {data.error}", severity="warning")
+
+    def _update_status_bar(self, data: DashboardData) -> None:
+        status_bar = self.query_one("#status-bar", StatusBar)
+        status_bar.update_from_data(data)
+
+    def _update_task_table(self, data: DashboardData) -> None:
+        table = self.query_one("#task-table", DataTable)
+        table.clear()
+
+        for task in data.tasks:
+            status_val = task.status.value if hasattr(task.status, "value") else str(task.status)
+            color = _STATUS_COLORS.get(status_val, "white")
+            table.add_row(
+                task.id[:8],
+                task.title[:50],
+                f"[{color}]{status_val}[/{color}]",
+                str(task.priority),
+            )
+
+    def _update_event_log(self, data: DashboardData) -> None:
+        log = self.query_one("#event-log-content", RichLog)
+        log.clear()
+
+        for event in reversed(data.events):  # oldest first
+            ts = event.created_at.strftime("%H:%M:%S") if hasattr(event.created_at, "strftime") else str(event.created_at)[:8]
+            log.write(f"[dim]{ts}[/dim] {event.event_type}")
+
+    def _update_blocker_panel(self, data: DashboardData) -> None:
+        log = self.query_one("#blocker-log", RichLog)
+        log.clear()
+
+        if not data.blockers:
+            log.write("[dim]No open blockers[/dim]")
+            return
+
+        for blocker in data.blockers:
+            log.write(f"[red bold]{blocker.id[:8]}[/red bold]: {blocker.question[:60]}")
+
+    _SEVERITY_COLORS: dict[str, str] = {
+        "critical": "red bold",
+        "high": "red",
+        "medium": "yellow",
+        "low": "dim",
+    }
+
+    _OBLIGATION_ICONS: dict[str, str] = {
+        "satisfied": "✅",
+        "failed": "❌",
+        "pending": "⏳",
+    }
+
+    def _update_proof_panel(self, data: DashboardData) -> None:
+        log = self.query_one("#proof-log", RichLog)
+        log.clear()
+
+        if not data.open_requirements and not data.expiring_waivers:
+            log.write("[dim]No open obligations[/dim]")
+            return
+
+        for req in data.expiring_waivers:
+            from datetime import date
+            days = (req.waiver.expires - date.today()).days
+            log.write(
+                f"[yellow bold]⚠ {req.id}[/yellow bold]: waiver expires in {days}d — {req.title[:50]}"
+            )
+
+        for req in data.open_requirements:
+            gate_parts = [
+                f"{obl.gate.value.upper()} {self._OBLIGATION_ICONS.get(obl.status, '⏳')}"
+                for obl in req.obligations
+            ]
+            gate_summary = " ".join(gate_parts)
+            sev_color = self._SEVERITY_COLORS.get(req.severity.value, "white")
+            log.write(
+                f"[red]{req.id}[/red] [{sev_color}]{req.severity.value}[/{sev_color}]"
+                f" {req.title[:45]} | {gate_summary}"
+            )
+
+    def action_refresh(self) -> None:
+        """Manual refresh via 'r' key."""
+        self._refresh_data()
+        self.notify("Refreshed")

codeframe/tui/data_service.py

@@ -0,0 +1,103 @@
+"""Dashboard data service — thin wrapper over core modules.
+
+Loads all dashboard data in a single call to minimize DB access.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from codeframe.core.workspace import Workspace
+
+
+@dataclass
+class DashboardData:
+    """Snapshot of workspace state for display."""
+
+    workspace_name: str = ""
+    workspace_path: str = ""
+    tech_stack: str = ""
+
+    # Task counts by status
+    task_counts: dict[str, int] = field(default_factory=dict)
+    tasks: list = field(default_factory=list)
+
+    # Open blockers
+    blockers: list = field(default_factory=list)
+    blocker_count: int = 0
+
+    # Recent events
+    events: list = field(default_factory=list)
+
+    # PROOF9 obligations
+    open_requirements: list = field(default_factory=list)
+    expiring_waivers: list = field(default_factory=list)
+    open_obligation_count: int = 0
+
+    # Error (if data loading failed)
+    error: Optional[str] = None
+
+
+def load_dashboard_data(
+    workspace: Workspace, event_limit: int = 50
+) -> DashboardData:
+    """Load all dashboard data from a workspace.
+
+    Queries tasks, blockers, and events in one shot.
+    Returns a DashboardData snapshot for rendering.
+    """
+    data = DashboardData(
+        workspace_name=workspace.repo_path.name,
+        workspace_path=str(workspace.repo_path),
+        tech_stack=workspace.tech_stack or "",
+    )
+
+    try:
+        from codeframe.core import tasks as task_module
+
+        all_tasks = task_module.list_tasks(workspace)
+        data.tasks = all_tasks
+
+        counts: dict[str, int] = {}
+        for t in all_tasks:
+            status_name = t.status.value if hasattr(t.status, "value") else str(t.status)
+            counts[status_name] = counts.get(status_name, 0) + 1
+        data.task_counts = counts
+    except Exception as exc:
+        data.error = f"Tasks: {exc}"
+
+    try:
+        from codeframe.core import blockers
+        data.blockers = blockers.list_open(workspace)
+        data.blocker_count = len(data.blockers)
+    except Exception as exc:
+        if not data.error:
+            data.error = f"Blockers: {exc}"
+
+    try:
+        from codeframe.core.events import list_recent
+        data.events = list_recent(workspace, limit=event_limit)
+    except Exception as exc:
+        if not data.error:
+            data.error = f"Events: {exc}"
+
+    try:
+        from datetime import date
+        from codeframe.core.proof.ledger import list_requirements
+        from codeframe.core.proof.models import ReqStatus
+
+        open_reqs = list_requirements(workspace, status=ReqStatus.OPEN)
+        data.open_requirements = open_reqs
+        data.open_obligation_count = len(open_reqs)
+
+        waived = list_requirements(workspace, status=ReqStatus.WAIVED)
+        today = date.today()
+        data.expiring_waivers = [
+            req for req in waived
+            if req.waiver and req.waiver.expires is not None
+            and 0 <= (req.waiver.expires - today).days <= 7
+        ]
+    except Exception as exc:
+        if not data.error:
+            data.error = f"Proof: {exc}"
+
+    return data

codeframe/ui/dependencies.py

@@ -0,0 +1,103 @@
+"""FastAPI dependency injection providers.
+
+This module provides dependency injection functions for accessing
+shared application state across all API endpoints.
+
+v2-only: All dependencies use codeframe.core modules.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from fastapi import HTTPException, Query, Request
+
+from codeframe.workspace import WorkspaceManager
+
+# v2 imports
+from codeframe.core.workspace import Workspace, get_workspace, workspace_exists
+
+
+def get_workspace_manager(request: Request) -> WorkspaceManager:
+    """Get workspace manager from application state.
+
+    Args:
+        request: FastAPI request object
+
+    Returns:
+        WorkspaceManager instance from app.state.workspace_manager
+
+    Usage:
+        @router.post("/endpoint")
+        async def endpoint(workspace_mgr: WorkspaceManager = Depends(get_workspace_manager)):
+            # Use workspace_mgr here
+            ...
+    """
+    return request.app.state.workspace_manager
+
+
+def get_v2_workspace(
+    workspace_path: Optional[str] = Query(
+        None,
+        description="Path to workspace directory (defaults to server's working directory)",
+    ),
+    request: Request = None,
+) -> Workspace:
+    """Get v2 Workspace from path or server default.
+
+    This dependency resolves a Workspace from either:
+    1. An explicit workspace_path query parameter
+    2. The server's default workspace (from app.state.default_workspace_path)
+    3. The server's current working directory
+
+    Args:
+        workspace_path: Optional explicit path to workspace
+        request: FastAPI request for accessing app state
+
+    Returns:
+        v2 Workspace instance
+
+    Raises:
+        HTTPException:
+            - 400: No workspace path provided and no default configured
+            - 404: Workspace not found at path
+
+    Usage:
+        @router.get("/v2/endpoint")
+        async def endpoint(workspace: Workspace = Depends(get_v2_workspace)):
+            # Use workspace here
+            ...
+    """
+    # Resolve workspace path
+    if workspace_path:
+        path = Path(workspace_path).resolve()
+    elif request and getattr(request.app.state, "default_workspace_path", None):
+        path = Path(request.app.state.default_workspace_path).resolve()
+    else:
+        # Fall back to current working directory
+        path = Path.cwd()
+
+    # Validate workspace exists
+    # Note: Avoid exposing full filesystem paths in error messages for hosted deployments
+    if not workspace_exists(path):
+        raise HTTPException(
+            status_code=404,
+            detail="Workspace not found at specified path. Initialize with 'cf init <path>'",
+        )
+
+    try:
+        workspace = get_workspace(path)
+    except FileNotFoundError:
+        raise HTTPException(
+            status_code=404,
+            detail="Workspace not found at specified path. Initialize with 'cf init <path>'",
+        )
+
+    # Note: get_workspace() raises FileNotFoundError rather than returning None,
+    # so no additional null check is needed here.
+    return workspace
+
+
+__all__ = [
+    "get_workspace_manager",
+    "get_v2_workspace",
+]