limbo-code 0.1.0__py3-none-any.whl

limbo/tools/ignore.py

@@ -0,0 +1,111 @@
+"""Gitignore matching for file tools.
+
+Shared by ``find`` and ``grep``: a minimal matcher that reads the workdir
+root ``.gitignore``. Does not support nested .gitignore files or advanced
+glob/negation rules.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+class GitignoreMatcher:
+    """Minimal gitignore matcher that reads the workdir root `.gitignore`."""
+
+    def __init__(self, base_dir: Path) -> None:
+        self.rules: list[tuple[bool, re.Pattern[str], bool]] = []
+        gitignore = base_dir / ".gitignore"
+        if gitignore.is_file():
+            try:
+                text = gitignore.read_text(encoding="utf-8")
+            except OSError:
+                text = ""
+            for line in text.splitlines():
+                rule = self._parse_line(line)
+                if rule is not None:
+                    self.rules.append(rule)
+
+    def _parse_line(self, line: str) -> tuple[bool, re.Pattern[str], bool] | None:
+        line = line.rstrip("\n")
+        if not line or line.startswith("#"):
+            return None
+
+        negation = False
+        if line.startswith("!"):
+            negation = True
+            line = line[1:]
+            if not line:
+                return None
+        elif line.startswith("\\!"):
+            line = line[1:]
+
+        if line.startswith("#"):
+            return None
+
+        dir_only = line.endswith("/")
+        if dir_only:
+            line = line[:-1]
+
+        anchored = "/" in line
+        if line.startswith("/"):
+            line = line[1:]
+
+        regex = self._glob_to_regex(line)
+        if not anchored:
+            regex = f"(?:.*/)?{regex}"
+        pattern = re.compile(f"^{regex}$")
+        return (negation, pattern, dir_only)
+
+    def _glob_to_regex(self, pattern: str) -> str:
+        i = 0
+        n = len(pattern)
+        result: list[str] = []
+        while i < n:
+            c = pattern[i]
+            if c == "*" and i + 1 < n and pattern[i + 1] == "*":
+                result.append(".*")
+                i += 2
+            elif c == "*":
+                result.append("[^/]*")
+                i += 1
+            elif c == "?":
+                result.append("[^/]")
+                i += 1
+            elif c == "[":
+                j = i + 1
+                if j < n and pattern[j] == "!":
+                    j += 1
+                if j < n and pattern[j] == "]":
+                    j += 1
+                while j < n and pattern[j] != "]":
+                    j += 1
+                if j >= n:
+                    result.append(re.escape(c))
+                    i += 1
+                else:
+                    chars = pattern[i + 1 : j]
+                    if chars.startswith("!"):
+                        chars = f"^{chars[1:]}"
+                    result.append(f"[{chars}]")
+                    i = j + 1
+            else:
+                result.append(re.escape(c))
+                i += 1
+        return "".join(result)
+
+    def is_ignored(self, rel_path: str) -> bool:
+        parts = rel_path.split("/")
+        paths = [rel_path]
+        paths.extend("/".join(parts[:k]) for k in range(1, len(parts)))
+
+        ignored = False
+        for negation, regex, dir_only in self.rules:
+            for path in paths:
+                if dir_only and path == rel_path:
+                    continue
+                if regex.match(path):
+                    ignored = not negation
+                    break
+        return ignored

limbo/tools/ls.py

@@ -0,0 +1,41 @@
+"""List directory contents tool."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from limbo.models import ToolResult
+from limbo.tools.base import BaseTool
+
+MAX_ENTRIES = 500
+
+
+class LsTool(BaseTool):
+    name = "ls"
+    description = "List directory contents. Includes dotfiles."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Directory to list"},
+            "limit": {"type": "integer", "description": "Max entries"},
+        },
+        "required": [],
+    }
+
+    def run(self, arguments: dict[str, Any]) -> ToolResult:
+        path = arguments.get("path", ".")
+        limit = arguments.get("limit", MAX_ENTRIES)
+
+        target = self.resolve_existing(path, kind="dir")
+
+        try:
+            entries = sorted(target.iterdir(), key=lambda p: (p.is_file(), p.name.lower()))
+        except OSError as e:
+            return ToolResult(success=False, error=f"Could not list directory: {e}")
+
+        lines = []
+        for entry in entries[:limit]:
+            suffix = "/" if entry.is_dir() else ""
+            lines.append(f"{entry.name}{suffix}")
+
+        return ToolResult(success=True, output="\n".join(lines))

