cortexshift 0.1.0__py3-none-any.whl

cortexshift/tui/screens/providers.py

@@ -0,0 +1,169 @@
+"""The Providers section: passive discovery status and MCP integration.
+
+Discovery is passive: no model prompts, no headless runs, no credential files, and no
+account identifiers. Rendering MCP status never starts an MCP server.
+"""
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import DataTable, Static
+
+from cortexshift.tui.models import (
+    TuiMcpStatus,
+    TuiProviderStatus,
+    WorkspaceActivity,
+)
+from cortexshift.tui.screens import SectionView, TuiSection
+from cortexshift.tui.widgets import FieldList, Panel, marked
+
+
+class ProvidersSection(SectionView):
+    """Renders provider CLI availability and CortexShift MCP integration modes."""
+
+    section = TuiSection.PROVIDERS
+
+    def __init__(self, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self._providers: tuple[TuiProviderStatus, ...] = ()
+        self._mcp: TuiMcpStatus | None = None
+
+    def compose(self) -> ComposeResult:
+        """Build the providers layout."""
+        yield Static(Text("Providers", style="bold"), classes="section-title")
+        yield Static("", id="providers-heading")
+        yield DataTable(id="providers-table", cursor_type="row")
+
+        with Panel("Provider detail"):
+            yield FieldList(id="providers-detail")
+
+        with Panel("CortexShift MCP"):
+            yield FieldList(id="providers-mcp")
+
+        yield Static(
+            Text(
+                "X opens the provider action palette (run · resume · switch). "
+                "G configures workspace MCP for Antigravity.\n"
+                "No account identifiers, credential paths, or tokens are read or shown.",
+                style="dim italic",
+            ),
+        )
+
+    def on_mount(self) -> None:
+        """Configure provider table columns."""
+        table = self.query_one("#providers-table", DataTable)
+        table.add_columns("Provider", "Installed", "Version", "Auth", "Native resume", "MCP")
+
+    def update_providers(
+        self,
+        providers: tuple[TuiProviderStatus, ...],
+        mcp: TuiMcpStatus | None,
+    ) -> None:
+        """Render discovery results and MCP integration status."""
+        self._providers = providers
+        self._mcp = mcp
+
+        heading = self.query_one("#providers-heading", Static)
+        table = self.query_one("#providers-table", DataTable)
+
+        if not providers:
+            heading.update(Text("Probing installed provider CLIs…", style="dim italic"))
+        else:
+            available = sum(1 for provider in providers if provider.available)
+            heading.update(
+                Text(f"{available} of {len(providers)} provider CLIs available on PATH.")
+            )
+
+        table.clear()
+        for provider in providers:
+            state = "available" if provider.installed else "unavailable"
+            if provider.supports_exact_resume:
+                resume = Text("✓ exact native resume", style="green")
+            elif provider.supports_native_resume:
+                resume = Text("· partial", style="dim")
+            else:
+                resume = Text("— not supported", style="dim")
+            table.add_row(
+                Text(provider.display_name),
+                marked(state, state),
+                Text(provider.version or "—"),
+                Text(provider.authentication),
+                resume,
+                Text(provider.mcp_integration),
+                key=provider.provider_id,
+            )
+
+        self._render_detail()
+        self._render_mcp()
+
+    def on_data_table_row_highlighted(self, _event: DataTable.RowHighlighted) -> None:
+        """Render the highlighted provider's diagnostics."""
+        self._render_detail()
+
+    def _render_detail(self) -> None:
+        detail = self.query_one("#providers-detail", FieldList)
+        provider = self.selected_provider
+        if provider is None:
+            detail.set_fields([])
+            return
+
+        diagnostics = "; ".join(provider.diagnostics) if provider.diagnostics else "—"
+        detail.set_fields(
+            [
+                ("Provider", provider.display_name),
+                ("Provider ID", provider.provider_id),
+                ("Executable", provider.executable),
+                ("Installed", "yes" if provider.installed else "no"),
+                ("Version", provider.version or "—"),
+                ("Authentication", provider.authentication),
+                ("Native resume", "yes" if provider.supports_native_resume else "no"),
+                ("Exact native resume", "yes" if provider.supports_exact_resume else "no"),
+                ("MCP integration", provider.mcp_integration),
+                ("Diagnostics", diagnostics),
+            ]
+        )
+
+    def _render_mcp(self) -> None:
+        widget = self.query_one("#providers-mcp", FieldList)
+        mcp = self._mcp
+        if mcp is None:
+            widget.set_fields([("MCP", Text("Loading…", style="dim italic"))])
+            return
+
+        antigravity = (
+            Text("✓ configured", style="green")
+            if mcp.antigravity_configured
+            else Text("! not configured — press G to configure", style="yellow")
+        )
+        widget.set_fields(
+            [
+                ("MCP server", "cortexshift (not running from this dashboard)"),
+                ("SDK", f"{'available' if mcp.sdk_available else 'unavailable'} {mcp.sdk_version}"),
+                ("Transport", mcp.transport),
+                ("Claude Code", mcp.claude_integration),
+                ("OpenAI Codex", mcp.codex_integration),
+                ("Antigravity", antigravity),
+                ("Config path", mcp.antigravity_config_path or "—"),
+                ("Read tools", f"{len(mcp.read_tools)}: {', '.join(mcp.read_tools)}"),
+                ("Write tools", f"{len(mcp.write_tools)}: {', '.join(mcp.write_tools)}"),
+                ("Resources", ", ".join(mcp.resources)),
+            ]
+        )
+
+    @property
+    def selected_provider(self) -> TuiProviderStatus | None:
+        """The provider row under the cursor, or None."""
+        table = self.query_one("#providers-table", DataTable)
+        if table.row_count == 0:
+            return None
+        try:
+            row_key, _ = table.coordinate_to_cell_key(table.cursor_coordinate)
+        except Exception:
+            return None
+        return next((p for p in self._providers if p.provider_id == row_key.value), None)
+
+    def update_activity(self, activity: WorkspaceActivity) -> None:
+        """Workspace lease state is surfaced by the app's status line."""
+
+    def on_section_shown(self) -> None:
+        """Focus the table so provider selection is keyboard-driven."""
+        self.query_one("#providers-table", DataTable).focus()

cortexshift/tui/screens/repository.py

@@ -0,0 +1,143 @@
+"""The Repository section: live, strictly read-only Git working tree state.
+
+This screen inspects; it never mutates. There is no staging, committing, checkout,
+reset, or stash control anywhere in CortexShift's dashboard, and full diffs are never
+rendered — only counts, file paths, and shortstat summaries.
+"""
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Static
+
+from cortexshift.tui.models import (
+    DataAuthority,
+    TuiRepositoryModel,
+    format_timestamp,
+)
+from cortexshift.tui.screens import SectionView, TuiSection
+from cortexshift.tui.widgets import BulletList, FieldList, Panel, marked
+
+
+class RepositorySection(SectionView):
+    """Renders the most recent live repository inspection."""
+
+    section = TuiSection.REPOSITORY
+
+    def compose(self) -> ComposeResult:
+        """Build the repository layout."""
+        yield Static(Text("Repository", style="bold"), classes="section-title")
+        yield Static("", id="repo-heading")
+
+        # Git facts span the full width so absolute paths and commit SHAs stay readable.
+        with Panel("Git", authority=DataAuthority.LIVE):
+            yield FieldList(id="repo-git")
+
+        with Horizontal(classes="columns"):
+            with Vertical(classes="column"):
+                with Panel("Diff summary", authority=DataAuthority.LIVE):
+                    yield FieldList(id="repo-diff")
+                with Panel("Staged"):
+                    yield BulletList(id="repo-staged")
+                with Panel("Modified"):
+                    yield BulletList(id="repo-modified")
+            with Vertical(classes="column"):
+                with Panel("Untracked"):
+                    yield BulletList(id="repo-untracked")
+                with Panel("Conflicted"):
+                    yield BulletList(id="repo-conflicted")
+
+        yield Static(
+            Text(
+                "Read-only view. CortexShift never stages, commits, checks out, resets, "
+                "or stashes; full diffs are not displayed.",
+                style="dim italic",
+            ),
+        )
+
+    def update_repository(self, repository: TuiRepositoryModel | None) -> None:
+        """Render an inspection result, or the in-flight state while one runs."""
+        heading = self.query_one("#repo-heading", Static)
+
+        if repository is None:
+            heading.update(Text("Inspecting repository…", style="dim italic"))
+            self.query_one("#repo-git", FieldList).set_fields([])
+            self.query_one("#repo-diff", FieldList).set_fields([])
+            for widget_id in (
+                "#repo-staged",
+                "#repo-modified",
+                "#repo-untracked",
+                "#repo-conflicted",
+            ):
+                self.query_one(widget_id, BulletList).set_items([], empty="—")
+            return
+
+        if not repository.ready:
+            heading.update(marked("warn", f"Repository unavailable: {repository.status.value}"))
+            self.query_one("#repo-git", FieldList).set_fields(
+                [
+                    ("Git available", "yes" if repository.git_available else "no"),
+                    ("Project root", str(repository.project_root)),
+                    ("Diagnostic", repository.diagnostic or "—"),
+                ]
+            )
+            self.query_one("#repo-diff", FieldList).set_fields([])
+            for widget_id in (
+                "#repo-staged",
+                "#repo-modified",
+                "#repo-untracked",
+                "#repo-conflicted",
+            ):
+                self.query_one(widget_id, BulletList).set_items([], empty="—")
+            return
+
+        branch = repository.branch or "(detached HEAD)"
+        state = "dirty" if repository.dirty else "clean"
+        summary = Text()
+        summary.append(branch, style="bold")
+        summary.append(" · ")
+        summary.append_text(marked(state, state))
+        summary.append(f" · {repository.changed_file_count} changed file(s)")
+        heading.update(summary)
+
+        git_root_relationship = "same as project root"
+        if repository.git_root and repository.git_root != str(repository.project_root):
+            git_root_relationship = repository.git_root
+
+        self.query_one("#repo-git", FieldList).set_fields(
+            [
+                ("Git available", "yes" if repository.git_available else "no"),
+                ("Git version", repository.git_version or "—"),
+                ("Project root", str(repository.project_root)),
+                ("Git root", git_root_relationship),
+                ("Branch", branch),
+                ("HEAD", repository.head_sha or "— (no commit yet)"),
+                ("Detached HEAD", "yes" if repository.detached_head else "no"),
+                ("Dirty", "yes" if repository.dirty else "no"),
+                ("Observed at", format_timestamp(repository.observed_at)),
+            ]
+        )
+
+        self.query_one("#repo-diff", FieldList).set_fields(
+            [
+                ("Staged", str(len(repository.staged_files))),
+                ("Modified", str(len(repository.modified_files))),
+                ("Untracked", str(len(repository.untracked_files))),
+                ("Conflicted", str(len(repository.conflicted_files))),
+                ("Working tree", repository.working_tree_diff_summary or "—"),
+                ("Staged diff", repository.staged_diff_summary or "—"),
+            ]
+        )
+
+        self.query_one("#repo-staged", BulletList).set_items(
+            list(repository.staged_files), limit=10, empty="No staged changes."
+        )
+        self.query_one("#repo-modified", BulletList).set_items(
+            list(repository.modified_files), limit=10, empty="No modified files."
+        )
+        self.query_one("#repo-untracked", BulletList).set_items(
+            list(repository.untracked_files), limit=10, empty="No untracked files."
+        )
+        self.query_one("#repo-conflicted", BulletList).set_items(
+            list(repository.conflicted_files), limit=10, empty="No conflicts."
+        )

cortexshift/tui/screens/sessions.py

@@ -0,0 +1,146 @@
+"""The Sessions section: CortexShift orchestration history.
+
+Only orchestration metadata is shown. Provider transcripts, prompts, reasoning, and
+terminal history are never read, stored, or rendered by CortexShift.
+"""
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.widgets import DataTable, Static
+
+from cortexshift.tui.models import (
+    AUTHORITY_LABELS,
+    TuiSessionRow,
+    TuiStateSnapshot,
+    format_relative,
+    format_timestamp,
+)
+from cortexshift.tui.screens import SectionView, TuiSection
+from cortexshift.tui.widgets import (
+    EmptyState,
+    FieldList,
+    Panel,
+    current_row_key,
+    marked,
+    restore_cursor,
+)
+
+
+class SessionsSection(SectionView):
+    """Lists CortexShift sessions newest first with native resume metadata."""
+
+    section = TuiSection.SESSIONS
+
+    def __init__(self, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self._rows: dict[str, TuiSessionRow] = {}
+
+    def compose(self) -> ComposeResult:
+        """Build the sessions layout."""
+        yield Static(Text("Sessions", style="bold"), classes="section-title")
+        yield EmptyState(
+            "No sessions yet.",
+            "Start one with:\n  cortexshift run PROVIDER\n\n"
+            "Or press X here to choose a provider action.",
+            id="sessions-empty",
+        )
+        yield DataTable(id="sessions-table", cursor_type="row")
+        with Panel("Session detail", id="sessions-detail-panel"):
+            yield FieldList(id="sessions-detail")
+        yield Static(
+            Text(
+                "CortexShift orchestration metadata only — no provider transcripts, "
+                "prompts, or reasoning are ever read or displayed.",
+                style="dim italic",
+            ),
+        )
+
+    def on_mount(self) -> None:
+        """Configure session table columns."""
+        table = self.query_one("#sessions-table", DataTable)
+        table.add_columns(
+            "Session", "Provider", "Status", "Native resume", "Started", "Ended", "Task"
+        )
+
+    def update_state(self, snapshot: TuiStateSnapshot) -> None:
+        """Refresh the sessions table, preserving the operator's selection."""
+        table = self.query_one("#sessions-table", DataTable)
+        empty = self.query_one("#sessions-empty", EmptyState)
+        detail_panel = self.query_one("#sessions-detail-panel", Panel)
+
+        rows = snapshot.sessions
+        self._rows = {row.id: row for row in rows}
+
+        empty.display = not rows
+        table.display = bool(rows)
+        detail_panel.display = bool(rows)
+
+        selected = current_row_key(table)
+        table.clear()
+        for row in rows:
+            if row.native_resumable:
+                resume = Text("✓ exact", style="green")
+            elif row.native_session_id:
+                resume = Text("· recorded", style="dim")
+            else:
+                resume = Text("— none", style="dim")
+
+            ended = format_relative(row.ended_at)
+            if row.ended_at is None and row.reconciled_at is not None:
+                ended = f"reconciled {format_relative(row.reconciled_at)}"
+
+            table.add_row(
+                Text(row.short_id),
+                Text(row.provider_id),
+                marked(row.status, row.status),
+                resume,
+                Text(format_relative(row.started_at)),
+                Text(ended),
+                Text(row.task_id[:12]),
+                key=row.id,
+            )
+        restore_cursor(table, selected)
+        self._render_detail()
+
+    def on_data_table_row_highlighted(self, _event: DataTable.RowHighlighted) -> None:
+        """Show full canonical detail for the highlighted session."""
+        self._render_detail()
+
+    def _render_detail(self) -> None:
+        table = self.query_one("#sessions-table", DataTable)
+        detail = self.query_one("#sessions-detail", FieldList)
+        key = current_row_key(table)
+        row = self._rows.get(key) if key else None
+        if row is None:
+            detail.set_fields([])
+            return
+
+        detail.set_fields(
+            [
+                ("Session ID", row.id),
+                ("Task ID", row.task_id),
+                ("Provider", row.provider_id),
+                ("Native session ID", row.native_session_id or "— (not recorded)"),
+                ("Native resumable", "yes" if row.native_resumable else "no"),
+                ("Resumed from", row.resumed_from_session_id or "—"),
+                ("Status", row.status),
+                ("Exit reason", row.exit_reason or "—"),
+                ("Exit code", "—" if row.exit_code is None else str(row.exit_code)),
+                ("Started at", format_timestamp(row.started_at)),
+                ("Ended at", format_timestamp(row.ended_at)),
+                ("Reconciled at", format_timestamp(row.reconciled_at)),
+                ("Authority", AUTHORITY_LABELS[row.authority]),
+            ]
+        )
+
+    @property
+    def selected_session(self) -> TuiSessionRow | None:
+        """The session row under the cursor, or None."""
+        key = current_row_key(self.query_one("#sessions-table", DataTable))
+        return self._rows.get(key) if key else None
+
+    def on_section_shown(self) -> None:
+        """Focus the table so the keyboard drives selection immediately."""
+        table = self.query_one("#sessions-table", DataTable)
+        if table.display:
+            table.focus()

cortexshift/tui/screens/task.py

@@ -0,0 +1,174 @@
+"""The Task section: complete canonical Task state, progress controls, and activation."""
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import DataTable, Static
+
+from cortexshift.tui.models import (
+    TuiStateSnapshot,
+    TuiTaskRow,
+    format_timestamp,
+    truncate,
+)
+from cortexshift.tui.screens import SectionView, TuiSection
+from cortexshift.tui.widgets import (
+    BulletList,
+    FieldList,
+    Panel,
+    current_row_key,
+    marked,
+    render_progress_bar,
+    restore_cursor,
+)
+
+
+class TaskSection(SectionView):
+    """Renders the active Task in full and lists every Task in the project."""
+
+    section = TuiSection.TASK
+
+    def __init__(self, id: str | None = None) -> None:
+        super().__init__(id=id)
+        self._rows: dict[str, TuiTaskRow] = {}
+
+    def compose(self) -> ComposeResult:
+        """Build the task layout."""
+        yield Static(Text("Task", style="bold"), classes="section-title")
+        yield Static("", id="task-heading")
+        yield Static("", id="task-progress")
+
+        # Identity spans the full width so canonical IDs and timestamps stay on one line
+        # and remain copy-friendly.
+        with Panel("Identity"):
+            yield FieldList(id="task-identity")
+
+        with Horizontal(classes="columns"):
+            with Vertical(classes="column"):
+                with Panel("Objective"):
+                    yield Static("", id="task-objective")
+                with Panel("Current work"):
+                    yield Static("", id="task-current-work")
+                with Panel("Requirements"):
+                    yield BulletList(id="task-requirements")
+                with Panel("Constraints"):
+                    yield BulletList(id="task-constraints")
+            with Vertical(classes="column"):
+                with Panel("Completed"):
+                    yield BulletList(id="task-completed")
+                with Panel("Remaining"):
+                    yield BulletList(id="task-remaining")
+                with Panel("Known issues"):
+                    yield BulletList(id="task-issues")
+
+        with Panel("All tasks"):
+            yield Static(
+                Text(
+                    "Enter or A activates the selected task · W set current work · "
+                    "M mark completed · N add remaining · I record issue",
+                    style="dim",
+                ),
+            )
+            yield DataTable(id="task-table", cursor_type="row", zebra_stripes=False)
+
+    def on_mount(self) -> None:
+        """Configure the task table columns."""
+        table = self.query_one("#task-table", DataTable)
+        table.add_columns("Task", "Title", "Status", "Done", "Left", "Active")
+
+    def update_state(self, snapshot: TuiStateSnapshot) -> None:
+        """Render the active task in full and refresh the task table."""
+        self._render_active(snapshot)
+        self._render_table(snapshot)
+
+    def _render_active(self, snapshot: TuiStateSnapshot) -> None:
+        heading = self.query_one("#task-heading", Static)
+        progress = self.query_one("#task-progress", Static)
+        task = snapshot.active_task
+
+        if task is None:
+            heading.update(Text("No active task.", style="bold"))
+            progress.update(
+                Text(
+                    "Activate a task from the table below, or create one with "
+                    "`cortexshift task start`.",
+                    style="dim",
+                )
+            )
+            self.query_one("#task-identity", FieldList).set_fields([])
+            self.query_one("#task-objective", Static).update(Text("—", style="dim"))
+            self.query_one("#task-current-work", Static).update(Text("—", style="dim"))
+            for widget_id in (
+                "#task-requirements",
+                "#task-constraints",
+                "#task-completed",
+                "#task-remaining",
+                "#task-issues",
+            ):
+                self.query_one(widget_id, BulletList).set_items([])
+            return
+
+        title = Text()
+        title.append(task.title, style="bold")
+        title.append_text(Text("   "))
+        title.append_text(marked(task.status, task.status))
+        heading.update(title)
+        progress.update(render_progress_bar(task.progress, width=28))
+
+        self.query_one("#task-identity", FieldList).set_fields(
+            [
+                ("Task ID", task.id),
+                ("Status", task.status),
+                ("Created", format_timestamp(task.created_at)),
+                ("Updated", format_timestamp(task.updated_at)),
+            ]
+        )
+        self.query_one("#task-objective", Static).update(Text(task.objective))
+        self.query_one("#task-current-work", Static).update(
+            Text(task.current_work) if task.current_work else Text("—", style="dim italic")
+        )
+        self.query_one("#task-requirements", BulletList).set_items(
+            list(task.requirements), empty="No requirements recorded."
+        )
+        self.query_one("#task-constraints", BulletList).set_items(
+            list(task.constraints), empty="No constraints recorded."
+        )
+        self.query_one("#task-completed", BulletList).set_items(
+            list(task.completed), empty="Nothing completed yet.", marker="✓"
+        )
+        self.query_one("#task-remaining", BulletList).set_items(
+            list(task.remaining), empty="No remaining items recorded.", marker="□"
+        )
+        self.query_one("#task-issues", BulletList).set_items(
+            list(task.known_issues), empty="No known issues recorded.", marker="!"
+        )
+
+    def _render_table(self, snapshot: TuiStateSnapshot) -> None:
+        table = self.query_one("#task-table", DataTable)
+        selected = current_row_key(table)
+
+        self._rows = {row.id: row for row in snapshot.tasks}
+        table.clear()
+        for row in snapshot.tasks:
+            table.add_row(
+                Text(row.short_id),
+                Text(truncate(row.title, 44)),
+                marked(row.status, row.status),
+                Text(str(row.completed_count)),
+                Text(str(row.remaining_count)),
+                Text("active" if row.is_active else "", style="bold green"),
+                key=row.id,
+            )
+        restore_cursor(table, selected)
+
+    # -- selection ---------------------------------------------------------
+
+    @property
+    def selected_task(self) -> TuiTaskRow | None:
+        """The task row under the cursor, or None when the table is empty."""
+        key = current_row_key(self.query_one("#task-table", DataTable))
+        return self._rows.get(key) if key else None
+
+    def on_section_shown(self) -> None:
+        """Focus the task table so activation is reachable from the keyboard."""
+        self.query_one("#task-table", DataTable).focus()