limbo-code 0.1.17__tar.gz → 0.2__tar.gz

{limbo_code-0.1.17 → limbo_code-0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: limbo-code
-Version: 0.1.17
+Version: 0.2
 Summary: A minimal terminal AI coding agent
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27

{limbo_code-0.1.17 → limbo_code-0.2}/src/limbo/agent.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import os
 import platform
 import secrets
@@ -44,6 +45,7 @@ from limbo.prompt import build_system_prompt
 from limbo.sessions import (
     CompactionRecord,
     SessionMeta,
+    append_session_messages,
     derive_title,
     load_session,
     save_session,
@@ -218,6 +220,13 @@ class Agent:
         self._prompt_estimator = PromptSizeEstimator()
         self._compactions: list[CompactionRecord] = []
         self._previous_summary: str | None = None
+        # Incremental session persistence: how many messages are already on
+        # disk (append-only fast path), and whether the next save must do a
+        # full rewrite instead (history reshaped by compaction, or a resume
+        # whose repair() inserted placeholder tool messages).
+        self._session_saved_count = 0
+        self._session_saved_meta: str | None = None
+        self._session_full_rewrite_needed = False
         self._auto_compaction_failed_this_turn = False
         self._auto_compact_noop_notified = False
 
@@ -226,6 +235,12 @@ class Agent:
             self._meta, history, self._compactions = load_session(resume)
             self._session_file = resume
             self.messages.extend(repair_history(history))
+            # repair_history may have inserted placeholder tool messages, and
+            # load_session re-applied compaction: the in-memory history no
+            # longer matches the file byte-for-byte, so the first save after
+            # resume is a full rewrite (then the append path takes over).
+            self._session_saved_count = len(self.messages)
+            self._session_full_rewrite_needed = True
             # Restore the presentation mode: repair_history dropped the
             # loaded system message, so rebuild the fresh one in code mode
             # when the session was saved with it on.
@@ -1254,6 +1269,10 @@ class Agent:
         system_msg = self.messages[0]
         kept = self.messages[split:]
         self.messages = [system_msg, make_summary_message(summary), *kept]
+        # History changed shape (old messages dropped): the append-only
+        # fast path would leave the summarized-away messages on disk, so the
+        # next save must fully rewrite (shrinking the file).
+        self._session_full_rewrite_needed = True
         after = estimate_tokens(self.messages)
         record = CompactionRecord(
             id=secrets.token_hex(8),
@@ -1294,13 +1313,72 @@ class Agent:
         )
 
     def _save_session_sync(self) -> None:
-        # Rewrite the whole session on every save. It is cheap for MVP-sized
-        # conversations.
+        """Persist the session: incremental append by default, full rewrite
+        when the on-disk state changes shape.
+
+        Full rewrite happens when the file does not exist yet (first save),
+        when compaction reshaped the history, when a resumed session's
+        repaired history must be re-synced, or when the meta record changed
+        (title, code_mode, goal, ...) — the meta line is only written by a
+        full rewrite, so any meta drift forces one. The meta snapshot
+        comparison replaces ad-hoc dirty flags, so future meta fields (e.g.
+        the LIM-40 goal state mutated by TurnPump._save_state) are covered
+        automatically. Otherwise only the messages appended since the last
+        save are written — long sessions no longer rewrite megabytes every
+        turn.
+        """
+        # Keep the presentation mode in sync before snapshotting the meta.
+        self._meta.code_mode = self.code_mode
         if not self._meta.title:
             self._meta.title = derive_title(self.messages)
-        # Persist the presentation mode so a resumed session restores it.
-        self._meta.code_mode = self.code_mode
-        save_session(self._session_file, self._meta, self.messages, self._compactions)
+        # updated_at is stamped by save_session (full rewrite) and refreshed
+        # in-memory on the append path; exclude it so the comparison below
+        # compares real meta content, not the always-moving timestamp.
+        meta_snapshot = json.dumps(
+            self._meta.model_dump(exclude={"path", "updated_at"}),
+            ensure_ascii=False,
+            sort_keys=True,
+        )
+        if (
+            self._session_full_rewrite_needed
+            or meta_snapshot != self._session_saved_meta
+            or not self._session_file.exists()
+        ):
+            save_session(
+                self._session_file,
+                self._meta,
+                self.messages,
+                self._compactions,
+            )
+            self._session_saved_count = len(self.messages)
+            self._session_saved_meta = meta_snapshot
+            self._session_full_rewrite_needed = False
+        else:
+            new_messages = self.messages[self._session_saved_count :]
+            if new_messages:
+                try:
+                    append_session_messages(self._session_file, new_messages)
+                except OSError:
+                    # Partial or failed append: some of the new messages may
+                    # already be on disk, and re-appending next time would
+                    # duplicate them. Force a full rewrite on the next save,
+                    # which rebuilds the file and drops the duplicates.
+                    self._session_full_rewrite_needed = True
+                    raise
+                self._session_saved_count = len(self.messages)
+            # Keep the in-memory timestamp fresh even though the meta line
+            # is not rewritten (export headers read it).
+            self._meta.updated_at = datetime.now(timezone.utc).isoformat(
+                timespec="seconds"
+            )
 
     async def _save_session(self) -> None:
-        await asyncio.to_thread(self._save_session_sync)
+        # Trace and session are separate files written independently; the
+        # flush barrier belongs here (turn end), so by the time run()
+        # returns, every trace record is on disk. Both run off the event
+        # loop so the UI never blocks on either file.
+        def _sync() -> None:
+            self.trace.flush()
+            self._save_session_sync()
+
+        await asyncio.to_thread(_sync)

{limbo_code-0.1.17 → limbo_code-0.2}/src/limbo/sessions.py

@@ -104,7 +104,14 @@ def save_session(
     messages: list[Message],
     compactions: Sequence[CompactionRecord] = (),
 ) -> None:
-    """Atomically write the whole session (meta + compactions + messages)."""
+    """Atomically (re)write the whole session: meta + compactions + messages.
+
+    The full rewrite is the heavyweight path — used on session creation and
+    whenever the on-disk history changes shape (compaction) or the meta
+    line must be refreshed (title/code_mode). Steady-state persistence goes
+    through :func:`append_session_messages`, which only appends new
+    messages, so long sessions do not rewrite megabytes per turn.
+    """
     path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
     meta.updated_at = _utc_now_iso()
     meta_line = json.dumps(
@@ -130,6 +137,29 @@ def save_session(
         path.chmod(0o600)
 
 
+def append_session_messages(path: Path, messages: list[Message]) -> None:
+    """Append new messages to an existing session file (incremental save).
+
+    The cheap steady-state write: the meta line and all previously saved
+    messages stay untouched, only ``messages`` are appended. Requires the
+    file to already exist with a meta first line (created by
+    :func:`save_session`) — a missing file raises instead of silently
+    creating a meta-less session, so the full-rewrite-then-append contract
+    stays explicit. Permissions are preserved (no re-chmod). A crash
+    during the append can leave a torn last line (skipped on load) and
+    loses at most the in-flight increment — narrower than the atomic
+    rewrite, which is why callers fall back to a full rewrite after a
+    failed append.
+    """
+    if not path.exists():
+        raise FileNotFoundError(
+            f"Cannot append to missing session file: {path}"
+        )
+    with path.open("a", encoding="utf-8") as f:
+        for msg in messages:
+            f.write(msg.model_dump_json() + "\n")
+
+
 def _parse_meta(raw: dict[str, Any], fallback_id: str, path: Path) -> SessionMeta:
     data = {k: v for k, v in raw.items() if k != "type"}
     data.setdefault("id", fallback_id)
@@ -192,6 +222,12 @@ def load_session(
             try:
                 record = json.loads(line)
             except json.JSONDecodeError:
+                # Torn tail from a crashed incremental append: skip, but say
+                # so — a silently dropped message is hard to diagnose.
+                warnings.warn(
+                    f"Skipping malformed line in session {path}: {line[:60]!r}",
+                    stacklevel=2,
+                )
                 continue
             if record.get("type") == META_TYPE:
                 meta = _parse_meta(record, path.stem, path)
@@ -255,6 +291,22 @@ def list_sessions(
         if wanted is not None and meta.workdir != wanted:
             continue
         sessions.append(meta)
+    # Surface the file mtime as updated_at: incremental saves append to the
+    # file without rewriting the meta line, so the meta record's own
+    # updated_at goes stale (it still carries the creation / last-full-
+    # rewrite time), while the file's mtime is exactly "when this session
+    # was last written". Callers (picker, sorting) see fresh values without
+    # knowing the incremental-save detail.
+    for meta in sessions:
+        meta_path = meta.path
+        if meta_path is None:
+            continue
+        try:
+            meta.updated_at = datetime.fromtimestamp(
+                meta_path.stat().st_mtime, tz=timezone.utc
+            ).isoformat(timespec="seconds")
+        except OSError:
+            pass  # keep the stale meta value; the file vanished mid-list
     sessions.sort(key=lambda m: m.updated_at, reverse=True)
     return sessions
 

limbo_code-0.2/src/limbo/trace.py

@@ -0,0 +1,181 @@
+"""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.
+
+Full fidelity is the contract — every record (including the entire LLM
+request body, which can be hundreds of KB to MBs on long sessions) is
+persisted, never sampled or truncated. What IS optimized is the write
+path: :meth:`TraceLogger.log` only enqueues the record (microseconds),
+while JSON serialization and the file write+flush run on a dedicated
+background writer thread, so a huge ``llm_request`` body never blocks
+the asyncio event loop (which is also the UI thread). Ordering is
+preserved (single FIFO consumer); ``flush()`` provides a synchronous
+barrier for readers (export, turn-end save); ``close()`` drains and
+joins the writer before releasing the handle. Tracing must never break
+the agent: all write failures degrade to a warning.
+"""
+
+from __future__ import annotations
+
+import json
+import queue
+import threading
+import warnings
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+TRACE_SUFFIX = ".trace.jsonl"
+
+# How long close() waits for the writer thread to drain the queue before
+# giving up and closing the handle anyway (a stuck OS write must not hang
+# session teardown / app exit).
+_CLOSE_DRAIN_TIMEOUT = 10.0
+
+
+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).
+
+    Enqueue-fast / write-later: ``log()`` assembles the record dict and
+    hands it to a single background writer thread (daemon) that owns all
+    serialization and file I/O. Callers never block on disk. Use
+    :meth:`flush` at points where a reader must see everything logged so
+    far (e.g. before exporting, or at the turn-end save), and :meth:`close`
+    to drain and release the file handle.
+    """
+
+    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._queue: "queue.Queue[dict[str, Any] | None]" = queue.Queue()
+        self._failed = False
+        self._closed = False
+        self._thread = threading.Thread(
+            target=self._writer,
+            name="limbo-trace-writer",
+            daemon=True,
+        )
+        self._thread.start()
+
+    # -- writer thread --------------------------------------------------------
+
+    def _writer(self) -> None:
+        """Consume the FIFO queue: serialize + write + flush each record.
+
+        Every record is flushed individually, preserving the original
+        crash-safety guarantee (a crash loses at most the records still in
+        the queue). The sentinel ``None`` (pushed by :meth:`close`) stops
+        the loop after all earlier records were written.
+
+        ``task_done`` runs AFTER the file write: :meth:`flush` blocks on
+        ``queue.join()``, so it must only return once the record is really
+        on disk (barrier semantics for export / turn-end save).
+        """
+        while True:
+            record = self._queue.get()
+            try:
+                if record is None:
+                    return
+                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.get("ts") if record else None,
+                            "type": record.get("type") if record else "?",
+                            "serialization_error": str(e),
+                        },
+                        ensure_ascii=False,
+                    )
+                try:
+                    self._file.write(line + "\n")
+                    self._file.flush()
+                except (OSError, ValueError) as e:
+                    # ValueError covers writes on a file handle closed by
+                    # close() after its drain timeout — the writer must
+                    # degrade to a warning, never die with a traceback.
+                    if not self._failed:
+                        self._failed = True
+                        warnings.warn(f"Trace log write failed: {e}", stacklevel=2)
+            finally:
+                self._queue.task_done()
+
+    # -- public API -----------------------------------------------------------
+
+    def log(self, event_type: str, **fields: Any) -> None:
+        """Queue one event record. Never raises, never blocks on disk."""
+        if self._closed:
+            return
+        record = {"ts": _utc_now_iso(), "type": event_type, **fields}
+        self._queue.put(record)
+
+    def flush(self) -> None:
+        """Block until every record logged so far is on disk.
+
+        Safe to call from any thread (used inside ``asyncio.to_thread`` at
+        the turn-end save, so the UI never waits on it). No-op after
+        :meth:`close`.
+        """
+        if self._closed:
+            return
+        self._queue.join()
+
+    def close(self) -> None:
+        """Drain the queue, stop the writer, release the file handle.
+
+        Idempotent: safe to call from Agent.close() at every replacement
+        point even when the UI tears down several agents in sequence.
+        Records logged after close are dropped silently (the handle is
+        gone), same as before.
+        """
+        if self._closed:
+            return
+        self._closed = True
+        self._queue.put(None)  # sentinel: FIFO keeps earlier records first
+        self._thread.join(timeout=_CLOSE_DRAIN_TIMEOUT)
+        try:
+            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_code-0.1.17 → limbo_code-0.2}/src/limbo/ui/app.tcss

@@ -45,10 +45,25 @@ ChatWidget {
     padding: 0;
 }
 .thinking-message {
+    /* Vertical defaults to height: 1fr — without this a thinking block eats
+       all free space when the conversation is shorter than the viewport
+       (fresh session, just after resume), leaving a huge blank gap. */
+    height: auto;
     color: $text-tertiary;
     text-style: italic;
     margin-top: 1;
 }
+.thinking-summary {
+    color: $text-tertiary;
+    text-style: italic;
+}
+.thinking-summary:hover {
+    text-style: bold italic;
+}
+.thinking-body {
+    color: $text-tertiary;
+    text-style: italic;
+}
 .error-message {
     width: 1fr;
     background: $error-bg;
@@ -97,6 +112,17 @@ ChatWidget {
     color: $text-secondary;
     margin-top: 1;
 }
+#load-more {
+    height: 1;
+    background: $panel;
+    color: $accent;
+    text-style: bold;
+    text-align: center;
+    margin-bottom: 1;
+}
+#load-more:hover {
+    color: $primary;
+}
 #back-to-bottom {
     dock: bottom;
     height: 1;

{limbo_code-0.1.17 → limbo_code-0.2}/src/limbo/ui/screens/main.py

@@ -694,8 +694,9 @@ class MainScreen(Screen[None]):
     def _render_history(self) -> None:
         """Render the agent's restored history into the chat flow.
 
-        User/assistant text is rendered as-is; raw tool outputs are summarized
-        (tool cards are not rebuilt for history).
+        User/assistant text is rendered as-is; reasoning is restored as a
+        collapsed thinking block; raw tool outputs are summarized (tool cards
+        are not rebuilt for history).
         """
         chat = self.query_one("#chat", ChatWidget)
         skipped_tools = 0
@@ -704,8 +705,11 @@ class MainScreen(Screen[None]):
                 chat.add_info("（此前对话已压缩为摘要）")
             elif msg.role == "user" and msg.content:
                 chat.add_user_message(msg.content, msg.attachments)
-            elif msg.role == "assistant" and msg.content:
-                chat.add_assistant_message(msg.content)
+            elif msg.role == "assistant":
+                if msg.reasoning:
+                    chat.add_thinking_message(msg.reasoning)
+                if msg.content:
+                    chat.add_assistant_message(msg.content)
             elif msg.role == "tool":
                 skipped_tools += 1
         if skipped_tools:
@@ -722,17 +726,35 @@ class MainScreen(Screen[None]):
             out = (
                 Path.home() / ".limbo" / "exports" / f"{self.agent.session_id}.jsonl"
             )
-        try:
+        # flush + export run off the event loop: flush() is a queue.join()
+        # barrier that can block for the whole writer backlog on a long
+        # session, and export_jsonl re-reads the whole trace — neither
+        # should freeze the UI.
+        self.run_worker(self._export_worker(chat, out), name="export-session")
+
+    async def _export_worker(self, chat: ChatWidget, out: Path) -> None:
+        """Perform the export off the event loop, then report."""
+        def _sync() -> None:
+            # The export reads the trace file; flush the background
+            # writer first so every record lands in the export.
+            self.agent.trace.flush()
             if out.suffix == ".md":
-                export_markdown(meta, self.agent.messages, out)
+                export_markdown(self.agent.session_meta, self.agent.messages, out)
             else:
                 export_jsonl(
-                    meta, self.agent.messages, out, trace_path=self.agent.trace.path
+                    self.agent.session_meta,
+                    self.agent.messages,
+                    out,
+                    trace_path=self.agent.trace.path,
                 )
+
+        try:
+            await asyncio.to_thread(_sync)
         except OSError as e:
             chat.add_error(f"导出失败：{e}")
-            return
-        chat.add_info(f"已导出到 {out}")
+        else:
+            chat.add_info(f"已导出到 {out}")
+
 
     def action_toggle_tools(self) -> None:
         self.query_one("#chat", ChatWidget).toggle_tool_bodies()
@@ -983,6 +1005,11 @@ class MainScreen(Screen[None]):
             # swallowing it the way the old finally-drain did.
             self.query_one("#chat", ChatWidget).add_error(f"内部错误：{e}")
         finally:
+            # Flush any buffered streamed text (assistant/thinking) so the
+            # final chunks are rendered even if the last flush tick had not
+            # fired yet — otherwise the transcript/display loses the tail.
+            chat = self.query_one("#chat", ChatWidget)
+            await chat.flush_stream()
             self._update_queue_status()
             # Disabling the input mid-turn moves focus away; give it back so
             # the user can keep typing without clicking.

{limbo_code-0.1.17 → limbo_code-0.2}/src/limbo/ui/screens/session_picker.py

@@ -47,6 +47,8 @@ class SessionPicker(Screen[Path | None]):
     @staticmethod
     def _format(meta: SessionMeta) -> str:
         title = meta.title or "(无标题)"
+        # list_sessions surfaces the file mtime as updated_at, so this shows
+        # when the session was last written even under incremental saves.
         updated = meta.updated_at[:16].replace("T", " ")
         return f"{title}  ·  {updated}  ·  {meta.id}"