delimit-cli 4.0.5 → 4.0.6

package/bin/delimit-os.sh

@@ -0,0 +1,105 @@
+#!/bin/bash
+# Delimit OS — the AI developer operating system
+# Type 'delimit' to launch the TUI, or 'delimit <command>' for CLI tools
+#
+# Usage:
+#   delimit              → Launch TUI (interactive terminal dashboard)
+#   delimit --quick      → Quick status (non-interactive)
+#   delimit think        → Trigger deliberation
+#   delimit build        → Start autonomous build loop
+#   delimit ask <query>  → Ask the swarm
+#   delimit lint <spec>  → Lint an API spec
+#   delimit init         → Initialize governance in current repo
+#   delimit setup        → Configure AI assistants
+
+set -e
+
+DELIMIT_HOME="${DELIMIT_HOME:-$HOME/.delimit}"
+GATEWAY="$DELIMIT_HOME/server/ai"
+
+# If no args, launch TUI (interactive if terminal, quick if piped)
+if [ $# -eq 0 ]; then
+    if [ -f "$GATEWAY/tui.py" ]; then
+        if [ -t 1 ] && [ -t 0 ]; then
+            cd "$DELIMIT_HOME/server" && exec python3 -m ai.tui
+        else
+            cd "$DELIMIT_HOME/server" && exec python3 -m ai.tui --quick
+        fi
+    else
+        # Fallback to npm CLI
+        exec delimit-cli "$@"
+    fi
+fi
+
+# Route commands
+case "$1" in
+    --quick|-q)
+        if [ -f "$GATEWAY/tui.py" ]; then
+            cd "$DELIMIT_HOME/server" && exec python3 -m ai.tui --quick
+        else
+            exec delimit-cli status
+        fi
+        ;;
+    think|deliberate)
+        shift
+        QUESTION="${*:-What should we build next based on the current ledger and signals?}"
+        echo "[Delimit OS] Triggering deliberation..."
+        cd "$DELIMIT_HOME/server" && python3 -c "
+from ai.deliberation import deliberate
+import json
+result = deliberate('''$QUESTION''', mode='dialogue', max_rounds=3)
+if 'error' in result:
+    print(f'Error: {result[\"error\"]}')
+elif result.get('mode') == 'single_model_reflection':
+    print(f'Model: {result.get(\"model\", \"?\")}')
+    print(f'\\nAdvocate:\\n{result.get(\"advocate\", \"\")[:500]}')
+    print(f'\\nCritic:\\n{result.get(\"critic\", \"\")[:500]}')
+    print(f'\\nSynthesis:\\n{result.get(\"synthesis\", \"\")}')
+else:
+    print(f'Verdict: {result.get(\"final_verdict\", \"no consensus\")[:500]}')
+    print(f'Rounds: {result.get(\"rounds\", 0)}')
+" 2>&1
+        ;;
+    build|loop)
+        shift
+        echo "[Delimit OS] Starting autonomous build loop..."
+        echo "Checking ledger for next task..."
+        cd "$DELIMIT_HOME/server" && python3 -c "
+from ai.ledger_manager import get_context
+import json
+result = get_context()
+items = result.get('next_up', [])
+if items:
+    print(f'Next up: {items[0].get(\"id\", \"?\")} [{items[0].get(\"priority\", \"?\")}] {items[0].get(\"title\", \"?\")[:60]}')
+    print(f'Total open: {result.get(\"open_items\", 0)}')
+else:
+    print('Ledger is clear — nothing to build.')
+" 2>&1
+        ;;
+    ask)
+        shift
+        QUERY="$*"
+        if [ -z "$QUERY" ]; then
+            echo "Usage: delimit ask <question>"
+            exit 1
+        fi
+        echo "[Delimit OS] Checking context..."
+        cd "$DELIMIT_HOME/server" && python3 -c "
+from ai.ledger_manager import get_context
+import json
+result = get_context()
+print(json.dumps(result, indent=2)[:2000])
+" 2>&1
+        ;;
+    status)
+        if [ -f "$GATEWAY/tui.py" ]; then
+            cd "$GATEWAY/.." && exec python3 -m ai.tui --quick
+        else
+            exec delimit-cli status
+        fi
+        ;;
+    *)
+        # Pass through to delimit-cli for all other commands
+        exec delimit-cli "$@"
+        ;;
+esac

package/gateway/ai/tui.py