limbo/tools/read.py

@@ -0,0 +1,105 @@
+"""Read file contents tool."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from limbo.config import DEFAULT_SENSITIVE_FILES
+from limbo.models import ToolResult
+from limbo.tools.base import MAX_OUTPUT_BYTES, BaseTool, ToolError
+
+MAX_LINES = 2000
+MAX_FILE_SIZE = 10 * 1024 * 1024  # 10 MB
+
+
+class ReadTool(BaseTool):
+    name = "read"
+    description = "Read the contents of a file. Use offset/limit for large files."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Path to the file"},
+            "offset": {
+                "type": "integer",
+                "description": "Line number to start from (1-indexed, optional)",
+            },
+            "limit": {
+                "type": "integer",
+                "description": "Maximum lines to read (optional)",
+            },
+        },
+        "required": ["path"],
+    }
+
+    def __init__(
+        self, workdir: Path, sensitive_files: list[str] | None = None
+    ):
+        super().__init__(workdir)
+        self.sensitive_files = set(sensitive_files or DEFAULT_SENSITIVE_FILES)
+
+    def run(self, arguments: dict[str, Any]) -> ToolResult:
+        raw_path = arguments.get("path", "")
+        target = self.resolve(raw_path)
+
+        if target.name in self.sensitive_files or any(
+            part in self.sensitive_files for part in target.parts
+        ):
+            return ToolResult(success=False, error="Refusing to read sensitive file.")
+
+        if not target.exists():
+            raise ToolError(f"File not found: {raw_path}")
+        if not target.is_file():
+            raise ToolError(f"Not a file: {raw_path}")
+
+        try:
+            file_size = target.stat().st_size
+        except OSError as e:
+            return ToolResult(success=False, error=f"Could not read file: {e}")
+        if file_size > MAX_FILE_SIZE:
+            return ToolResult(
+                success=False,
+                error=(
+                    f"File too large ({file_size} bytes). "
+                    f"Maximum size is {MAX_FILE_SIZE} bytes."
+                ),
+            )
+
+        try:
+            text = target.read_text(encoding="utf-8", errors="replace")
+        except OSError as e:
+            return ToolResult(success=False, error=f"Could not read file: {e}")
+
+        lines = text.splitlines(keepends=True)
+        offset = arguments.get("offset")
+        limit = arguments.get("limit")
+
+        if offset is not None and offset < 1:
+            return ToolResult(
+                success=False, error="offset must be a positive integer."
+            )
+        if limit is not None and limit < 1:
+            return ToolResult(
+                success=False, error="limit must be a positive integer."
+            )
+
+        if offset is not None:
+            start = max(0, offset - 1)
+            lines = lines[start:]
+        if limit is not None:
+            lines = lines[:limit]
+
+        output = "".join(lines)
+        truncated = False
+        encoded = output.encode("utf-8", errors="replace")
+        if len(encoded) > MAX_OUTPUT_BYTES:
+            output = encoded[:MAX_OUTPUT_BYTES].decode("utf-8", errors="replace")
+            truncated = True
+        elif len(lines) > MAX_LINES:
+            output = "".join(lines[:MAX_LINES])
+            truncated = True
+
+        if truncated:
+            output += "\n[Output truncated. Use offset/limit to read more.]"
+
+        return ToolResult(success=True, output=output)

limbo/tools/registry.py

@@ -0,0 +1,66 @@
+"""Tool registry that collects all available tools."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any
+
+from limbo.config import Config
+from limbo.models import ToolResult
+from limbo.tools.base import BaseTool
+from limbo.tools.bash import BashTool
+from limbo.tools.edit import EditTool
+from limbo.tools.find import FindTool
+from limbo.tools.grep import GrepTool
+from limbo.tools.ls import LsTool
+from limbo.tools.read import ReadTool
+from limbo.tools.write import WriteTool
+
+
+class ToolRegistry:
+    """Registers and executes tools."""
+
+    def __init__(self, workdir: Path, config: Config | None = None):
+        self.workdir = workdir
+        self.config = config or Config()
+        self._tools: dict[str, BaseTool] = {}
+        # Tools without configurable safety settings are registered generically.
+        for tool_class in [EditTool, WriteTool, GrepTool, FindTool, LsTool]:
+            self.register(tool_class)  # type: ignore[type-abstract]
+        # Wire configurable safety options from Config.
+        self._tools["read"] = ReadTool(
+            workdir=workdir,
+            sensitive_files=self.config.safety.sensitive_files,
+        )
+        if self.config.tools.bash_enabled:
+            self._tools["bash"] = BashTool(
+                workdir=workdir,
+                dangerous_patterns=self.config.safety.dangerous_commands,
+            )
+
+    def register(self, tool_class: type[BaseTool]) -> None:
+        tool = tool_class(workdir=self.workdir)
+        self._tools[tool.name] = tool
+
+    def get(self, name: str) -> BaseTool | None:
+        return self._tools.get(name)
+
+    async def execute(self, name: str, arguments: dict[str, Any]) -> ToolResult:
+        tool = self.get(name)
+        if tool is None:
+            return ToolResult(success=False, error=f"Unknown tool: {name}")
+        return await asyncio.to_thread(tool.execute, arguments)
+
+    def definitions(self) -> list[dict[str, Any]]:
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.parameters,
+                },
+            }
+            for tool in self._tools.values()
+        ]

