lang2sim 2.0.0__py3-none-any.whl

lang2sim/cli/widgets/__init__.py

@@ -0,0 +1,16 @@
+from .thought_box import ThoughtBox
+from .action_pill import ActionPill
+from .prompt_card import PromptCard
+from .telemetry_sidebar import TelemetrySidebar
+from .command_card import CommandCard
+from .plan_card import PlanCard
+
+__all__ = [
+    "ThoughtBox",
+    "ActionPill",
+    "PromptCard",
+    "TelemetrySidebar",
+    "CommandCard",
+    "PlanCard",
+]
+

lang2sim/cli/widgets/action_pill.py

@@ -0,0 +1,67 @@
+"""
+Tool Action Status Pill Widget
+File: lang2sim/cli/widgets/action_pill.py
+"""
+
+from textual.widget import Widget
+from textual.widgets import Static
+from textual.reactive import reactive
+
+class ActionPill(Widget):
+    """Tool invocation status badge pill (e.g. ■ solve_spatial_layout · 0.4s · completed)."""
+
+    DEFAULT_CSS = """
+    ActionPill {
+        height: auto;
+        background: #161616;
+        border: solid #222222;
+        padding: 0 1;
+        margin-bottom: 1;
+    }
+    """
+
+    tool_name = reactive("")
+    duration_str = reactive("0.0s")
+    status = reactive("running")  # running, completed, error
+
+    def __init__(self, tool_name: str, duration_str: str = "0.4s", status: str = "completed", **kwargs):
+        super().__init__(classes="action-pill", **kwargs)
+        self.tool_name = tool_name
+        self.duration_str = duration_str
+        self.status = status
+
+    def compose(self):
+        yield Static(self._format_content(), id="pill-content")
+
+    def _format_content(self) -> str:
+        icon = "[#38bdf8]■[/]"
+        if self.status == "completed":
+            status_text = "[#2ed573]completed[/]"
+        elif self.status == "running":
+            status_text = "[#ffa502]running...[/]"
+        else:
+            status_text = "[#ff4757]failed[/]"
+        return f"{icon}  [bold #f1f2f6]{self.tool_name}[/] · [#a4b0be]{self.duration_str}[/] · {status_text}"
+
+    def set_running(self) -> None:
+        self.status = "running"
+        try:
+            self.query_one("#pill-content", Static).update(self._format_content())
+        except Exception:
+            pass
+
+    def set_completed(self, duration: str = "0.5s") -> None:
+        self.status = "completed"
+        self.duration_str = duration
+        try:
+            self.query_one("#pill-content", Static).update(self._format_content())
+        except Exception:
+            pass
+
+    def set_failed(self, duration: str = "0.5s") -> None:
+        self.status = "error"
+        self.duration_str = duration
+        try:
+            self.query_one("#pill-content", Static).update(self._format_content())
+        except Exception:
+            pass

lang2sim/cli/widgets/command_card.py