@@ -0,0 +1,296 @@
+"""Delimit TUI — Terminal User Interface (Phase 2 of Delimit OS).
+
+The proprietary terminal experience. Type 'delimit' and get an OS-like
+environment with panels for ledger, swarm, memory, and live logs.
+
+Enterprise-ready: zero JS, pure Python, works over SSH, sub-2s boot.
+Designed for devs who hate browser-based tools.
+
+Usage:
+    python -m ai.tui          # Full TUI
+    python -m ai.tui --quick  # Quick status (no interactive mode)
+"""
+
+from textual.app import App, ComposeResult
+from textual.containers import Container, Horizontal, Vertical
+from textual.widgets import (
+    Header, Footer, Static, DataTable, Log, TabbedContent, TabPane,
+    Label, ProgressBar, Button, Input,
+)
+from textual.timer import Timer
+from textual import work
+import json
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+# ── Data loaders ─────────────────────────────────────────────────────
+
+LEDGER_DIR = Path.home() / ".delimit" / "ledger"
+SWARM_DIR = Path.home() / ".delimit" / "swarm"
+MEMORY_DIR = Path.home() / ".delimit" / "memory"
+SESSIONS_DIR = Path.home() / ".delimit" / "sessions"
+
+
+def _load_ledger_items(status: str = "open", limit: int = 20) -> List[Dict]:
+    items = []
+    for fname in ("operations.jsonl", "strategy.jsonl"):
+        path = LEDGER_DIR / fname
+        if not path.exists():
+            continue
+        for line in path.read_text().strip().split("\n")[-200:]:
+            try:
+                d = json.loads(line)
+                if d.get("status") == status:
+                    items.append(d)
+            except json.JSONDecodeError:
+                continue
+    items.sort(key=lambda x: (0 if x.get("priority") == "P0" else 1 if x.get("priority") == "P1" else 2))
+    return items[:limit]
+
+
+def _load_swarm_status() -> Dict[str, Any]:
+    registry = SWARM_DIR / "agent_registry.json"
+    if not registry.exists():
+        return {"agents": 0, "ventures": 0}
+    try:
+        data = json.loads(registry.read_text())
+        agents = data.get("agents", {})
+        ventures = set(a.get("venture", "") for a in agents.values())
+        return {
+            "agents": len(agents),
+            "ventures": len(ventures),
+            "by_venture": {v: sum(1 for a in agents.values() if a.get("venture") == v) for v in ventures},
+        }
+    except (json.JSONDecodeError, KeyError):
+        return {"agents": 0, "ventures": 0}
+
+
+def _load_recent_sessions(limit: int = 5) -> List[Dict]:
+    if not SESSIONS_DIR.exists():
+        return []
+    sessions = []
+    for f in sorted(SESSIONS_DIR.glob("*.json"), reverse=True)[:limit]:
+        try:
+            sessions.append(json.loads(f.read_text()))
+        except (json.JSONDecodeError, KeyError):
+            continue
+    return sessions
+
+
+# ── Widgets ──────────────────────────────────────────────────────────
+
+class LedgerPanel(Static):
+    """Live ledger view — shows open items sorted by priority."""
+
+    def compose(self) -> ComposeResult:
+        yield DataTable(id="ledger-table")
+
+    def on_mount(self) -> None:
+        table = self.query_one("#ledger-table", DataTable)
+        table.add_columns("ID", "P", "Title", "Venture", "Type")
+        self._refresh_data()
+        self.set_interval(30, self._refresh_data)
+
+    def _refresh_data(self) -> None:
+        table = self.query_one("#ledger-table", DataTable)
+        table.clear()
+        for item in _load_ledger_items("open", 25):
+            table.add_row(
+                item.get("id", ""),
+                item.get("priority", ""),
+                item.get("title", "")[:60],
+                item.get("venture", "")[:15],
+                item.get("type", ""),
+            )
+
+
+class SwarmPanel(Static):
+    """Swarm status — agents, ventures, health."""
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="swarm-content")
+
+    def on_mount(self) -> None:
+        self._refresh_data()
+        self.set_interval(15, self._refresh_data)
+
+    def _refresh_data(self) -> None:
+        content = self.query_one("#swarm-content", Static)
+        swarm = _load_swarm_status()
+        lines = [
+            f"[bold cyan]Agents:[/] {swarm['agents']}  |  [bold cyan]Ventures:[/] {swarm['ventures']}",
+            "",
+        ]
+        for venture, count in swarm.get("by_venture", {}).items():
+            lines.append(f"  [green]{venture}[/]: {count} agents")
+        content.update("\n".join(lines))
+
+
+class SessionPanel(Static):
+    """Recent sessions — handoff history."""
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="session-content")
+
+    def on_mount(self) -> None:
+        self._refresh_data()
+
+    def _refresh_data(self) -> None:
+        content = self.query_one("#session-content", Static)
+        sessions = _load_recent_sessions(5)
+        if not sessions:
+            content.update("[dim]No sessions recorded yet.[/]")
+            return
+        lines = []
+        for s in sessions:
+            ts = s.get("timestamp", s.get("closed_at", ""))[:16]
+            summary = s.get("summary", "")[:80]
+            completed = len(s.get("items_completed", []))
+            lines.append(f"[dim]{ts}[/] — {summary}")
+            if completed:
+                lines.append(f"  [green]✓ {completed} items completed[/]")
+        content.update("\n".join(lines))
+
+
+class GovernanceBar(Static):
+    """Top status bar — governance health at a glance."""
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="gov-bar")
+
+    def on_mount(self) -> None:
+        self._refresh()
+        self.set_interval(60, self._refresh)
+
+    def _refresh(self) -> None:
+        bar = self.query_one("#gov-bar", Static)
+        ledger_count = len(_load_ledger_items("open", 999))
+        swarm = _load_swarm_status()
+        mode_file = Path.home() / ".delimit" / "enforcement_mode"
+        mode = mode_file.read_text().strip() if mode_file.exists() else "default"
+
+        bar.update(
+            f"  [bold magenta]</>[/] [bold]Delimit OS[/]  |  "
+            f"[cyan]Ledger:[/] {ledger_count} open  |  "
+            f"[cyan]Swarm:[/] {swarm['agents']} agents / {swarm['ventures']} ventures  |  "
+            f"[cyan]Mode:[/] {mode}  |  "
+            f"[dim]{time.strftime('%H:%M')}[/]"
+        )
+
+
+# ── Main App ─────────────────────────────────────────────────────────
+
+class DelimitOS(App):
+    """Delimit OS — the AI developer operating system."""
+
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+    #gov-bar {
+        height: 1;
+        background: $primary-background;
+        color: $text;
+        padding: 0 1;
+    }
+    TabbedContent {
+        height: 1fr;
+    }
+    DataTable {
+        height: 1fr;
+    }
+    #swarm-content, #session-content {
+        padding: 1;
+    }
+    """
+
+    TITLE = "Delimit OS"
+    SUB_TITLE = "AI Developer Operating System"
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("l", "focus_ledger", "Ledger"),
+        ("s", "focus_swarm", "Swarm"),
+        ("h", "focus_sessions", "History"),
+        ("r", "refresh", "Refresh"),
+        ("t", "think", "Think"),
+        ("b", "build", "Build"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        yield GovernanceBar()
+        with TabbedContent():
+            with TabPane("Ledger", id="tab-ledger"):
+                yield LedgerPanel()
+            with TabPane("Swarm", id="tab-swarm"):
+                yield SwarmPanel()
+            with TabPane("Sessions", id="tab-sessions"):
+                yield SessionPanel()
+        yield Footer()
+
+    def action_focus_ledger(self) -> None:
+        self.query_one(TabbedContent).active = "tab-ledger"
+
+    def action_focus_swarm(self) -> None:
+        self.query_one(TabbedContent).active = "tab-swarm"
+
+    def action_focus_sessions(self) -> None:
+        self.query_one(TabbedContent).active = "tab-sessions"
+
+    def action_refresh(self) -> None:
+        for panel in self.query(LedgerPanel):
+            panel._refresh_data()
+        for panel in self.query(SwarmPanel):
+            panel._refresh_data()
+        for panel in self.query(SessionPanel):
+            panel._refresh_data()
+        self.query_one(GovernanceBar)._refresh()
+
+    def action_think(self) -> None:
+        self.notify("Deliberation triggered — check ledger for results", title="Think")
+
+    def action_build(self) -> None:
+        self.notify("Build loop started — swarm dispatching tasks", title="Build")
+
+
+def main():
+    """Entry point for 'delimit' command."""
+    import sys
+    if "--quick" in sys.argv:
+        # Quick status mode — no interactive TUI
+        from rich.console import Console
+        from rich.table import Table
+
+        console = Console()
+        console.print("\n[bold magenta]</>[/] [bold]Delimit OS[/]\n")
+
+        swarm = _load_swarm_status()
+        items = _load_ledger_items("open", 10)
+
+        console.print(f"[cyan]Swarm:[/] {swarm['agents']} agents across {swarm['ventures']} ventures")
+        console.print(f"[cyan]Ledger:[/] {len(items)} open items\n")
+
+        if items:
+            table = Table(title="Open Items")
+            table.add_column("ID", style="dim")
+            table.add_column("P", style="bold")
+            table.add_column("Title")
+            table.add_column("Venture", style="green")
+            for item in items[:10]:
+                table.add_row(
+                    item.get("id", ""),
+                    item.get("priority", ""),
+                    item.get("title", "")[:60],
+                    item.get("venture", "")[:15],
+                )
+            console.print(table)
+        return
+
+    app = DelimitOS()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "delimit-cli",
   "mcpName": "io.github.delimit-ai/delimit-mcp-server",
-  "version": "4.0.5",
+  "version": "4.0.6",
   "description": "Unify Claude Code, Codex, Cursor, and Gemini CLI with persistent context, governance, and multi-model debate.",
   "main": "index.js",
   "files": [