rockycode 0.1.0__py3-none-any.whl

rockycode/tui/mdterm.py

@@ -0,0 +1,232 @@
+"""Markdown → terminal-friendly markdown, applied just before Textual's
+Markdown widget parses it (ported from a research branch).
+
+Two failure modes this fixes:
+- Textual intentionally disables auto-links inside fenced code blocks, and
+  VS Code's terminal link detector only sees one visual row at a time — a long
+  local path that soft-wraps LOOKS complete but clicking captures only the
+  first row. So absolute-path link targets are rewritten to real file:// URIs
+  (clickable anywhere), and each code fence gets a compact "path links:" line
+  appended after it for the paths trapped inside.
+- Long tree/path lines inside fences don't soft-wrap (code blocks clip), so
+  tree output loses its tail. Path-looking lines are wrapped at cell width
+  (CJK-aware), breaking at / _ - with a continuation indent; code-looking
+  lines are left alone (wrapping code would corrupt it).
+
+Pure functions, no Textual imports — unit-tested in tests/smoke_mdterm.py.
+"""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from urllib.parse import urlsplit
+from urllib.request import url2pathname
+
+from markdown_it import MarkdownIt
+from rich.cells import cell_len
+
+# Absolute paths under the roots real user files live in (macOS + Linux +
+# common containers) — anchored so URL fragments like /v1/messages don't match.
+_ROOT = r"/(?:Users|home|root|tmp|private|var|opt|srv|mnt|etc|workspace)/"
+ABS_PATH_RE = re.compile(r"(?<![\w:])(" + _ROOT + r"[^\s`<>\]\)]+)")
+ABS_LINK_TARGET_RE = re.compile(r"\]\((" + _ROOT + r"[^)\s]+)\)")
+ABS_ANGLE_LINK_TARGET_RE = re.compile(r"\]\(<(" + _ROOT + r"[^>]+)>\)")
+_ROOT_RE = re.compile(_ROOT)
+TREE_OR_PATH_HINT_RE = re.compile(r"(" + _ROOT + r"|[├└│┬┴─]|←|✅|\.md\b|\.txt\b|\.pdf\b|/)")
+CODELIKE_PUNCT_RE = re.compile(r"[{};=()]")
+# `loop.py:128` / `loop.py:128:5` — the label keeps it, the URI can't.
+_LINE_SUFFIX_RE = re.compile(r":\d+(?::\d+)?$")
+
+
+# Click policy: clicking is for CHECKING things — the
+# paper, the docs, the link — never for RUNNING things. Reading files open
+# with the system default; code/shell/anything else shows a dim note instead.
+READING_SUFFIXES = {
+    ".md", ".markdown", ".rst", ".txt", ".pdf", ".html", ".htm",
+    ".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp",
+}
+
+
+def link_click_action(href: str) -> tuple[str, str]:
+    """Decide what a clicked link may do.
+
+    Returns ("browser", href) for the web, ("open", file_uri) for an existing
+    reading file, ("blocked", path) for code or anything that could execute,
+    ("missing", path) for a target that moved or was renamed since the reply.
+
+    HARD RULE (enforced here, not by the model): "open" is returned only for
+    a regular file whose RESOLVED target has a reading suffix and no exec bit.
+    Symlinks are judged by what they point at — `innocent.md → evil.command`
+    is blocked, because macOS `open` follows the link and would RUN a
+    .command/.app/unix-executable target. Nothing a click opens can execute.
+    """
+    parts = urlsplit(href)
+    scheme = parts.scheme.lower()
+    if scheme in ("http", "https"):
+        return ("browser", href)
+    if scheme not in ("", "file"):
+        return ("blocked", href)
+    path = url2pathname(parts.path)
+    if not path.startswith("/"):
+        return ("blocked", path)
+    real = Path(path).resolve()
+    if real.suffix.lower() not in READING_SUFFIXES:
+        return ("blocked", path)
+    if not real.exists():
+        return ("missing", path)
+    if not real.is_file() or os.access(real, os.X_OK):
+        return ("blocked", path)
+    return ("open", real.as_uri())
+
+
+def rocky_markdown_parser() -> MarkdownIt:
+    """markdown-it tuned for the transcript: file:// hrefs allowed (the stock
+    security filter drops them and the whole link renders as raw text), fuzzy
+    linkify off (`loop.py` is a file, not a Paraguayan website — explicit
+    https:// URLs still autolink)."""
+    md = MarkdownIt("gfm-like")
+    stock_validate = md.validateLink
+    md.validateLink = lambda url: url.startswith("file://") or stock_validate(url)
+    md.linkify.set({"fuzzy_link": False})
+    return md
+
+
+def _file_uri(path: str) -> str:
+    try:
+        return Path(path).as_uri()
+    except ValueError:
+        return path
+
+
+def _rewrite_link_targets(line: str) -> str:
+    # `:128` must come off before as_uri() — quoted to %3A128 it points at a
+    # file that doesn't exist. The label lives in [...] and keeps the suffix.
+    def uri(m: re.Match) -> str:
+        return f"](<{_file_uri(_LINE_SUFFIX_RE.sub('', m.group(1)))}>)"
+
+    return ABS_LINK_TARGET_RE.sub(uri, ABS_ANGLE_LINK_TARGET_RE.sub(uri, line))
+
+
+def _markdown_link_text(text: str) -> str:
+    return text.replace("\\", "\\\\").replace("[", "\\[").replace("]", "\\]")
+
+
+def _path_link(path: str) -> str:
+    target = _LINE_SUFFIX_RE.sub("", path)
+    label = Path(path).name or path
+    return f"[{_markdown_link_text(label)}](<{_file_uri(target)}>)"
+
+
+def _looks_like_tree_or_path_line(line: str) -> bool:
+    stripped = line.strip()
+    if not stripped:
+        return False
+    if _ROOT_RE.search(line):
+        return True
+    if TREE_OR_PATH_HINT_RE.search(line) and not CODELIKE_PUNCT_RE.search(stripped):
+        return True
+    separators = sum(stripped.count(ch) for ch in "/_-")
+    return separators >= 4 and not CODELIKE_PUNCT_RE.search(stripped)
+
+
+def _take_wrapped_chunk(text: str, max_cells: int) -> tuple[str, str]:
+    used = 0
+    last_break = -1
+    for i, char in enumerate(text):
+        used += cell_len(char)
+        # Overflow check BEFORE recording this char as a break point — a
+        # separator that itself overflows must not become the cut position.
+        if used > max_cells:
+            if last_break > 0:
+                return text[:last_break].rstrip(), text[last_break:].lstrip()
+            return "", text
+        if char in "/_-" or char.isspace():
+            last_break = i + 1
+    return text.rstrip(), ""
+
+
+def _wrap_tree_or_path_line(line: str, max_cells: int) -> list[str]:
+    if cell_len(line) <= max_cells or not _looks_like_tree_or_path_line(line):
+        return [line]
+
+    indent_len = len(line) - len(line.lstrip(" "))
+    indent = line[:indent_len]
+    continuation_indent = indent + "  "
+    available = max(max_cells - cell_len(indent), 24)
+    continuation_available = max(max_cells - cell_len(continuation_indent), 24)
+    remaining = line[indent_len:]
+    wrapped: list[str] = []
+
+    while remaining and cell_len(indent + remaining) > max_cells:
+        chunk, rest = _take_wrapped_chunk(remaining, available)
+        if not chunk:
+            break
+        wrapped.append(indent + chunk)
+        remaining = rest
+        indent = continuation_indent
+        available = continuation_available
+
+    if not wrapped:
+        return [line]
+    if remaining:
+        wrapped.append(indent + remaining)
+    return wrapped
+
+
+def enhance_markdown(
+    markdown: str, *, width: int | None = None, only_existing: bool = False
+) -> str:
+    """Rewrite abs-path link targets to file:// URIs (outside fences only),
+    append a "path links:" line after each fence that trapped paths, and wrap
+    path-looking fence lines at `width` cells (None = don't wrap). The original
+    text is otherwise untouched — path-free markdown passes through
+    byte-identical. With only_existing=True, fence-collected paths get a link
+    only if they exist on this machine — dead, renamed, container-only, or
+    regex-truncated paths are silently skipped (not pure: reads the fs)."""
+    code_wrap_width = None if width is None else max(min(width - 8, 88), 28)
+
+    out: list[str] = []
+    in_fence = False
+    fence_marker = ""
+    fence_paths: list[str] = []
+
+    for line in markdown.splitlines():
+        stripped = line.lstrip()
+        if not in_fence and (stripped.startswith("```") or stripped.startswith("~~~")):
+            in_fence = True
+            fence_marker = stripped[:3]
+            fence_paths = []
+            out.append(line)
+            continue
+
+        if in_fence:
+            if stripped.startswith(fence_marker):
+                out.append(line)
+                unique_paths = list(dict.fromkeys(fence_paths))
+                if only_existing:
+                    unique_paths = [
+                        p for p in unique_paths
+                        if Path(_LINE_SUFFIX_RE.sub("", p)).exists()
+                    ]
+                if unique_paths:
+                    links = " · ".join(_path_link(path) for path in unique_paths[:5])
+                    out.append("")
+                    out.append(f"> path links: {links}")
+                in_fence = False
+                fence_marker = ""
+                fence_paths = []
+                continue
+            fence_paths.extend(
+                match.group(1).rstrip(".,;:!?") for match in ABS_PATH_RE.finditer(line)
+            )
+            if code_wrap_width is not None:
+                out.extend(_wrap_tree_or_path_line(line, code_wrap_width))
+                continue
+            out.append(line)
+            continue
+
+        # Outside fences only — a fenced markdown example must stay verbatim.
+        out.append(_rewrite_link_targets(line))
+
+    return "\n".join(out)

