localcode 0.4.0__py3-none-macosx_13_0_arm64.whl

localcode/notebook.py

@@ -0,0 +1,123 @@
+"""Session-scoped notebook directory for the agent's working files.
+
+Motivation — reduce in-context memory bloat
+--------------------------------------------
+Without a notebook, every intermediate draft, plan, half-finished script, or
+piece of working data lived in the conversation history: written via
+`write_file` into the user's project tree (polluting the repo) OR shoved
+into a content message the model then has to re-read every round. Both
+approaches leak context: project writes stick around forever and surprise
+the user with random files; content-in-history grows the prompt linearly
+and eats the window the model needs for the actual task.
+
+The notebook is a per-session directory at
+`~/.localcode/notebook/<session-id>/` that the model treats as its own
+working memory. It uses regular `write_file`, `read_file`, and `bash`
+against this path — no new tool — but the system prompt points the model
+at the directory and tells it "use this for drafts, plans, intermediate
+data; the user's project tree is for final output only."
+
+Benefits:
+  • Drafts and intermediate data don't pollute the user's repo.
+  • The model can offload working memory to disk instead of re-emitting
+    it into the chat context every round.
+  • Trivial cleanup — wipe the session directory on exit.
+  • Writes / edits inside the notebook are auto-approved at the
+    permission layer — see `PermissionManager.check` in
+    permissions_v2.py — regardless of autonomy mode (`suggest`,
+    `auto_edit`, `full_auto`). `is_within_notebook` resolves
+    symlinks and rejects path-traversal (`../..`), so the bypass
+    cannot be abused to write into the user's project tree.
+
+Design notes:
+  • One directory per session — session_id is generated once at app start
+    (UUID-based) and persists for the lifetime of that LocalCodeApp.
+  • Parent directory `~/.localcode/notebook/` persists across sessions so
+    stale session dirs from crashes can be garbage-collected later. For
+    now, the most recent N are kept on disk for post-mortem debugging.
+  • Does NOT persist across sessions by default — fresh session, fresh
+    directory. If we later want long-term memory, that's a separate
+    mechanism on top of this scratchpad.
+  • Writes to the notebook never prompt for permission (see
+    `is_within_notebook` check in the write/edit tool dispatchers).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from .paths import notebook_root as _notebook_root
+
+
+# Per-project notebook root: `<project_root>/.localcode/notebook/`.
+# Computed on first access (so `cd` to a different project picks up the
+# new location). Resolved lazily via the property below; do not cache
+# the value at module import time.
+def _root() -> Path:
+    return _notebook_root()
+
+
+# Backwards-compat shim: code that imported `NOTEBOOK_ROOT` previously
+# got a `Path`. Anyone reading the module-level constant now gets the
+# CURRENT project's notebook root resolved at access time. If you need
+# to pin a value (e.g., for the duration of a session), capture it
+# into a local variable.
+NOTEBOOK_ROOT = _root()
+# Cap on the number of historical session directories we keep on disk.
+# Each one holds a few small files at most, so 20 is cheap and gives a
+# useful debugging tail without unbounded growth.
+MAX_HISTORICAL_SESSIONS = 20
+
+
+def notebook_dir_for(session_id: str) -> Path:
+    """Return (and create) the notebook directory for `session_id`.
+
+    Creating on access is idempotent — subsequent calls just return the
+    existing path. Safe to call from any thread.
+    """
+    # Resolve the notebook root LIVE (not the cached module-level
+    # NOTEBOOK_ROOT) so the lookup follows the current project even if
+    # the user changed working directories since import time.
+    d = _root() / session_id
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def is_within_notebook(path: Path) -> bool:
+    """True if `path` resolves inside any session's notebook directory.
+
+    Used by the tool-permission layer to skip the approval prompt for
+    writes into the notebook. A path traversal (`../..`) from inside the
+    notebook will resolve outside the notebook root and correctly return
+    False, so the user's project is still protected from malicious or
+    confused tool calls.
+    """
+    try:
+        resolved = path.resolve()
+        return resolved.is_relative_to(_root().resolve())
+    except (OSError, ValueError):
+        return False
+
+
+def gc_old_sessions(keep: int = MAX_HISTORICAL_SESSIONS) -> None:
+    """Delete all but the `keep` most-recently-modified session directories.
+
+    Best-effort — silent on any filesystem error. Safe to call on every
+    app start; idempotent when under the cap.
+    """
+    root = _root()
+    if not root.is_dir():
+        return
+    try:
+        subdirs = [p for p in root.iterdir() if p.is_dir()]
+    except OSError:
+        return
+    if len(subdirs) <= keep:
+        return
+    subdirs.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    for old in subdirs[keep:]:
+        try:
+            # rmtree without importing shutil at module level (cold path).
+            import shutil
+            shutil.rmtree(old, ignore_errors=True)
+        except Exception:
+            pass

localcode/output.py

@@ -0,0 +1,403 @@
+"""Centralized output manager — ALL terminal output goes through here.
+
+agent-inspired design:
+- ▪ bullet prefix on each section (tool groups, text responses, status)
+- Bold action headers: "Ran", "Read", "Wrote", "Searched"
+- └ tree connectors for tool results
+- Clear spacing between sections
+- "Working (Xs · esc to interrupt)" status line
+"""
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import time
+from dataclasses import dataclass, field
+from enum import Enum, auto
+
+
+class Phase(Enum):
+    IDLE = auto()
+    THINKING = auto()
+    TOOL_CALL = auto()
+    STREAMING = auto()
+    DONE = auto()
+    ERROR = auto()
+
+
+@dataclass
+class ToolAction:
+    name: str
+    args: str
+    status: str = "running"  # running | done | error
+    result: str = ""
+
+
+@dataclass
+class OutputState:
+    phase: Phase = Phase.IDLE
+    start_time: float = 0.0
+    thinking_peek: str = ""
+    tokens: int = 0
+    tool_actions: list[ToolAction] = field(default_factory=list)
+    content_chunks: list[str] = field(default_factory=list)
+    error: str = ""
+
+
+# Tool name → human-readable action header
+TOOL_HEADERS = {
+    "bash":         "Ran",
+    "read_file":    "Read",
+    "write_file":   "Wrote",
+    "append_file":  "Appended",
+    "edit_file":    "Edited",
+    "grep":         "Searched",
+    "glob":         "Found",
+    "list_files":   "Listed",
+    "web_search":   "Searched web",
+    "web_fetch":    "Fetched",
+}
+
+
+def _cols() -> int:
+    try:
+        return os.get_terminal_size().columns
+    except Exception:
+        return 80
+
+
+class OutputManager:
+    """Single output controller for the entire app."""
+
+    def __init__(self) -> None:
+        self.state = OutputState()
+        self._lock = threading.Lock()
+        self._indicator_thread: threading.Thread | None = None
+        self._indicator_running = False
+        self._event_callback = None
+        self._approval_callback = None  # TUI: blocks worker thread until approved/denied
+        self._stream_started = False
+        self._custom_stage = ""
+        self._status_line = ""
+        self._input_field = None  # set by app.py to enable typeahead
+
+    def set_event_callback(self, callback) -> None:
+        self._event_callback = callback
+
+    def set_approval_callback(self, callback) -> None:
+        """Set callback for TUI approval: callback(tool_name, command) -> bool."""
+        self._approval_callback = callback
+
+    def _emit_event(self, event_type: str, **payload) -> None:
+        if self._event_callback is not None:
+            try:
+                self._event_callback(event_type, payload)
+            except Exception:
+                pass
+
+    # ── Phase transitions ────────────────────────────────────────────
+
+    def start_thinking(self, reset: bool = True) -> None:
+        """Begin thinking phase — shows working indicator."""
+        with self._lock:
+            self.state.phase = Phase.THINKING
+            self._custom_stage = ""
+            if reset:
+                self.state.start_time = time.time()
+                self.state.tokens = 0
+                self.state.thinking_peek = ""
+                self.state.tool_actions.clear()
+                self.state.content_chunks.clear()
+                self._stream_started = False
+            else:
+                self.state.thinking_peek = ""
+        self._emit_event("thinking_start", reset=str(reset).lower())
+        self._start_indicator()
+
+    def start_streaming(self) -> None:
+        """Transition to content streaming — stops indicator."""
+        self._stop_indicator()
+        with self._lock:
+            self.state.phase = Phase.STREAMING
+            self._custom_stage = ""
+        self._emit_event("stream_start")
+        # Clear indicator and add breathing room before response
+        sys.stdout.write("\r\033[K\n\n  ")
+        sys.stdout.flush()
+        self._stream_started = False
+
+    def done(self) -> None:
+        """Finished — cleanup."""
+        self._stop_indicator()
+        elapsed = time.time() - self.state.start_time
+        tools_used = len(self.state.tool_actions)
+        with self._lock:
+            self.state.phase = Phase.DONE
+            self._custom_stage = ""
+        self._emit_event("done")
+        # Summary line + breathing room (guard against stale start_time)
+        parts = [f"{elapsed:.1f}s"]
+        if tools_used:
+            tool_names = {}
+            for t in self.state.tool_actions:
+                tool_names[t.name] = tool_names.get(t.name, 0) + 1
+            tool_summary = ", ".join(f"{n}×{c}" if c > 1 else n for n, c in tool_names.items())
+            parts.append(f"tools: {tool_summary}")
+        sys.stdout.write(f"\n\033[2m  Done in {' — '.join(parts)}\033[0m\n")
+        sys.stdout.flush()
+
+    def set_error(self, msg: str) -> None:
+        self._stop_indicator()
+        with self._lock:
+            self.state.phase = Phase.ERROR
+            self.state.error = msg
+            self._custom_stage = ""
+        self._emit_event("error", message=msg[:240])
+        sys.stdout.write(f"\n\033[31m▪ Error: {msg}\033[0m\n\n")
+        sys.stdout.flush()
+
+    # ── Thinking ─────────────────────────────────────────────────────
+
+    def feed_thinking(self, chunk: str) -> None:
+        with self._lock:
+            self.state.tokens += max(1, len(chunk) // 4)
+        self._emit_event("thinking_chunk", chunk=chunk[:2000])
+
+    def thinking_done(self, full_text: str) -> None:
+        """Emit the complete thinking text for display in TUI."""
+        self._last_thinking_text = full_text  # Store for direct access
+        self._emit_event("thinking_done", text=full_text[:8000])
+
+    def set_stage(self, stage: str) -> None:
+        with self._lock:
+            self._custom_stage = stage
+        self._emit_event("stage", stage=stage[:120])
+
+    def set_thinking_peek(self, text: str) -> None:
+        with self._lock:
+            self.state.thinking_peek = text[:120]
+        if text.strip():
+            self._emit_event("thinking_peek", text=text[:120])
+
+    # ── Tool calls ───────────────────────────────────────────────────
+
+    def update_turn_tokens(
+        self,
+        prompt_tokens: int,
+        completion_tokens: int,
+        total_tokens: int = 0,
+    ) -> None:
+        """Forward llama-server's `usage` info (prompt + completion token
+        counts) to the UI so the per-turn summary can show real
+        in/out counts instead of estimates.
+
+        Called once per round from `agent/loop.py` after `stream_done`.
+        Multi-tool turns fire it N times; the chat screen accumulates
+        and resets at turn boundaries.
+        """
+        self._emit_event(
+            "turn_tokens",
+            prompt_tokens=str(int(prompt_tokens or 0)),
+            completion_tokens=str(int(completion_tokens or 0)),
+            total_tokens=str(int(total_tokens or 0)),
+        )
+
+    def tool_preview(self, name: str, args_chars: int = 0, args_snippet: str = "") -> None:
+        """Mid-stream signal that a tool call is forming.
+
+        Fires the moment the model commits to a tool name and again as the
+        args grow. Lets the TUI render a `▪ Write` placeholder + size
+        progress IMMEDIATELY instead of waiting for end-of-stream — without
+        this, a 5K-line file write looks like a 3-minute hang.
+
+        `args_snippet` carries the first ~256 chars of the accumulating
+        JSON args so the UI can regex-extract `"path": "x"` and show
+        `writing(pyproject.toml… 3 KB)` instead of the generic
+        `writing(streaming… 3 KB)`.
+
+        Distinct from `log_tool`: no state mutation, no stdout write, no
+        `tool_actions.append`. Just an event for the UI to update its
+        floating active-step widget.
+        """
+        self._emit_event(
+            "tool_preview",
+            name=name,
+            chars=str(args_chars),
+            snippet=args_snippet[:256],
+        )
+
+    def log_tool(self, name: str, args: str = "") -> int:
+        """Log a tool call with agent-style formatting."""
+        self._stop_indicator()
+        idx = len(self.state.tool_actions)
+        self.state.tool_actions.append(ToolAction(name=name, args=args))
+        self._emit_event("tool_start", name=name, args=args[:200], index=str(idx))
+
+        header = TOOL_HEADERS.get(name, name)
+        # Bold header + cyan args
+        if name == "bash":
+            sys.stdout.write(f"\n\033[1m▪ {header}\033[0m \033[36m{args[:80]}\033[0m\n")
+        elif name in ("read_file", "write_file", "append_file", "edit_file"):
+            sys.stdout.write(f"\n\033[1m▪ {header}\033[0m \033[36m{args[:80]}\033[0m\n")
+        elif name in ("grep", "glob"):
+            sys.stdout.write(f"\n\033[1m▪ {header}\033[0m \033[36m{args[:80]}\033[0m\n")
+        else:
+            sys.stdout.write(f"\n\033[1m▪ {header}\033[0m \033[36m{args[:80]}\033[0m\n")
+        sys.stdout.flush()
+        self._start_indicator()
+        return idx
+
+    @staticmethod
+    def _filter_noise(text: str) -> str:
+        lines = text.splitlines()
+        filtered = [
+            l for l in lines
+            if "MallocStackLogging" not in l
+            and "MallocStackLoggingNoCompact" not in l
+            and "MallocNanoZone" not in l
+            and "can't turn off malloc stack logging" not in l
+        ]
+        return "\n".join(filtered)
+
+    def tool_result(self, result: str, error: bool = False, idx: int = -1) -> None:
+        """Show tool result with tree-style indentation."""
+        result = self._filter_noise(result)
+        if idx >= 0 and idx < len(self.state.tool_actions):
+            self.state.tool_actions[idx].status = "error" if error else "done"
+            self.state.tool_actions[idx].result = result
+        with self._lock:
+            self._custom_stage = ""
+        # Include tool name/args so TUI doesn't rely on stale _active_tool_name
+        tool_name = ""
+        tool_args = ""
+        if idx >= 0 and idx < len(self.state.tool_actions):
+            tool_name = self.state.tool_actions[idx].name
+            tool_args = self.state.tool_actions[idx].args
+        self._emit_event(
+            "tool_result",
+            error=str(error).lower(),
+            index=str(idx),
+            result=result[:4000],
+            name=tool_name,
+            args=tool_args[:200],
+        )
+        self._stop_indicator()
+        lines = result.strip().splitlines()
+        if error:
+            # A tool returning an error is normal, recoverable agentic operation
+            # (the model reads it and adjusts) — render it calm amber, NOT alarm
+            # red. Red is reserved for a terminal, turn-ending failure (set_error).
+            for line in lines[:5]:
+                sys.stdout.write(f"\033[33m  └ {line[:90]}\033[0m\n")
+        elif lines:
+            max_lines = 8
+            for i, line in enumerate(lines[:max_lines]):
+                sys.stdout.write(f"\033[2m  └ {line[:90]}\033[0m\n")
+            if len(lines) > max_lines:
+                sys.stdout.write(f"\033[2m    … +{len(lines) - max_lines} lines\033[0m\n")
+        sys.stdout.flush()
+        self._start_indicator()
+
+    # ── Content streaming ────────────────────────────────────────────
+
+    _col_pos = 0  # track column position for soft wrapping
+
+    def stream(self, chunk: str) -> None:
+        """Stream content to terminal with soft wrapping.
+
+        TUI mode (event_callback is set): emits a `content` event for
+        the chat-log widget to consume — DOES NOT write to stdout.
+        Earlier code wrote to stdout unconditionally, which (a) doubled
+        the model's prose into both the TUI render path AND raw stdout,
+        and (b) leaked the raw bytes to the visible terminal whenever
+        Textual's alt-screen was in a transitional state (startup race,
+        mid-resize, paste handoff). Real failure 2026-04-26: user saw
+        ~14 sentences of model narration printed raw to the terminal
+        outside the chat log because the TUI hadn't fully attached yet.
+
+        CLI mode (no event callback): same as before — soft-wrap and
+        write to stdout for the no-Textual fallback.
+        """
+        if self.state.phase != Phase.STREAMING:
+            self.start_streaming()
+            self._col_pos = 2  # we start with 2-char indent
+        with self._lock:
+            self.state.content_chunks.append(chunk)
+            self.state.tokens += max(1, len(chunk) // 4)
+        self._emit_event("content", chunk=chunk[:2000], chars=str(len(chunk)))
+        # In TUI mode the chat-log widget renders streamed content
+        # exclusively. Skipping stdout here is the difference between
+        # "model prose appears in the chat log only" and "model prose
+        # leaks to the raw terminal whenever the alt-screen flickers".
+        if self._event_callback is not None:
+            return
+        cols = _cols()
+        wrap_at = cols - 1  # leave 1 char margin
+        out = []
+        for ch in chunk:
+            if ch == "\n":
+                out.append("\n  ")
+                self._col_pos = 2
+            else:
+                if self._col_pos >= wrap_at:
+                    out.append("\n  ")
+                    self._col_pos = 2
+                out.append(ch)
+                self._col_pos += 1
+        sys.stdout.write("".join(out))
+        sys.stdout.flush()
+
+    def print_info(self, text: str) -> None:
+        """Print dim info text."""
+        was_running = self._indicator_running
+        if was_running:
+            self._stop_indicator()
+        sys.stdout.write(f"\033[2m  {text}\033[0m\n")
+        sys.stdout.flush()
+        if was_running:
+            self._start_indicator()
+
+    def notice(self, text: str) -> None:
+        """User-facing notice shown in BOTH the CLI (dim stdout) and the TUI
+        (as an info line). Unlike print_info — which is stdout-only and so is
+        invisible in the TUI — this emits an event the TUI renders. Use it for
+        anything the user must actually see (e.g. why a turn ended)."""
+        self.print_info(text)
+        self._emit_event("notice", text=text)
+
+    # ── Indicator (background thread) ────────────────────────────────
+
+    def _start_indicator(self) -> None:
+        if self._indicator_running:
+            return
+        self._indicator_running = True
+        self._indicator_thread = threading.Thread(target=self._run_indicator, daemon=True)
+        try:
+            self._indicator_thread.start()
+        except RuntimeError:
+            self._indicator_thread = threading.Thread(target=self._run_indicator, daemon=True)
+            self._indicator_thread.start()
+
+    def _stop_indicator(self) -> None:
+        if not self._indicator_running:
+            return
+        self._indicator_running = False
+        if self._indicator_thread:
+            try:
+                self._indicator_thread.join(timeout=1)
+            except (KeyboardInterrupt, RuntimeError):
+                pass
+        try:
+            sys.stdout.write("\033[?25h")  # show cursor
+            sys.stdout.write("\r\033[J")   # clear from cursor to end of screen
+            sys.stdout.flush()
+        except (BrokenPipeError, OSError):
+            pass
+
+    def _run_indicator(self) -> None:
+        # CLI-mode spinner removed — TUI owns the terminal and renders
+        # its own thinking indicator. start/stop scaffolding kept for
+        # legacy call sites; this thread now just idles until stopped.
+        while self._indicator_running:
+            time.sleep(0.5)

localcode/patching.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+DIFF_BLOCK_RE = re.compile(r"```diff\s*(.*?)```", re.DOTALL)
+
+
+@dataclass
+class DiffHunk:
+    header: str
+    lines: list[str]
+
+
+@dataclass
+class DiffFile:
+    old_path: str
+    new_path: str
+    headers: list[str]
+    hunks: list[DiffHunk]
+
+
+def parse_diff(diff_text: str) -> list[DiffFile]:
+    files: list[DiffFile] = []
+    current: DiffFile | None = None
+    current_hunk: DiffHunk | None = None
+    for line in diff_text.splitlines():
+        if line.startswith("diff --git "):
+            if current is not None:
+                if current_hunk is not None:
+                    current.hunks.append(current_hunk)
+                    current_hunk = None
+                files.append(current)
+            parts = line.split()
+            old_path = parts[2][2:] if len(parts) > 2 else ""
+            new_path = parts[3][2:] if len(parts) > 3 else old_path
+            current = DiffFile(old_path=old_path, new_path=new_path, headers=[line], hunks=[])
+            continue
+        if current is None:
+            continue
+        if line.startswith("@@"):
+            if current_hunk is not None:
+                current.hunks.append(current_hunk)
+            current_hunk = DiffHunk(header=line, lines=[])
+            continue
+        if current_hunk is not None:
+            current_hunk.lines.append(line)
+        else:
+            current.headers.append(line)
+    if current is not None:
+        if current_hunk is not None:
+            current.hunks.append(current_hunk)
+        files.append(current)
+    return files
+
+
+def build_diff(selected_files: list[DiffFile]) -> str:
+    blocks: list[str] = []
+    for file in selected_files:
+        blocks.extend(file.headers)
+        for hunk in file.hunks:
+            blocks.append(hunk.header)
+            blocks.extend(hunk.lines)
+    return "\n".join(blocks) + ("\n" if blocks else "")