limbo-code 0.1.0__py3-none-any.whl

limbo/ui/widgets/input.py

@@ -0,0 +1,199 @@
+"""User input widget."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.cells import cell_len
+from textual.binding import Binding
+from textual.message import Message
+from textual.widgets import TextArea
+
+# Widget height is text rows + 2 rows of round border. The input starts at
+# one text row (height 3) and grows up to MAX_TEXT_ROWS before scrolling.
+MIN_TEXT_ROWS = 1
+MAX_TEXT_ROWS = 8
+
+
+class UserSubmitted(Message):
+    """Event emitted when the user submits a message."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__()
+
+
+class InputWidget(TextArea):
+    """Multi-line input that submits on Enter (Shift+Enter for newline).
+
+    The widget grows vertically as lines are added (up to MAX_TEXT_ROWS),
+    and recalls previously submitted input with the up/down arrow keys
+    (shell-style history, in-memory per session).
+
+    When the screen's slash-command menu is open, Enter/Tab/up/down/Esc are
+    redirected to the menu instead of their default behavior.
+
+    Styles live in ``limbo/ui/app.tcss``.
+    """
+
+    # Use priority bindings so these actions run before TextArea's default
+    # key handling, which would otherwise insert a newline on Enter.
+    BINDINGS = [
+        Binding("enter", "submit", "Submit", priority=True),
+        Binding("shift+enter", "newline", "Newline", priority=True),
+        Binding("up", "menu_up", show=False, priority=True),
+        Binding("down", "menu_down", show=False, priority=True),
+        Binding("tab", "menu_complete", show=False, priority=True),
+        Binding("escape", "menu_cancel", show=False, priority=True),
+    ]
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.show_line_numbers = False
+        # Shell-style input history (in-memory, per session).
+        self._history: list[str] = []
+        self._history_index: int | None = None
+        self._draft: str = ""
+        # Last value applied via history recall; used to tell recall edits
+        # apart from manual edits in the (async) Changed handler.
+        self._history_value: str | None = None
+
+    def _menu_screen(self):
+        """The screen, but only when its slash-command menu is open."""
+        screen = self.screen
+        if getattr(screen, "slash_menu_open", False):
+            return screen
+        return None
+
+    # -- auto-growing height ---------------------------------------------------
+
+    def _visual_rows(self) -> int:
+        """Number of display rows the current text occupies (soft-wrapped)."""
+        width = self.wrap_width
+        rows = 0
+        for line in self.document.lines:
+            length = cell_len(line)
+            if width > 0:
+                rows += max(1, -(-length // width))
+            else:
+                rows += 1
+        return max(MIN_TEXT_ROWS, rows)
+
+    def _auto_resize(self) -> None:
+        height = min(self._visual_rows(), MAX_TEXT_ROWS) + 2
+        current = self.styles.height
+        if current is not None and getattr(current, "value", None) == height:
+            return
+        self.styles.height = height
+
+    def on_text_area_changed(self, event: TextArea.Changed) -> None:
+        if event.text_area is not self:
+            return
+        self._auto_resize()
+        # Editing by hand while browsing history cancels the recall position,
+        # so the next up/down starts fresh from the latest entry. Changes
+        # applied by history recall itself keep the navigation position.
+        if self._history_value is not None and self.text == self._history_value:
+            return
+        self._history_value = None
+        self._history_index = None
+
+    def on_resize(self) -> None:
+        # Terminal width changes affect soft-wrapping, hence the row count.
+        self._auto_resize()
+
+    # -- submission ------------------------------------------------------------
+
+    def action_submit(self) -> None:
+        screen = self._menu_screen()
+        if screen is not None and screen.slash_menu_complete(execute=True):
+            return
+        text = self.text.strip()
+        if text:
+            if not self._history or self._history[-1] != text:
+                self._history.append(text)
+            self._history_index = None
+            self._history_value = None
+            self._draft = ""
+            self.post_message(UserSubmitted(text))
+            self.clear()
+
+    def action_newline(self) -> None:
+        """Insert a newline at the current cursor position."""
+        self.insert("\n")
+
+    # -- history recall --------------------------------------------------------
+
+    def _set_text_from_history(self, value: str) -> None:
+        self._history_value = value
+        self.text = value
+        self.move_cursor(self.document.end)
+
+    def _cursor_on_first_visual_row(self) -> bool:
+        """Whether the cursor sits on the first *visual* (soft-wrapped) row.
+
+        With soft wrap a single logical line spans several display rows; the
+        logical row from ``cursor_location`` stays 0, so the column is used
+        to approximate the visual position (wide chars make this approximate).
+        """
+        row, col = self.cursor_location
+        if row > 0:
+            return False
+        width = self.wrap_width
+        return width <= 0 or col < width
+
+    def _history_prev(self) -> None:
+        if not self._history:
+            self.action_cursor_up()
+            return
+        if self._history_index is None:
+            # Multi-line/soft-wrapped input: up moves the cursor until it
+            # reaches the first visual row; only then does it start
+            # recalling history.
+            if not self._cursor_on_first_visual_row():
+                self.action_cursor_up()
+                return
+            self._draft = self.text
+            self._history_index = len(self._history) - 1
+        else:
+            self._history_index = max(0, self._history_index - 1)
+        self._set_text_from_history(self._history[self._history_index])
+
+    def _history_next(self) -> None:
+        if self._history_index is None:
+            self.action_cursor_down()
+            return
+        self._history_index += 1
+        if self._history_index >= len(self._history):
+            self._history_index = None
+            self._set_text_from_history(self._draft)
+        else:
+            self._set_text_from_history(self._history[self._history_index])
+
+    # -- slash-menu key redirection --------------------------------------------
+
+    def action_menu_up(self) -> None:
+        screen = self._menu_screen()
+        if screen is None:
+            self._history_prev()
+        else:
+            screen.slash_menu_move(-1)
+
+    def action_menu_down(self) -> None:
+        screen = self._menu_screen()
+        if screen is None:
+            self._history_next()
+        else:
+            screen.slash_menu_move(1)
+
+    def action_menu_complete(self) -> None:
+        screen = self._menu_screen()
+        if screen is None:
+            self.screen.focus_next()
+        else:
+            screen.slash_menu_complete(execute=False)
+
+    def action_menu_cancel(self) -> None:
+        screen = self._menu_screen()
+        if screen is not None:
+            screen.slash_menu_close()

limbo/ui/widgets/status_bar.py

@@ -0,0 +1,32 @@
+"""Top status bar: agent state on the left, model/workdir on the right."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widgets import Static
+
+
+class StatusBar(Horizontal):
+    """One-line status bar docked at the top of the screen."""
+
+    def __init__(self, model: str, workdir: str, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        # NOTE: attribute names must not collide with MessagePump internals
+        # (e.g. `_context` is a method on MessagePump).
+        self._state_label = Static("● idle", id="statusbar-state", markup=False)
+        self._context_label = Static(
+            f"{model} · {workdir}", id="statusbar-context", markup=False
+        )
+
+    def compose(self) -> ComposeResult:
+        yield self._state_label
+        yield self._context_label
+
+    def set_state(self, text: str, style: str = "idle") -> None:
+        """Update the left side. ``style`` is one of idle/thinking/tool."""
+        self._state_label.update(f"● {text}")
+        self._state_label.set_class(style == "thinking", "thinking")
+        self._state_label.set_class(style == "tool", "tool")

limbo/ui/widgets/tool_card.py

@@ -0,0 +1,179 @@
+"""Inline tool-call card shown in the chat flow.
+
+A tool card renders as a single summary line (state symbol + tool name +
+argument summary + elapsed time) and can be expanded to show the full tool
+output. State machine: running → success | error.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.css.query import NoMatches
+from textual.widgets import RichLog, Static
+
+_STATE_SYMBOLS = {
+    "running": "…",
+    "success": "✓",
+    "error": "✗",
+}
+_STATE_LABELS = {
+    "running": "运行中",
+    "success": "",
+    "error": "失败",
+}
+
+# Argument keys worth showing in the one-line summary, in priority order.
+_SUMMARY_KEYS = ("path", "command", "pattern", "old_text")
+
+
+class ToolCard(Vertical):
+    """One-line tool summary that expands to show full output."""
+
+    def __init__(
+        self,
+        tool_id: str,
+        name: str,
+        arguments: dict[str, Any],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.tool_id = tool_id
+        self.tool_name = name
+        self.arguments = arguments
+        self.state = "running"
+        self._started = time.monotonic()
+        self._elapsed: float | None = None
+        self._has_body = False
+        self._body_content: tuple[str, str | None] | None = None
+        self.add_class("running")
+
+    def compose(self) -> ComposeResult:
+        yield Static(self._header_text(), classes="tool-header", markup=False)
+        body = RichLog(classes="tool-body", wrap=True, max_lines=1000)
+        body.display = False
+        yield body
+
+    def on_mount(self) -> None:
+        # State transitions may have happened before composition finished
+        # (events can arrive in the same loop turn as the card creation).
+        self._refresh_header()
+        if self._body_content is not None:
+            self._write_body(*self._body_content)
+
+    @property
+    def header(self) -> Static:
+        return self.query_one(".tool-header", Static)
+
+    @property
+    def body(self) -> RichLog:
+        return self.query_one(".tool-body", RichLog)
+
+    # -- state transitions -------------------------------------------------
+
+    def set_success(self, output: str) -> None:
+        self._set_state("success")
+        self._set_body(output, lexer=self._lexer_for_body())
+
+    def set_error(self, error: str) -> None:
+        self._set_state("error")
+        self._set_body(error)
+
+    # -- expansion ----------------------------------------------------------
+
+    def toggle(self) -> None:
+        if self._has_body:
+            self.body.display = not self.body.display
+
+    def on_click(self) -> None:
+        self.toggle()
+
+    # -- internals ----------------------------------------------------------
+
+    def _set_state(self, state: str) -> None:
+        if self.state != state:
+            self.remove_class(self.state)
+            self.state = state
+            self.add_class(state)
+        if state != "running" and self._elapsed is None:
+            self._elapsed = time.monotonic() - self._started
+        self._refresh_header()
+
+    def _refresh_header(self) -> None:
+        try:
+            self.header.update(self._header_text())
+        except NoMatches:
+            pass  # Not composed yet; on_mount refreshes.
+
+    def _set_body(self, content: str, lexer: str | None = None) -> None:
+        if not content:
+            return
+        self._has_body = True
+        self._body_content = (content, lexer)
+        try:
+            self._write_body(content, lexer)
+        except NoMatches:
+            pass  # Not composed yet; on_mount writes the body.
+
+    def _write_body(self, content: str, lexer: str | None = None) -> None:
+        renderable: Any = Text(content)
+        if lexer:
+            try:
+                from rich.syntax import Syntax
+
+                renderable = Syntax(content, lexer, theme="ansi_dark")
+            except Exception:  # noqa: BLE001 - fall back to plain text
+                renderable = Text(content)
+        self.body.write(renderable)
+
+    def _lexer_for_body(self) -> str | None:
+        """Pick a syntax-highlighting lexer based on the tool and its target."""
+        if self.tool_name == "edit":
+            return "diff"
+        if self.tool_name in ("read", "write"):
+            path = self.arguments.get("path")
+            if isinstance(path, str) and path:
+                try:
+                    from pygments.lexers import (  # type: ignore[import-untyped]
+                        get_lexer_for_filename,
+                    )
+                    from pygments.util import (  # type: ignore[import-untyped]
+                        ClassNotFound,
+                    )
+
+                    try:
+                        aliases: list[str] = get_lexer_for_filename(path).aliases
+                        return aliases[0] if aliases else None
+                    except ClassNotFound:
+                        return None
+                except Exception:  # noqa: BLE001
+                    return None
+        return None
+
+    def _summary(self) -> str:
+        for key in _SUMMARY_KEYS:
+            value = self.arguments.get(key)
+            if isinstance(value, str) and value:
+                first_line = value.splitlines()[0] if value.strip() else value
+                return (
+                    first_line if len(first_line) <= 60 else first_line[:57] + "..."
+                )
+        return ""
+
+    def _header_text(self) -> str:
+        symbol = _STATE_SYMBOLS.get(self.state, "?")
+        parts = [f"{symbol} {self.tool_name}"]
+        summary = self._summary()
+        if summary:
+            parts.append(summary)
+        label = _STATE_LABELS.get(self.state, "")
+        if label:
+            parts.append(f"({label})")
+        if self._elapsed is not None and self._elapsed >= 0.05:
+            parts.append(f"{self._elapsed:.1f}s")
+        return "  ".join(parts)

limbo_code-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: limbo-code
+Version: 0.1.0
+Summary: A minimal terminal AI coding agent
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: openai>=1.30
+Requires-Dist: pydantic>=2.0
+Requires-Dist: textual>=0.58
+Requires-Dist: toml>=0.10
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'

limbo_code-0.1.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+limbo/__init__.py,sha256=nmQZ4JiUyT_OMv0zZlfqfN9ZhmPsR65wPgxl1a2LsWM,72
+limbo/__main__.py,sha256=zAxWJyXU_Gmqu2jxQJM2qmjxX3FllekW2u4HaUdGAAY,126
+limbo/agent.py,sha256=98SBFk4ev4v3Zl1_zZxNdsqAuDhi8n2NKNwAMy2d6qU,16496
+limbo/app.py,sha256=E0rsLGAQAPZFLOD8Q-iIyx23F61mq4FawdqCGk2EVhA,3066
+limbo/config.py,sha256=5CUuUYyiWyXO0mk3LbhmoRy8xon8nGvDK9g8F3gBmOc,3146
+limbo/history.py,sha256=1E3JgkxXNmGJsvLpx261VqbIh7hc3VpUqzHPK_C1aSg,3066
+limbo/models.py,sha256=ZvpA56OlfA3vWye3VJNqey3kQ8MfSRt80Yokps65e1w,2156
+limbo/sessions.py,sha256=RHWRQD9nWojvxcZvnafZEZH2SKDvO_ueetkxNdp_zig,8428
+limbo/skills.py,sha256=GyLtmdAo-cE3dqE6anLoE4nFW_hkKOyKeIWl_gTIaQ4,2959
+limbo/trace.py,sha256=qqoWOXupUJHDja_3dFO6mtJ5ou891HD93xgJNt0lLqw,3299
+limbo/llm/__init__.py,sha256=t2HYY6CphVNUIxWioSdhoQWqMBCq3IJRv366SAckMAs,26
+limbo/llm/anthropic_client.py,sha256=2p6Jsqw0UUeMIRXBNLaJhBARbOkuAyo0GdMg3g_000Q,12568
+limbo/llm/catalog.py,sha256=pLft6sn5yew4yVIaRRIWW4hcEq-CpDuBFJgUGLfCwpA,8294
+limbo/llm/client.py,sha256=6DFajD-wY705HEQX48fiRxhVWZcCKiw9bCf4t7NAIOE,599
+limbo/llm/factory.py,sha256=rKqYviEAKc7UFD0g779amfV8KAkjeSewN_GySw8RX4Q,1536
+limbo/llm/openai_client.py,sha256=uZkUYt8a0FgCK8T6STHJ5PagvsTHyxtAHjkARU3zQeY,9942
+limbo/tools/__init__.py,sha256=FFDBp7pUO15wxLeJGOxJ7TMV3GrNxzwUGKpZiCgP8Dg,27
+limbo/tools/base.py,sha256=l6UQB6FWZRm-n-vY79rSIWAk3CtysfjuzvynyjAUraw,3423
+limbo/tools/bash.py,sha256=UZV5XaXiiEtzo3a7mfRpjuyW5Sq3k2rdWnt8Oocr09s,6257
+limbo/tools/edit.py,sha256=aQeX5Yrm8Jb2EH6TtsROLG6MZoe60_Qm7RuXbbu8oFU,2422
+limbo/tools/find.py,sha256=shvmcxrF-A0NZup9Hz1Oix9WHJoHJuEcN3ysnqghLbQ,2205
+limbo/tools/grep.py,sha256=Wjh3KpYnV1yifKNfLlGn3mMkzivxe4hym_SA-KMtSXI,6229
+limbo/tools/ignore.py,sha256=NXurQ3HnpRvgTz3ICF1gGDOMDgt_91wdxA7bTpBVl1U,3449
+limbo/tools/ls.py,sha256=Rf9Us8_Y1R5YEsTUaIoC7wyYSayHvcLw2aL5APx7BUE,1212
+limbo/tools/read.py,sha256=sBog3GAMJlTyJfLTOhcqcf7xJ3jHf6CdPuEOYYtLHZM,3511
+limbo/tools/registry.py,sha256=0xXcRQt8YswrjIgxFdObPkQelS0h3HG3A4V4NnJCQhI,2301
+limbo/tools/write.py,sha256=tphwTuVcqngwRuzLVoKuv_S9IWStJgAMPI8zWPtOCHI,1103
+limbo/ui/__init__.py,sha256=pcY6-j4Z4FcG0CxRYVssqowkAewo7l3kQvc1Y1IVvGU,28
+limbo/ui/app.py,sha256=pqhP7uEc6dAjov2MAXl1he7v4i4EWr_E1ggRquPJkX4,1371
+limbo/ui/app.tcss,sha256=dF4NqtaqtLP39pL40YO4U2Q57BSXTHa_BVojxvbnn9g,3712
+limbo/ui/banner.py,sha256=FJJyYgp6cVbEbjzqFv_YXlFE1g38BcRdsW30ncKz4dM,3342
+limbo/ui/commands.py,sha256=36bSpvJdsz7fFhHfd-hcn7in8o2wGVoJ_aLNghFEVUk,1922
+limbo/ui/screens/__init__.py,sha256=HsHJQF2SQ9BCUxhchFdDECHh_vk2XJuc9DQFMv8l1jw,21
+limbo/ui/screens/game2048.py,sha256=9nepzBqDjrgtktKV8i-NhxbxddPj5t4P9cYPYGKw_YM,7317
+limbo/ui/screens/main.py,sha256=F9RbTvk8jkn-53gBdh7wKgEQy3xZejE3VQzUK5fG0PA,14266
+limbo/ui/screens/session_picker.py,sha256=0bUCn9QMY-V3iLZlDlCxAKzYnoc7JSwQ-x8YUpyWb5g,1817
+limbo/ui/widgets/__init__.py,sha256=eIeZxQhS1gKqW7kSRh0yRfozVyvDfiSYpK9w5sqnfbE,24
+limbo/ui/widgets/chat.py,sha256=EFKZf3QqCYNEQ0xGWnh0urQKnMdzKQ0Sw604J9Z_FTs,6017
+limbo/ui/widgets/command_menu.py,sha256=oifnskHQEEPCvlyixzaUgBezdH12u2467zVpk-LYn-k,1398
+limbo/ui/widgets/input.py,sha256=ACVtU9CZy34Y4R608ne4nDiI-9xti6HC61T75yXwHy8,7256
+limbo/ui/widgets/status_bar.py,sha256=Ht0Ov7U-22WIwLE2PKmQSmkr7FH8sJumUq7QaiEQzAo,1237
+limbo/ui/widgets/tool_card.py,sha256=aI4ZQ-kF9UtTr-bZfWyC_kvHMm6v17pW8pjaq8Zj76E,6014
+limbo_code-0.1.0.dist-info/METADATA,sha256=YDSA6cwi0nBEHvLK07934qqb4DywrWSk6rxHz73seQc,502
+limbo_code-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+limbo_code-0.1.0.dist-info/entry_points.txt,sha256=YU3Qkp1sof5v9ROdiBCprNUJ1KuxeehhS95nxFoKPRI,41
+limbo_code-0.1.0.dist-info/RECORD,,

limbo_code-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

limbo_code-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+limbo = limbo.app:main