rockycode/tui/mdview.py

@@ -0,0 +1,99 @@
+"""The doc dock — read a paper or doc BESIDE the chat, never over it.
+
+Clicking a text-family link (see TEXT_DOC_SUFFIXES) docks the rendered file
+in a right-hand pane instead of launching an external app: the transcript
+stays live and visible, scrolls independently, and gets its exact width back
+on close. Nothing here ever touches engine history — the dock is pure
+display, so the prompt-cache prefix is byte-identical with or without it.
+
+The click policy stays upstream: the app routes a file here only after
+mdterm.link_click_action returned "open" (resolved regular file, reading
+suffix, no exec bit). The dock can only render — it has no way to run.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.markup import escape
+from textual.containers import Vertical, VerticalScroll
+from textual.widgets import Markdown, Static
+
+from rockycode.palette import MUTED
+from rockycode.tui.mdterm import rocky_markdown_parser
+
+# What docks in-app: files a terminal can honestly render. Everything else
+# that passed the click policy (pdf, images, html) still goes to `open`.
+TEXT_DOC_SUFFIXES = {".md", ".markdown", ".rst", ".txt"}
+
+READ_CAP = 200_000  # chars — keeps a giant log paste from freezing the dock
+WIDTHS = ("45%", "62%", "30%")  # ⇄ cycles; the CSS default matches WIDTHS[0]
+
+
+def read_doc(path: Path, cap: int = READ_CAP) -> str:
+    """File → markdown for the dock. .txt is fenced so it stays verbatim;
+    oversized files are cut at `cap` chars with an honest tail note."""
+    text = path.read_text(errors="replace")
+    truncated = len(text) > cap
+    if truncated:
+        text = text[:cap]
+    if path.suffix.lower() == ".txt":
+        text = f"````text\n{text}\n````"
+    if truncated:
+        text += f"\n\n> ✂ showing the first {cap:,} characters — the file has more."
+    return text
+
+
+class DocDock(Vertical):
+    """Right-hand reading pane. Keeps a back-stack so links inside a docked
+    doc (routed through the same click policy by the app) navigate in place."""
+
+    def __init__(self) -> None:
+        super().__init__(id="docdock")
+        self._stack: list[Path] = []
+        self.width_i = 0
+        self.is_full = False
+
+    @property
+    def current(self) -> Path | None:
+        return self._stack[-1] if self._stack else None
+
+    def compose(self):
+        yield Static("", id="docdock-head")
+        yield VerticalScroll(
+            Markdown("", parser_factory=rocky_markdown_parser,
+                     open_links=False, id="docdock-md"),
+            id="docdock-body",
+        )
+
+    async def load(self, path: Path) -> None:
+        self._stack.append(path)
+        await self._show()
+
+    async def back(self) -> bool:
+        if len(self._stack) < 2:
+            return False
+        self._stack.pop()
+        await self._show()
+        return True
+
+    async def _show(self) -> None:
+        path = self._stack[-1]
+        await self.query_one("#docdock-md", Markdown).update(read_doc(path))
+        self.border_title = f"♪ {escape(path.name)}"
+        back = "[@click=app.doc_back]← back[/] · " if len(self._stack) > 1 else ""
+        self.query_one("#docdock-head", Static).update(
+            f"[{MUTED}]{back}[@click=app.doc_wider]⇄ width[/] · "
+            f"[@click=app.doc_full]⛶ full[/] · "
+            f"[@click=app.doc_close]✕ close · esc[/] · {escape(str(path))}[/]"
+        )
+        self.query_one("#docdock-body", VerticalScroll).scroll_home(animate=False)
+
+    # Wheel over the header/border must scroll the DOC, not fall through to
+    # the app-level catch-all that scrolls the transcript.
+    def on_mouse_scroll_up(self, event) -> None:
+        self.query_one("#docdock-body", VerticalScroll).scroll_relative(y=-3, animate=False)
+        event.stop()
+
+    def on_mouse_scroll_down(self, event) -> None:
+        self.query_one("#docdock-body", VerticalScroll).scroll_relative(y=3, animate=False)
+        event.stop()

rockycode/tui/modepicker.py

@@ -0,0 +1,103 @@
+"""The mode picker: bare /research (or /learn with local additions) opens this
+— browse the family's modes with a when-to-use preview, so nobody has to
+remember type names. Heavy users graduate to `/research <type>`; the entry
+card teaches that at the moment of use.
+
+dismiss() value: a Mode to apply, the string "off" to leave the current mode,
+or None on cancel.
+"""
+from __future__ import annotations
+
+from textual import on
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import OptionList, Static
+from textual.widgets.option_list import Option
+
+from rich.markup import escape
+
+from rockycode.engine.modes import Mode
+from rockycode.palette import LAVENDER, MUTED
+
+
+class ModePicker(ModalScreen):
+    BINDINGS = [
+        ("escape", "cancel", "cancel"),
+        ("down", "cursor_down", "↓"),
+        ("up", "cursor_up", "↑"),
+    ]
+
+    DEFAULT_CSS = """
+    ModePicker { align: center middle; }
+    ModePicker > #picker {
+        width: 76%;
+        max-width: 100;
+        height: auto;
+        max-height: 80%;
+        padding: 1 2;
+        background: $surface;
+        border: round $primary;
+        border-title-color: $text-muted;
+    }
+    ModePicker OptionList { height: auto; max-height: 12; background: $surface; }
+    ModePicker #mode-preview { height: auto; margin-top: 1; color: $text-muted; }
+    ModePicker #mode-guide { height: 1; margin-top: 1; color: $text-muted; }
+    """
+
+    def __init__(self, family: str, modes: list[Mode], *, active: str | None = None) -> None:
+        super().__init__()
+        self.family = family
+        self.modes = modes
+        self.active = active  # currently active mode name (any family) or None
+
+    def compose(self):
+        with Vertical(id="picker") as box:
+            box.border_title = f"/{self.family} — pick how we work"
+            yield OptionList(id="mode-list")
+            yield Static("", id="mode-preview")
+            yield Static(
+                f"[{MUTED}]↑↓ move · ↵ apply · esc cancel · "
+                f"direct next time: [{LAVENDER}]/{self.family} <name>[/][/]",
+                id="mode-guide",
+            )
+
+    def on_mount(self) -> None:
+        ol = self.query_one("#mode-list", OptionList)
+        if self.active:
+            ol.add_option(Option(f"  ◉ off{'':<18} — back to normal rocky (now: {self.active})", id="off"))
+        for i, m in enumerate(self.modes):
+            marker = "▸ " if m.name == self.active else "  "
+            local = "" if m.builtin else "  ·  project-local"
+            ol.add_option(Option(f"{marker}{m.name:<22} — {escape(m.description)}{local}", id=str(i)))
+        ol.highlighted = 0
+        ol.focus()
+        self._show_preview(0 if not self.active else None)
+
+    def _show_preview(self, idx: int | None) -> None:
+        pv = self.query_one("#mode-preview", Static)
+        if idx is None or not (0 <= idx < len(self.modes)):
+            pv.update(f"[{MUTED}]leave the current mode — rocky goes back to its plain contract.[/]")
+            return
+        pv.update(f"[{MUTED}]{escape(self.modes[idx].preview)}[/]")
+
+    @on(OptionList.OptionHighlighted)
+    def _on_highlight(self, e: OptionList.OptionHighlighted) -> None:
+        oid = e.option.id
+        self._show_preview(int(oid) if oid and oid.isdigit() else None)
+
+    @on(OptionList.OptionSelected)
+    def _on_select(self, e: OptionList.OptionSelected) -> None:
+        oid = e.option.id
+        if oid == "off":
+            self.dismiss("off")
+        elif oid and oid.isdigit():
+            self.dismiss(self.modes[int(oid)])
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    def action_cursor_down(self) -> None:
+        self.query_one("#mode-list", OptionList).action_cursor_down()
+
+    def action_cursor_up(self) -> None:
+        self.query_one("#mode-list", OptionList).action_cursor_up()

rockycode/tui/permission.py

@@ -0,0 +1,154 @@
+"""The inline tool-approval prompt + the turn-cancel signal.
+
+InlineApproval asks the user to approve one tool call and resolves a Future with
+one of "once" | "session" | "deny" | "cancel". Unlike a modal it is mounted
+*inside* the chat, docked just above the input, so the transcript stays fully
+visible and scrollable (wheel / pageup / shift+↑↓) while a tool waits — you can
+scroll up to re-read the history that led here, then come back and decide.
+
+Keyboard-driven like Codex / Claude Code: ↑↓ move the highlight, Enter selects it
+(default = run once, so Enter approves); y/a/n are accelerators; Esc maps to
+"cancel" (abort the whole turn) — the app's approver turns that into CancelTurn,
+which propagates out of Engine.run_turn so its tool-loop finally can keep history
+valid. The transcript-scroll keys live on the App as priority bindings, so they
+keep working even while this prompt holds focus.
+
+Styling matches the app: explicit hex from the palette, soft purple, minimal.
+The OptionList pattern mirrors the resume picker (rockycode/tui/resume.py).
+"""
+from __future__ import annotations
+
+import asyncio
+from typing import Optional
+
+from rich.markup import escape
+from textual.containers import Vertical
+from textual.widgets import Static
+
+from rockycode.palette import LAVENDER, MUTED, RED
+
+
+class CancelTurn(Exception):
+    """Raised by the TUI approver when the user chooses 'cancel turn' (Esc) in
+    the approval prompt. Propagates out of Engine.run_turn; the tool-loop
+    finally backfills tool responses so history stays API-valid."""
+
+
+class InlineApproval(Vertical):
+    """Approve one tool call, rendered INLINE at the bottom of the chat instead
+    of a modal. Resolves `future` with 'once' | 'session' | 'deny' | 'cancel'.
+
+    Enter selects the highlighted choice (default run once → Enter approves),
+    ↑↓ move it, y/a/n are accelerators, Esc cancels the whole turn.
+
+    The choices are plain Static rows (not an OptionList) *on purpose*: an
+    OptionList swallows PageUp/PageDown for its own paging, which would block
+    the App's transcript-scroll bindings while this prompt holds focus. Binding
+    only the keys we use here lets pgup/pgdn/shift+↑↓ fall through to the App so
+    the user can still scroll the history that led to this call, then decide.
+    """
+
+    can_focus = True
+
+    BINDINGS = [
+        ("up", "move(-1)", "up"),
+        ("down", "move(1)", "down"),
+        ("enter", "confirm", "select"),
+        ("escape", "cancel_turn", "cancel turn"),
+        ("y", "pick('once')", "run once"),
+        ("a", "pick('session')", "allow"),
+        ("n", "pick('deny')", "deny"),
+    ]
+
+    DEFAULT_CSS = """
+    InlineApproval {
+        height: auto;
+        margin: 0 1 1 1;
+        padding: 1 2;
+        background: $surface;
+        border: round $primary;
+        border-title-color: $text-muted;
+        border-subtitle-color: $text-muted;
+    }
+    InlineApproval:focus { border: round $primary; }
+    InlineApproval #perm-cmd { margin: 1 0; color: $text; }
+    InlineApproval #perm-warn { margin-bottom: 1; }
+    InlineApproval .perm-opt { height: 1; }
+    InlineApproval #perm-keys { color: $text-muted; margin-top: 1; }
+    """
+
+    def __init__(
+        self,
+        tool: str,
+        detail: str,
+        risk: str,
+        warning: Optional[str],
+        future: "asyncio.Future[str]",
+        session_label: Optional[str] = None,
+    ) -> None:
+        super().__init__()
+        self._tool = tool
+        self._detail = detail or "(no arguments)"
+        self._risk = risk
+        self._warning = warning
+        self._future = future
+        # The session grant is offered ONLY when session_label is given. A
+        # DANGEROUS bash command passes None → no "allow for session" at all
+        # (you can never blanket-grant a risky command); it's run-once or deny.
+        self._choices = [("once", "▶  Run once")]
+        if session_label:
+            self._choices.append(("session", f"✓  {session_label}"))
+        self._choices.append(("deny", "✗  Deny"))
+        self._idx = 0  # default = run once → Enter approves
+
+    def compose(self):
+        # markup=False: the raw command/url is shown literally, never parsed.
+        yield Static(self._detail, id="perm-cmd", markup=False)
+        if self._warning:
+            yield Static(f"[bold {RED}]⚠ {escape(self._warning)}[/]", id="perm-warn")
+        for i in range(len(self._choices)):
+            yield Static("", id=f"perm-opt-{i}", classes="perm-opt")
+        yield Static(
+            f"[{LAVENDER}]↑↓[/] choose   [{LAVENDER}]↵[/] select   "
+            f"[{LAVENDER}]y[/]/[{LAVENDER}]a[/]/[{LAVENDER}]n[/] quick   "
+            f"[{LAVENDER}]esc[/] cancel turn   "
+            f"[{LAVENDER}]pgup[/]/[{LAVENDER}]shift+↑↓[/] scroll history",
+            id="perm-keys",
+        )
+
+    def on_mount(self) -> None:
+        self.border_title = f"approve tool · {self._tool}"
+        self.border_subtitle = f"risk: {self._risk}"
+        self._render_choices()
+        self.focus()
+
+    def _render_choices(self) -> None:
+        for i, (_value, text) in enumerate(self._choices):
+            row = self.query_one(f"#perm-opt-{i}", Static)
+            if i == self._idx:
+                row.update(f"[b {LAVENDER}]▸ {text}[/]")
+            else:
+                row.update(f"[{MUTED}]  {text}[/]")
+
+    def action_move(self, delta: int) -> None:
+        self._idx = (self._idx + delta) % len(self._choices)
+        self._render_choices()
+
+    def action_confirm(self) -> None:
+        self._resolve(self._choices[self._idx][0])
+
+    def action_pick(self, choice: str) -> None:
+        # 'a' must no-op when the session option isn't offered (dangerous bash).
+        if choice not in {v for v, _ in self._choices}:
+            return
+        self._resolve(choice)
+
+    def action_cancel_turn(self) -> None:
+        self._resolve("cancel")
+
+    def _resolve(self, value: str) -> None:
+        """Deliver the choice to the awaiting approver. Idempotent — a stray
+        second key (e.g. Enter after y) must not crash on an already-set Future.
+        Removal is left to the awaiter's finally so there's no double-remove."""
+        if not self._future.done():
+            self._future.set_result(value)