limbo/tools/write.py

@@ -0,0 +1,34 @@
+"""Write file contents tool."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from limbo.models import ToolResult
+from limbo.tools.base import BaseTool
+
+
+class WriteTool(BaseTool):
+    name = "write"
+    description = "Create or overwrite a file. Use only for new files or complete rewrites."
+    parameters = {
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Path to the file"},
+            "content": {"type": "string", "description": "Content to write"},
+        },
+        "required": ["path", "content"],
+    }
+
+    def run(self, arguments: dict[str, Any]) -> ToolResult:
+        raw_path = arguments.get("path", "")
+        content = arguments.get("content", "")
+        target = self.resolve_creatable(raw_path)
+
+        try:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(content, encoding="utf-8")
+        except OSError as e:
+            return ToolResult(success=False, error=f"Could not write file: {e}")
+
+        return ToolResult(success=True, output=f"Wrote {raw_path}.")

limbo/trace.py

@@ -0,0 +1,100 @@
+"""Append-only JSONL trace log for analyzing complete agent runs.
+
+The trace lives in a ``traces/`` subdirectory of the session directory
+(``traces/<session>.trace.jsonl``) and records everything the message
+history cannot reconstruct after the fact: full LLM request bodies,
+token usage, tool execution timing, and errors/interruptions.
+
+Writes are appended and flushed immediately so a crash or interrupt loses
+at most the in-flight event. Tracing must never break the agent: all write
+failures degrade to a warning.
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+import warnings
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+TRACE_SUFFIX = ".trace.jsonl"
+
+
+def trace_path_for(session_file: Path) -> Path:
+    """Return the trace file path belonging to a session file.
+
+    Traces live in a ``traces/`` subdirectory so session listing/globbing
+    (``*.jsonl``) never picks them up.
+    """
+    return session_file.parent / "traces" / f"{session_file.stem}{TRACE_SUFFIX}"
+
+
+def _utc_now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="milliseconds")
+
+
+class TraceLogger:
+    """Thread-safe, append-only JSONL event log (one record per line)."""
+
+    def __init__(self, path: Path):
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        file_existed = self.path.exists()
+        self._file = self.path.open("a", encoding="utf-8")
+        if not file_existed:
+            self.path.chmod(0o600)
+        self._lock = threading.Lock()
+        self._failed = False
+
+    def log(self, event_type: str, **fields: Any) -> None:
+        """Append one event record. Never raises."""
+        record = {"ts": _utc_now_iso(), "type": event_type, **fields}
+        try:
+            line = json.dumps(record, ensure_ascii=False, default=str)
+        except (TypeError, ValueError) as e:
+            # Extremely defensive: `default=str` should catch everything.
+            line = json.dumps(
+                {
+                    "ts": record["ts"],
+                    "type": event_type,
+                    "serialization_error": str(e),
+                },
+                ensure_ascii=False,
+            )
+        try:
+            with self._lock:
+                self._file.write(line + "\n")
+                self._file.flush()
+        except OSError as e:
+            if not self._failed:
+                self._failed = True
+                warnings.warn(f"Trace log write failed: {e}", stacklevel=2)
+
+    def close(self) -> None:
+        try:
+            with self._lock:
+                self._file.close()
+        except OSError:
+            pass
+
+
+def read_trace(path: Path) -> list[dict[str, Any]]:
+    """Read all trace records, skipping malformed lines."""
+    records: list[dict[str, Any]] = []
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    record = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if isinstance(record, dict):
+                    records.append(record)
+    except OSError:
+        pass
+    return records