@@ -0,0 +1,265 @@
+"""
+Interactive Terminal Command & Permission Card Widget
+File: lang2sim/cli/widgets/command_card.py
+"""
+
+from typing import Optional, Dict, Any
+from textual.widget import Widget
+from textual.widgets import Static, Button
+from textual.containers import Horizontal, Vertical
+from textual.message import Message
+from textual.binding import Binding
+
+
+class CommandCard(Widget):
+    """
+    OpenCode/Antigravity-style Interactive Terminal Command Card.
+    Presents proposed commands to the user, asks for approval, runs execution,
+    and displays exit codes, execution duration, and terminal stdout/stderr.
+    """
+
+    DEFAULT_CSS = """
+    CommandCard {
+        height: auto;
+        background: #111114;
+        border: solid #27272a;
+        border-left: thick #ffa502;
+        padding: 1 1;
+        margin-bottom: 1;
+    }
+
+    CommandCard.status-running {
+        border-left: thick #38bdf8;
+    }
+
+    CommandCard.status-completed {
+        border-left: thick #2ed573;
+    }
+
+    CommandCard.status-failed {
+        border-left: thick #ff4757;
+    }
+
+    CommandCard.status-rejected {
+        border-left: thick #747d8c;
+    }
+
+    .cmd-header {
+        height: 1;
+        margin-bottom: 1;
+    }
+
+    .cmd-title {
+        color: #f1f2f6;
+        text-style: bold;
+    }
+
+    .cmd-badge {
+        text-align: right;
+    }
+
+    .cmd-snippet {
+        background: #09090b;
+        border: solid #1e1e24;
+        color: #38bdf8;
+        padding: 0 1;
+        margin-bottom: 1;
+        height: auto;
+    }
+
+    .cmd-actions {
+        height: 3;
+        margin-top: 1;
+        align-horizontal: left;
+    }
+
+    .cmd-actions Button {
+        margin-right: 2;
+        min-width: 16;
+        height: 3;
+    }
+
+    .cmd-output {
+        background: #08080a;
+        border: solid #1c1c22;
+        color: #ced6e0;
+        padding: 0 1;
+        margin-top: 1;
+        height: auto;
+        max-height: 12;
+        overflow-y: auto;
+    }
+    """
+
+    BINDINGS = [
+        Binding("y", "approve", "Approve", show=False),
+        Binding("enter", "approve", "Approve", show=False),
+        Binding("a", "always_allow", "Always Allow", show=False),
+        Binding("n", "reject", "Reject", show=False),
+        Binding("escape", "reject", "Reject", show=False),
+    ]
+
+    class Approved(Message):
+        """User approved command execution."""
+        def __init__(self, event_id: str, always_allow: bool = False):
+            super().__init__()
+            self.event_id = event_id
+            self.always_allow = always_allow
+
+    class Rejected(Message):
+        """User rejected command execution."""
+        def __init__(self, event_id: str):
+            super().__init__()
+            self.event_id = event_id
+
+    def __init__(
+        self,
+        event_id: str,
+        command: str,
+        tool_name: str = "run_command",
+        arguments: Optional[Dict[str, Any]] = None,
+        permission_required: bool = True,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.event_id = event_id
+        self.command = command
+        self.tool_name = tool_name
+        self.arguments = arguments or {}
+        self.permission_required = permission_required
+        self.status = "awaiting_permission" if permission_required else "running"
+        self.exit_code: Optional[int] = None
+        self.duration_str: str = "0.0s"
+        self.stdout: str = ""
+        self.stderr: str = ""
+
+    def compose(self):
+        # Header: Title + Status Badge
+        with Horizontal(classes="cmd-header"):
+            yield Static(f"⚡ [bold #f1f2f6]Terminal Command[/] [#747d8c]({self.tool_name})[/]", classes="cmd-title")
+            yield Static(self._format_badge(), id="cmd-badge", classes="cmd-badge")
+
+        # Command Code Snippet
+        yield Static(f"[bold #38bdf8]$[/] [bold #ffffff]{self.command}[/]", classes="cmd-snippet")
+
+        # Interactive Approval Buttons
+        if self.status == "awaiting_permission":
+            with Horizontal(id="cmd-actions", classes="cmd-actions"):
+                yield Button("Approve & Run (y)", id=f"btn-approve-{self.event_id}", variant="success")
+                yield Button("Always Allow (a)", id=f"btn-always-{self.event_id}", variant="default")
+                yield Button("Reject (n)", id=f"btn-reject-{self.event_id}", variant="error")
+
+        # Output Terminal Container (hidden until execution completes)
+        yield Static("", id="cmd-output", classes="cmd-output", expand=True)
+
+    def on_mount(self) -> None:
+        self._update_classes()
+        out_widget = self.query_one("#cmd-output", Static)
+        out_widget.display = False
+        if self.status == "awaiting_permission":
+            try:
+                self.query_one(f"#btn-approve-{self.event_id}", Button).focus()
+            except Exception:
+                pass
+
+    def _format_badge(self) -> str:
+        if self.status == "awaiting_permission":
+            return "[bold #ffa502]⏳ AWAITING PERMISSION[/]"
+        elif self.status == "running":
+            return "[bold #38bdf8]● RUNNING...[/]"
+        elif self.status == "completed":
+            code = self.exit_code if self.exit_code is not None else 0
+            if code == 0:
+                return f"[bold #2ed573]✔ EXIT 0[/] [#747d8c]· {self.duration_str}[/]"
+            else:
+                return f"[bold #ff4757]✖ EXIT {code}[/] [#747d8c]· {self.duration_str}[/]"
+        elif self.status == "rejected":
+            return "[bold #747d8c]⛔ REJECTED[/]"
+        return f"[#747d8c]{self.status}[/]"
+
+    def _update_classes(self) -> None:
+        self.remove_class("status-running")
+        self.remove_class("status-completed")
+        self.remove_class("status-failed")
+        self.remove_class("status-rejected")
+
+        if self.status == "running":
+            self.add_class("status-running")
+        elif self.status == "completed":
+            if (self.exit_code or 0) == 0:
+                self.add_class("status-completed")
+            else:
+                self.add_class("status-failed")
+        elif self.status == "rejected":
+            self.add_class("status-rejected")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn_id = event.button.id or ""
+        if "btn-approve" in btn_id:
+            self.action_approve()
+        elif "btn-always" in btn_id:
+            self.action_always_allow()
+        elif "btn-reject" in btn_id:
+            self.action_reject()
+
+    def action_approve(self) -> None:
+        if self.status != "awaiting_permission":
+            return
+        self.set_running()
+        self.post_message(self.Approved(self.event_id, always_allow=False))
+
+    def action_always_allow(self) -> None:
+        if self.status != "awaiting_permission":
+            return
+        self.set_running()
+        self.post_message(self.Approved(self.event_id, always_allow=True))
+
+    def action_reject(self) -> None:
+        if self.status != "awaiting_permission":
+            return
+        self.status = "rejected"
+        self._update_classes()
+        self._remove_actions_row()
+        self.query_one("#cmd-badge", Static).update(self._format_badge())
+        self.post_message(self.Rejected(self.event_id))
+
+    def _remove_actions_row(self) -> None:
+        try:
+            actions_row = self.query_one("#cmd-actions")
+            actions_row.remove()
+        except Exception:
+            pass
+
+    def set_running(self) -> None:
+        self.status = "running"
+        self._update_classes()
+        self._remove_actions_row()
+        try:
+            self.query_one("#cmd-badge", Static).update(self._format_badge())
+        except Exception:
+            pass
+
+    def set_result(self, exit_code: int, duration_str: str, stdout: str = "", stderr: str = "") -> None:
+        self.status = "completed"
+        self.exit_code = exit_code
+        self.duration_str = duration_str
+        self.stdout = stdout
+        self.stderr = stderr
+        self._update_classes()
+        self._remove_actions_row()
+
+        try:
+            self.query_one("#cmd-badge", Static).update(self._format_badge())
+            out_widget = self.query_one("#cmd-output", Static)
+            lines = []
+            if stdout.strip():
+                lines.append(f"[#a4b0be]{stdout.strip()}[/]")
+            if stderr.strip():
+                lines.append(f"[#ff6b81]{stderr.strip()}[/]")
+            if not lines:
+                lines.append("[italic #57606f](No output produced)[/]")
+
+            out_widget.update("\n".join(lines))
+            out_widget.display = True
+        except Exception:
+            pass

lang2sim/cli/widgets/plan_card.py

@@ -0,0 +1,106 @@
+"""
+Stage-wise Execution Plan Card Widget
+File: lang2sim/cli/widgets/plan_card.py
+"""
+
+from typing import List, Dict, Any, Optional
+from textual.widget import Widget
+from textual.widgets import Static
+from textual.containers import Horizontal, Vertical
+
+
+class PlanCard(Widget):
+    """
+    Antigravity/OpenCode-style Stage-wise Execution Plan Card.
+    Visualizes multi-step autonomous workflows ([ ] -> [▶] -> [✔]).
+    """
+
+    DEFAULT_CSS = """
+    PlanCard {
+        height: auto;
+        background: #111114;
+        border: solid #27272a;
+        border-left: thick #a78bfa;
+        padding: 0 1;
+        margin-top: 1;
+        margin-bottom: 1;
+    }
+
+    .plan-header {
+        height: 1;
+        margin-bottom: 1;
+    }
+
+    .plan-title {
+        color: #f1f2f6;
+        text-style: bold;
+    }
+
+    .plan-counter {
+        text-align: right;
+        color: #a78bfa;
+    }
+
+    .plan-step {
+        height: auto;
+        padding: 0 1;
+        margin-bottom: 0;
+    }
+    """
+
+    def __init__(
+        self,
+        steps: List[str],
+        title: str = "Autonomous Execution Plan",
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.plan_title = title
+        # Each step: {"title": str, "status": "pending"|"running"|"completed"|"failed", "detail": ""}
+        self.steps: List[Dict[str, Any]] = [
+            {"title": s, "status": "pending", "detail": ""} for s in steps
+        ]
+        if self.steps:
+            self.steps[0]["status"] = "running"
+
+    def compose(self):
+        with Horizontal(classes="plan-header"):
+            yield Static(f"📋 [bold #f1f2f6]{self.plan_title}[/]", classes="plan-title")
+            yield Static(self._format_counter(), id="plan-counter", classes="plan-counter")
+
+        for i, step in enumerate(self.steps):
+            yield Static(self._format_step(i), id=f"step-{i}", classes="plan-step")
+
+    def _format_counter(self) -> str:
+        completed = sum(1 for s in self.steps if s["status"] == "completed")
+        total = len(self.steps)
+        if completed == total and total > 0:
+            return f"[bold #2ed573]All {total} Steps Completed ✔[/]"
+        return f"[#ced6e0]{completed}/{total} Completed[/]"
+
+    def _format_step(self, index: int) -> str:
+        step = self.steps[index]
+        status = step["status"]
+        title = step["title"]
+        detail = f" [#747d8c]({step['detail']})[/]" if step.get("detail") else ""
+
+        if status == "completed":
+            return f"  [bold #2ed573]✔[/]  [bold #ffffff]{title}[/]{detail}"
+        elif status == "running":
+            return f"  [bold #38bdf8]▶[/]  [bold #38bdf8]{title}[/]{detail}"
+        elif status == "failed":
+            return f"  [bold #ff4757]✖[/]  [bold #ff4757]{title}[/]{detail}"
+        else:
+            return f"  [#57606f][ ][/]  [#a4b0be]{title}[/]"
+
+    def update_step(self, index: int, status: str, detail: str = "") -> None:
+        """Updates the status and detail of a specific step."""
+        if 0 <= index < len(self.steps):
+            self.steps[index]["status"] = status
+            if detail:
+                self.steps[index]["detail"] = detail
+            try:
+                self.query_one(f"#step-{index}", Static).update(self._format_step(index))
+                self.query_one("#plan-counter", Static).update(self._format_counter())
+            except Exception:
+                pass

lang2sim/cli/widgets/prompt_card.py

@@ -0,0 +1,96 @@
+"""
+Input Card Widget (Floating & Sticky Docked)
+File: lang2sim/cli/widgets/prompt_card.py
+"""
+
+from textual.widget import Widget
+from textual.widgets import Input, Static
+from textual.containers import Vertical
+from textual.message import Message
+
+
+class PromptCard(Widget):
+    """Input card with cyan vertical bar and model status badge row."""
+
+    DEFAULT_CSS = """
+    PromptCard {
+        height: auto;
+        max-height: 5;
+        background: #18181b;
+        border-left: thick #00d2ff;
+        padding: 1 2;
+    }
+
+    PromptCard > Vertical {
+        height: auto;
+    }
+
+    PromptCard Input {
+        background: transparent;
+        border: none !important;
+        height: 1;
+        padding: 0;
+        margin: 0;
+        color: #ffffff;
+    }
+
+    PromptCard Input:focus {
+        border: none !important;
+        background: transparent;
+    }
+
+    PromptCard Input > .input--placeholder {
+        color: #6b7280;
+    }
+
+    PromptCard Input > .input--cursor {
+        background: #00d2ff;
+        color: #000000;
+    }
+
+    PromptCard #badge-row {
+        height: 1;
+        margin-top: 1;
+    }
+    """
+
+    class Submitted(Message):
+        """Dispatched when the user presses Enter in the prompt card."""
+
+        def __init__(self, value: str) -> None:
+            self.value = value
+            super().__init__()
+
+    def __init__(
+        self,
+        placeholder: str = "Ask anything.. 'Spawn 14x10m warehouse with 8 racks, send AMR to rack 5'",
+        card_id: str = "prompt-input",
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.placeholder_text = placeholder
+        self.card_id = card_id
+
+    def compose(self):
+        with Vertical():
+            yield Input(placeholder=self.placeholder_text, id=self.card_id)
+            yield Static(
+                "[bold white on #2563eb] Build [/] [#4b5563]·[/] "
+                "[#9ca3af]Nemotron 3 Ultra 550B A55B Nvidia[/] [#4b5563]·[/] "
+                "[bold white on #d97706] medium [/]",
+                id="badge-row",
+            )
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        value = event.value.strip()
+        if value:
+            event.input.value = ""
+            self.post_message(self.Submitted(value))
+
+    def focus_input(self) -> None:
+        try:
+            inp = self.query_one(Input)
+            inp.focus()
+        except Exception:
+            pass
+

lang2sim/cli/widgets/telemetry_sidebar.py

@@ -0,0 +1,117 @@
+"""
+Telemetry Sidebar Widget (20% Workspace Right Pane)
+File: lang2sim/cli/widgets/telemetry_sidebar.py
+"""
+
+from textual.widget import Widget
+from textual.widgets import Static
+from textual.containers import Vertical
+from textual import work
+from dataclasses import dataclass
+
+@dataclass
+class TelemetryData:
+    sim_state: str = "Idle (Offline)"
+    sim_time: str = "00:00.0"
+    rtf: str = "0.0x"
+    robot_x: float = 0.0
+    robot_y: float = 0.0
+    speed: float = 0.0
+    clearance: float = 0.0
+    bumper_force: float = 0.0
+    collision_count: int = 0
+    ate_drift_m: float = 0.0
+    tokens_used: int = 0
+    context_capacity_pct: int = 0
+
+class TelemetrySidebar(Widget):
+    """Right-hand sidebar displaying live simulation, robot kinematics, bumper, and context stats."""
+
+    DEFAULT_CSS = """
+    TelemetrySidebar {
+        width: 100%;
+        height: 100%;
+        background: #0e0e0e;
+        padding: 1;
+    }
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(id="telemetry-sidebar", **kwargs)
+        self.data = TelemetryData()
+
+    def compose(self):
+        with Vertical():
+            yield Static("[bold #f1f2f6]SIMULATION[/]", classes="sidebar-section-title")
+            yield Static(self._format_sim_state(), id="sim-state", classes="sidebar-metric")
+            yield Static(self._format_sim_time(), id="sim-time", classes="sidebar-metric")
+            yield Static(self._format_rtf(), id="sim-rtf", classes="sidebar-metric")
+
+            yield Static("[bold #f1f2f6]ROBOT TELEMETRY[/]", classes="sidebar-section-title")
+            yield Static(self._format_pose(), id="robot-pose", classes="sidebar-metric")
+            yield Static(self._format_speed(), id="robot-speed", classes="sidebar-metric")
+            yield Static(self._format_clearance(), id="robot-clearance", classes="sidebar-metric")
+            yield Static(self._format_ate_drift(), id="robot-drift", classes="sidebar-metric")
+
+            yield Static("[bold #f1f2f6]BUMPER[/]", classes="sidebar-section-title")
+            yield Static(self._format_bumper_force(), id="bumper-force", classes="sidebar-metric")
+            yield Static(self._format_collision_count(), id="collision-count", classes="sidebar-metric")
+
+            yield Static("[bold #f1f2f6]CONTEXT[/]", classes="sidebar-section-title")
+            yield Static(self._format_context(), id="token-context", classes="sidebar-metric")
+
+    def _format_sim_state(self) -> str:
+        color = "#2ed573" if "Active" in self.data.sim_state else "#ffa502"
+        return f"State: [{color}]{self.data.sim_state}[/]"
+
+    def _format_sim_time(self) -> str:
+        return f"Sim Time: [#ced6e0]{self.data.sim_time}[/]"
+
+    def _format_rtf(self) -> str:
+        return f"RTF: [#ced6e0]{self.data.rtf}[/]"
+
+    def _format_pose(self) -> str:
+        return f"Pose: [#ced6e0]({self.data.robot_x:.2f}m, {self.data.robot_y:.2f}m)[/]"
+
+    def _format_speed(self) -> str:
+        return f"Speed: [#ced6e0]{self.data.speed:.2f}m/s[/]"
+
+    def _format_clearance(self) -> str:
+        color = "#ff4757" if self.data.clearance < 0.25 else "#2ed573"
+        return f"Clearance: [{color}]{self.data.clearance:.2f}m[/]"
+
+    def _format_ate_drift(self) -> str:
+        color = "#ff4757" if self.data.ate_drift_m > 0.35 else "#2ed573"
+        alert = " [#ff4757]⚠ divergence[/]" if self.data.ate_drift_m > 0.35 else ""
+        return f"Drift (ATE): [{color}]{self.data.ate_drift_m:.2f}m[/]{alert}"
+
+    def _format_bumper_force(self) -> str:
+        return f"Forces: [#ced6e0]{self.data.bumper_force:.1f} N[/]"
+
+    def _format_collision_count(self) -> str:
+        color = "#ff4757" if self.data.collision_count > 0 else "#ced6e0"
+        return f"Hits: [{color}]{self.data.collision_count}[/]"
+
+    def _format_context(self) -> str:
+        spend = (self.data.tokens_used / 1_000_000.0) * 0.20
+        return f"[#ced6e0]{self.data.tokens_used:,} tokens\n{self.data.context_capacity_pct}% used\n${spend:.4f} spent[/]"
+
+    def update_telemetry(self, **kwargs) -> None:
+        """Update any metric dynamically and refresh corresponding label."""
+        for key, value in kwargs.items():
+            if hasattr(self.data, key):
+                setattr(self.data, key, value)
+        
+        try:
+            self.query_one("#sim-state", Static).update(self._format_sim_state())
+            self.query_one("#sim-time", Static).update(self._format_sim_time())
+            self.query_one("#sim-rtf", Static).update(self._format_rtf())
+            self.query_one("#robot-pose", Static).update(self._format_pose())
+            self.query_one("#robot-speed", Static).update(self._format_speed())
+            self.query_one("#robot-clearance", Static).update(self._format_clearance())
+            self.query_one("#robot-drift", Static).update(self._format_ate_drift())
+            self.query_one("#bumper-force", Static).update(self._format_bumper_force())
+            self.query_one("#collision-count", Static).update(self._format_collision_count())
+            self.query_one("#token-context", Static).update(self._format_context())
+        except Exception:
+            pass