limbo/ui/__init__.py

@@ -0,0 +1 @@
+"""Limbo TUI components."""

limbo/ui/app.py

@@ -0,0 +1,52 @@
+"""Textual App for Limbo."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App
+
+from limbo.config import Config
+from limbo.llm.client import LLMClient
+from limbo.ui.screens.main import MainScreen
+
+
+class LimboApp(App[None]):
+    """Main TUI application."""
+
+    TITLE = "Limbo"
+    CSS_PATH = "app.tcss"
+
+    def __init__(
+        self,
+        workdir: str | Path,
+        config: Config | None = None,
+        llm_client: LLMClient | None = None,
+        session_dir: Path | None = None,
+        resume: Path | None = None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.workdir = Path(workdir).resolve()
+        self.config = config
+        self.llm_client = llm_client
+        self.session_dir = session_dir
+        self.resume = resume
+        theme = (config.ui.theme if config else None) or None
+        if theme:
+            try:
+                self.theme = theme
+            except Exception:  # noqa: BLE001 - unknown theme name, keep default
+                pass
+
+    def on_mount(self) -> None:
+        self.push_screen(
+            MainScreen(
+                workdir=self.workdir,
+                config=self.config,
+                llm_client=self.llm_client,
+                session_dir=self.session_dir,
+                resume=self.resume,
+            )
+        )

limbo/ui/app.tcss

@@ -0,0 +1,174 @@
+/* Limbo TUI — pi 风格单栏布局，集中管理所有样式 */
+
+/* ---- 顶部状态栏 ---- */
+#statusbar {
+    height: 1;
+    padding: 0 1;
+    background: $surface;
+}
+#statusbar-state {
+    width: 1fr;
+    color: $text-muted;
+}
+#statusbar-state.thinking {
+    color: $warning;
+}
+#statusbar-state.tool {
+    color: $accent;
+}
+#statusbar-context {
+    width: auto;
+    color: $text-muted;
+    text-align: right;
+}
+
+/* ---- 聊天流 ---- */
+ChatWidget {
+    width: 1fr;
+    height: 1fr;
+    padding: 0 1;
+}
+.user-message {
+    color: $text-accent;
+    margin-top: 1;
+}
+.assistant-message {
+    margin-top: 1;
+    padding: 0;
+}
+.error-message {
+    color: $error;
+    margin-top: 1;
+}
+.info-message {
+    color: $text-muted;
+}
+.ascii-art {
+    color: $text-muted;
+    margin-top: 1;
+}
+
+/* ---- 工具调用卡片 ---- */
+ToolCard {
+    height: auto;
+    padding-left: 1;
+}
+ToolCard .tool-header {
+    height: 1;
+    color: $text-muted;
+}
+ToolCard.running .tool-header {
+    color: $warning;
+}
+ToolCard.success .tool-header {
+    color: $success;
+}
+ToolCard.error .tool-header {
+    color: $error;
+}
+ToolCard .tool-body {
+    height: auto;
+    max-height: 24;
+    padding-left: 1;
+    border-left: solid $primary-lighten-2;
+}
+
+/* ---- 斜杠命令自动补全菜单 ---- */
+#slash-menu {
+    height: auto;
+    max-height: 8;
+    margin: 0 1;
+    border: round $primary;
+    background: $surface;
+}
+
+/* ---- 输入框（全局唯一的圆角边框，视觉锚点） ---- */
+#input {
+    height: 3;
+    border: round $accent;
+    margin: 0 1;
+}
+#input:focus {
+    border: round $accent-lighten-1;
+}
+
+/* ---- 底部快捷键提示 ---- */
+#hint {
+    height: 1;
+    padding: 0 2;
+    color: $text-muted;
+}
+
+/* ---- 会话选择弹窗 ---- */
+SessionPicker {
+    align: center middle;
+}
+SessionPicker #session-picker {
+    width: 80%;
+    max-width: 110;
+    height: auto;
+    max-height: 80%;
+    border: round $accent;
+    background: $surface;
+    padding: 1 2;
+}
+SessionPicker #picker-title {
+    text-style: bold;
+    margin-bottom: 1;
+}
+SessionPicker ListView {
+    height: auto;
+    max-height: 20;
+}
+
+/* ---- 2048 游戏弹窗 ---- */
+Game2048Screen {
+    align: center middle;
+}
+Game2048Screen #game-container {
+    width: auto;
+    height: auto;
+    border: round $accent;
+    background: $surface;
+    padding: 1 2;
+}
+Game2048Screen #game-header {
+    text-style: bold;
+    margin-bottom: 1;
+    content-align: center middle;
+    width: 100%;
+}
+Game2048Screen #game-grid {
+    grid-size: 4 4;
+    grid-columns: 6;
+    grid-rows: 3;
+    grid-gutter: 1;
+    width: 27;
+    height: 15;
+}
+Game2048Screen #game-footer {
+    margin-top: 1;
+    color: $text-muted;
+    content-align: center middle;
+    width: 100%;
+}
+Game2048Screen .tile {
+    content-align: center middle;
+    text-style: bold;
+    width: 100%;
+    height: 3;
+    background: $surface-lighten-1;
+    color: $text-muted;
+}
+Game2048Screen .tile-2     { background: #eee4da; color: #776e65; }
+Game2048Screen .tile-4     { background: #ede0c8; color: #776e65; }
+Game2048Screen .tile-8     { background: #f2b179; color: #f9f6f2; }
+Game2048Screen .tile-16    { background: #f59563; color: #f9f6f2; }
+Game2048Screen .tile-32    { background: #f67c5f; color: #f9f6f2; }
+Game2048Screen .tile-64    { background: #f65e3b; color: #f9f6f2; }
+Game2048Screen .tile-128   { background: #edcf72; color: #f9f6f2; }
+Game2048Screen .tile-256   { background: #edcc61; color: #f9f6f2; }
+Game2048Screen .tile-512   { background: #edc850; color: #f9f6f2; }
+Game2048Screen .tile-1024  { background: #edc53f; color: #f9f6f2; }
+Game2048Screen .tile-2048  { background: #edc22e; color: #f9f6f2; }
+Game2048Screen .tile-super { background: #3c3a32; color: #f9f6f2; }