pi-repoprompt-mcp 0.3.0 → 0.4.9

package/README.md

@@ -1,15 +1,10 @@
 # RepoPrompt MCP for Pi (`pi-repoprompt-mcp`)
 
-A token-efficient RepoPrompt MCP integration for Pi.
+This extension provides a single tool (`rp`) that exposes RepoPrompt MCP tools to Pi, includes branch-safe window and tab binding (auto-detect and bind to window by `cwd`, auto-bind to safe tab, persist and restore across sessions and session tree nodes, and interactive selection of windows and tabs) and batches of read files (automatically selected as context in the RepoPrompt desktop app), renders RepoPrompt tool outputs (syntax + diff highlighting), and applies guardrails for destructive operations.
 
-Exposes a single `rp` tool (RepoPrompt MCP proxy) plus `/rp …` commands, with:
-- window/tab binding (auto-detect by `cwd`, optional persistence); these are branch-safe across navigation of the session DAG via `/tree` and across `/fork`ed sessions
-- output rendering (syntax + diff highlighting; uses `delta` when installed, honoring the user's global git/delta color config, with graceful fallback)
-- safety guardrails (deletes blocked unless explicitly allowed; optional edit confirmation)
-- optional [Gurpartap/pi-readcache](https://github.com/Gurpartap/pi-readcache)-like caching for RepoPrompt `read_file` results (unchanged markers + diffs) to save on tokens
-- optional auto-selection in the RP UI (e.g. for use in RP Chat) of slices/files the agent has read; these selections are also branch-safe across `/tree` navigation and `/fork`ed session
+The extension's window- and tab-related management features allow a workflow where new Pi sessions automatically attach to the required workspace and tab without clobbering your, or other agents', parallel usage of RepoPrompt.  Because it recovers the window, tab, and auto-selected read-files context when you rewind via `/tree` or restore a session, all the context the agent has built up (and automatically selected in the RepoPrompt app) by reading files and slices up to that point always remains available in the app for RP Chat (see `/rp oracle` below) or external "oracle" (e.g. GPT-x Pro) use cases.  Recovery is based on the required root(s) of the saved selection state, so it can reattach to any open workspace that already contains those roots rather than requiring the original workspace name; if multiple open workspaces satisfy that requirement and `cwd` does not disambiguate them, then you should re-bind with `/rp bind`.
 
-## Install
+## Installation
 
 From npm:
 
@@ -35,28 +30,114 @@ Add to `~/.pi/agent/settings.json` (or replace an existing unfiltered `git:githu
 }
 ```
 
+## Features
+
+### Window and tab binding
+
+- Auto-binds to the RepoPrompt window that matches `process.cwd()` (by workspace roots, resolving symlinks to their real paths before matching)
+  - If multiple windows match, you're prompted to pick one
+  - Window binding is (optionally) persisted across session reloads and session tree nodes
+- If a bound window has an existing tab with zero selected files and no chats, the extension binds to that tab; otherwise it provisions a new tab and binds to that
+- Deterministically reconciles the session tree node's bound tab, and can restore the tab already associated with that node or provision a new safe tab when needed
+- User-driven binding via `/rp bind` (windows) or `/rp tab` (tabs); agents can use `rp({ bind: ... })`
+- In addition to window bindings, tab bindings and auto-selected read-files context is stored and automatically recovered across node rewinds via `/tree`, different sessions (e.g., created via `/fork`), and resumed sessions
+
+Forked sessions inherit the parent session-plus-node's window, tab, and auto-selected context snapshot at the fork point (unless you rewind in the forked session and switch window/tab/etc.), then can diverge independently as later reads or manual tab switches are performed in the child session.  Binding is non-invasive, in that it doesn't change RepoPrompt's globally active window, and automatic tab provisioning uses background tabs (`focus=false`) without stealing UI focus.  This is to prevent interference when multiple agents (or your manual usage of RepoPrompt in parallel to a Pi session) are using this extension and need to target different windows or tabs simultaneously.
+
+### Output rendering
+
+- Syntax highlighting for code blocks and codemaps in `read_file`, and for code blocks in outputs of `apply_edits`, `file_actions create/delete`, and `git`
+- Common non-mutating RepoPrompt actions (`read_file`, `file_search`, `get_file_tree`, `get_code_structure`, `workspace_context`, routing helpers like `manage_workspaces`, and control/discovery actions like `windows`/`bind`/`status`/`search`/`describe`) get concise request-driven call/result summaries in collapsed mode.  The call line carries intent while the result line carries outcome, so the transcript stays compact without echoing the same label twice.  These summaries are derived from the arguments Pi sent, not by parsing RepoPrompt's prose output, and unknown tools fall back to normal collapsed rendering
+<img width="270" height="936" alt="Image" src="https://github.com/user-attachments/assets/142ca6c2-c1cf-4f0b-b41b-3d52d623c78c" />
+- RepoPrompt `apply_edits` calls are forwarded with `verbose: true` by default (unless `raw: true`), while the returned diff is normalized into `details.diff` and presented to the agent as a terse summary.  The same is done for `file_actions create/delete` outputs, so you see all edited/created/deleted LOC with rich rendering but the extension prevents the context window from getting bloated by round-tripping tool I/O tokens
+- Adaptive diff rendering for RepoPrompt `git` and `apply_edits` outputs by default (`diffViewMode: "auto"` picks split, unified, compact, or summary at render time based on pane width).  This uses the active Pi theme's `toolDiffAdded`, `toolDiffRemoved`, and `toolDiffContext` colors (typically mapped to chosen hues for green and red), and its visual design and rendering logic are indebted to [MasuRii/pi-tool-display](https://github.com/MasuRii/pi-tool-display).  Two different examples at different pane widths:
+<img width="1027" height="256" alt="horizontal" src="https://github.com/user-attachments/assets/31943d5b-475c-4254-813b-18bf9bd79d60" />
+<img width="629" height="302" alt="vertical" src="https://github.com/user-attachments/assets/fe4fc253-6bda-49e3-a37e-918244eb9e05" />
+- Generic fenced diff blocks, and adaptive-diff parse failures, fall back to a simpler diff renderer, which uses `delta` if installed or otherwise the built-in highlighter
+- Markdown-aware styling for headings and lists
+
+### Safety checks
+
+- Delete operations are blocked unless you pass `allowDelete: true`
+- Optional edit confirmation gate for edit-like operations (`confirmEdits`)
+- Warn on in-place workspace switches (when applicable)
+
 ## Requirements
 
-- RepoPrompt installed
-- RepoPrompt MCP server reachable (stdio transport)
-  - If the server is not configured/auto-detected, the package will still load, but `rp(...)` will error until you configure it
-- `rp-cli` on `PATH` is recommended (used as a fallback for window discovery)
+- RepoPrompt MCP server configured and reachable (stdio transport)
+  - If the server is not configured/auto-detected, the extension will still load, but `rp(...)` will error until you configure it
+- `rp-cli` available in `PATH` is recommended (used as a fallback for window discovery)
+
+### Compatibility notes
+
+This extension tries to be tolerant of **tool name prefixing** (e.g. `RepoPrompt_list_windows` vs `list_windows`), but it is still dependent on a small set of capabilities and their semantics remaining reasonably stable across RepoPrompt versions:
+
+- **Window discovery**: `list_windows`
+  - If `list_windows` is not exposed by the MCP server, the extension falls back to `rp-cli -e 'windows'`
+  - If neither is available, window listing/binding features will be limited
+- **Workspace root discovery (auto-bind by cwd)**: `get_file_tree` with `{ type: "roots" }` (scoped by `_windowID`)
+  - If unavailable (or if parameters/semantics change), auto-binding may be disabled or less accurate
+- Selection summary: `manage_selection` with `{ op: "get", view: "files" }` and `{ op: "get", view: "summary" }`
+  - If these are unavailable (or if parameters/semantics change), the status output may omit file/token counts
+
+If RepoPrompt renames/removes these tools or changes their required parameters/output formats, this extension may need updates
 
 ## Usage
 
-Commands:
-- `/rp status`
-- `/rp windows`
-- `/rp bind`
-- `/rp reconnect`
-- `/rp readcache-status`
-- `/rp readcache-refresh <path> [start-end]`
+### Commands
+
+- `/rp status` — show status (connection + binding), including the currently bound tab name and a label like `[bound, in-focus]` or `[bound, out-of-focus]`, plus current selected file counts and estimated token counts
+
+<p align="center">
+  <img width="210" alt="status" src="https://github.com/user-attachments/assets/bd59af9e-7df1-4572-8baf-edb6f8f7a0df" />
+</p>
+
+- `/rp windows` — list available RepoPrompt windows
+- `/rp bind` — interactive workflow for choosing the RepoPrompt window
+- `/rp bind <id> [tab]` — direct option if you already know the target window id (and optionally an exact tab name or tab id); when `[tab]` is omitted, the extension restores the branch's tab for that window or provisions a fresh background tab once
+- `/rp tab` — interactive tab picker for the current bound window, with `Create new tab` as the first option followed by existing tab names
+- `/rp tab new` — create and bind a fresh tab on the current bound window
+- `/rp tab <name-or-id>` — bind an existing tab on the current bound window by name or id
+- `/rp oracle [--mode <chat|plan|edit|review>] [--name <chat name>] [--continue|--chat-id <id>] <message>` — ask RepoPrompt chat with current selection context.  If `--mode` not specified, uses `oracleDefaultMode` config.
+- `/rp reconnect` — reconnect to RepoPrompt
+
+### Tool: `rp`
+
+Examples:
 
-Tool:
 ```ts
+// Status (connection + binding)
+rp({ })
+
+// List windows (best-effort; uses MCP tool if available, otherwise rp-cli)
 rp({ windows: true })
+
+// Bind to a specific window (does not change RepoPrompt active window)
 rp({ bind: { window: 3 } })
+
+// Bind to an exact tab in that window
+rp({ bind: { window: 3, tab: "T2" } })
+
+// Search or describe tools
+rp({ search: "file" })
+rp({ describe: "apply_edits" })
+
+// Call a RepoPrompt tool (binding args are injected automatically)
 rp({ call: "read_file", args: { path: "src/main.ts" } })
+
+// Edit confirmation gate (only required if confirmEdits=true in config)
+rp({
+  call: "apply_edits",
+  args: { path: "file.ts", search: "old", replace: "new" },
+  confirmEdits: true
+})
+
+// Delete guard override
+rp({
+  call: "file_actions",
+  args: { action: "delete", path: "temp.txt" },
+  allowDelete: true
+})
 ```
 
 ## Configuration
@@ -65,32 +146,82 @@ Create `~/.pi/agent/extensions/repoprompt-mcp.json`:
 
 ```json
 {
+  "command": "rp-mcp-server",
+  "args": [],
+
   "autoBindOnStart": true,
   "persistBinding": true,
+
   "confirmDeletes": true,
   "confirmEdits": false,
-  "readcacheReadFile": true,
-  "collapsedMaxLines": 3
-}
-```
-
-`collapsedMaxLines` controls how many lines of RepoPrompt tool output Pi shows in collapsed view before you expand the result. It applies across `rp(...)` calls, so it is the main knob for keeping window listings, reads, and other RepoPrompt responses compact in the TUI. `3` is the best default if you want maximally compressed but still informative output.
 
-If the MCP server is not auto-detected, set `command` explicitly:
+  "readcacheReadFile": true,
+  "autoSelectReadSlices": true,
+  "oracleDefaultMode": "chat",
 
-```json
-{
-  "command": "/Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp",
-  "args": []
+  "collapsedMaxLines": 3,
+  "diffViewMode": "auto",
+  "diffSplitMinWidth": 120,
+  "suppressHostDisconnectedLog": true
 }
 ```
 
-(Alternatively, configure RepoPrompt in `~/.pi/agent/mcp.json`)
-
-For more detail, see: `extensions/repoprompt-mcp/README.md` in the dot314 repo.
+`collapsedMaxLines` controls how many rendered lines of RepoPrompt tool output Pi shows before the result is expanded for the generic fallback path.  In addition, the extension now emits hand-authored one-line or two-line collapsed summaries for common non-mutating actions like `read_file`, `file_search`, `get_file_tree`, `get_code_structure`, `workspace_context`, `windows`, `bind`, and `status`; these are derived from Pi's own request metadata rather than RepoPrompt's returned prose.  Unknown or unsupported tools still fall back to the normal `collapsedMaxLines` behavior.  LOC-changing operations are the other exception: verbose RepoPrompt `apply_edits` and rendered `file_actions create/delete` results ignore `collapsedMaxLines` once normalized into `details.diff`, so the full rendered code changes remain visible.
+
+Options:
+
+| Option | Default | Description |
+|---|---:|---|
+| `command` | auto-detect | MCP server command |
+| `args` | `[]` | MCP server args |
+| `env` | unset | Extra environment variables for the MCP server |
+| `autoBindOnStart` | `true` | Auto-detect and bind on session start, then reconcile the branch-safe tab for the chosen window |
+| `persistBinding` | `true` | Persist window and tab bindings in Pi session history for branch-safe replay |
+| `confirmDeletes` | `true` | Block delete operations unless `allowDelete: true` |
+| `confirmEdits` | `false` | Block edit-like operations unless `confirmEdits: true` |
+| `readcacheReadFile` | `false` | Enable [pi-readcache](https://github.com/Gurpartap/pi-readcache)-like caching for RepoPrompt `read_file` calls (returns unchanged markers/diffs on repeat reads to save on tokens and prevent context bloat) |
+| `autoSelectReadSlices` | `true` | Automatically track `read_file` calls by adding slices/full-file selection via `manage_selection`, so `chat_send` (or a manually created chat in the RP app) uses everything the agent has read as context; these file/slice selections are **branch-safe** across `/tree` rewinds and `/fork`ed session branches via extension-owned snapshot replay |
+| `oracleDefaultMode` | `"chat"` | Default mode for `/rp oracle` when `--mode` is omitted (`chat`, `plan`, `edit`, or `review`) |
+| `collapsedMaxLines` | `3` | Lines shown in collapsed view |
+| `diffViewMode` | `"auto"` | Diff layout for RepoPrompt `git` / `apply_edits` fenced diff output (`auto`, `split`, `unified`) |
+| `diffSplitMinWidth` | `120` | Minimum render width before `diffViewMode: "auto"` uses split diff layout |
+| `suppressHostDisconnectedLog` | `true` | Filter noisy stderr from macOS `repoprompt-mcp` (disconnect/retry bootstrap logs) |
+
+Automatic tab restoration and provisioning is driven by `autoBindOnStart` and `persistBinding`; there is no separate tab-only configuration surface. Adaptive diff layout applies only to RepoPrompt `git` and `apply_edits` outputs that arrive as fenced `diff` blocks; other rendered output stays on the existing text-based path.
+
+Note: when `readcacheReadFile` is enabled, the extension may persist UTF-8 file snapshots to an on-disk content-addressed store under
+`<repo-root>/.pi/readcache/objects` to compute diffs/unchanged markers across calls. Common secret filenames (e.g. `.env*`, `*.pem`) are excluded,
+but this is best-effort
 
 ## Readcache gotchas
 
 - `raw: true` disables readcache (and rendering). Don't use unless debugging
 - Need full content? use `bypass_cache: true` in `read_file` args
 - Multi-root: use absolute or specific relative paths (MCP `read_file` has no `RootName:` disambiguation)
+
+## Troubleshooting
+
+### "Not connected to RepoPrompt"
+- Ensure RepoPrompt is running
+- Verify the MCP server command in config
+- Run `/rp reconnect`
+
+### Pi becomes unresponsive after closing/restarting RepoPrompt
+If the RepoPrompt MCP server stops responding (for example, if the RepoPrompt app is closed while Pi stays open), tool calls may time out. When that happens, the extension will drop the connection and you can recover with `/rp reconnect`.
+
+### "No matching window found"
+- Your `cwd` may not match any RepoPrompt workspace root
+- Use `/rp windows` to list windows
+- Use `/rp bind` to pick one
+
+### Window listing doesn't work
+- If the MCP server does not expose a `list_windows` tool, this extension uses `rp-cli -e 'windows'`
+- Make sure `rp-cli` is installed and on your `PATH`
+- If RepoPrompt is in single-window mode, `rp-cli -e 'windows'` may report single-window mode
+
+### Delete operation blocked
+- Pass `allowDelete: true` on the `rp` call
+
+## License
+
+MIT

package/extensions/repoprompt-mcp/src/auto-select.ts

@@ -3,6 +3,12 @@
 import * as fs from "node:fs";
 import { stat } from "node:fs/promises";
 
+import type {
+  AutoSelectionEntryData,
+  AutoSelectionEntryRangeData,
+  AutoSelectionEntrySliceData,
+} from "./types.js";
+
 export type SelectionMode = "full" | "slices" | "codemap_only";
 
 export interface SelectionStatus {
@@ -118,8 +124,128 @@ export function inferSelectionStatus(selectionText: string, selectionPath: strin
       continue;
     }
 
-    const parentPrefix = prefixes[indentDepth] ?? baseDir;
-    if (!parentPrefix) {
+    const parentPrefix = prefixes[indentDepth] ?? baseDir ?? (indentDepth === 0 ? "" : null);
+    if (parentPrefix === null) {
+      continue;
+    }
+
+    const nodePath = joinPath(parentPrefix, name);
+
+    if (name.endsWith("/")) {
+      prefixes[indentDepth + 1] = normalizeDir(nodePath);
+      prefixes.length = indentDepth + 2;
+      continue;
+    }
+
+    const match = considerMatch(nodePath, rest);
+    if (match) {
+      return match;
+    }
+  }
+
+  return null;
+}
+
+export function inferSelectionSliceRanges(
+  selectionText: string,
+  selectionPath: string
+): AutoSelectionEntryRangeData[] | null {
+  if (!selectionText || !selectionPath) {
+    return null;
+  }
+
+  const target = toPosixPath(selectionPath).replace(/\/+$/, "");
+
+  const normalizeDir = (dir: string): string => {
+    const normalized = toPosixPath(dir).trim();
+    return normalized.endsWith("/") ? normalized : `${normalized}/`;
+  };
+
+  const joinPath = (dir: string, name: string): string => {
+    if (!dir) {
+      return name;
+    }
+    return dir.endsWith("/") ? `${dir}${name}` : `${dir}/${name}`;
+  };
+
+  const lines = selectionText.split("\n");
+
+  let section: "selected" | "codemaps" | null = null;
+
+  let baseDir: string | null = null;
+  const prefixes: string[] = [];
+
+  const considerMatch = (nodePath: string, rest: string): AutoSelectionEntryRangeData[] | null => {
+    const normalizedNode = toPosixPath(nodePath).replace(/\/+$/, "");
+    if (normalizedNode !== target) {
+      return null;
+    }
+
+    if (section !== "selected") {
+      return null;
+    }
+
+    const allRangesMatch = rest.match(/\(lines\s+([^)]*)\)/i);
+    if (!allRangesMatch) {
+      return null;
+    }
+
+    const rangesText = allRangesMatch[1] ?? "";
+    const ranges = [...rangesText.matchAll(/(\d+)\s*[-–—]\s*(\d+)/g)]
+      .map((m) => ({
+        start_line: Number(m[1]),
+        end_line: Number(m[2]),
+      }))
+      .filter((range) => Number.isFinite(range.start_line) && Number.isFinite(range.end_line))
+      .filter((range) => range.start_line > 0 && range.end_line >= range.start_line);
+
+    return ranges.length > 0 ? ranges : null;
+  };
+
+  for (const rawLine of lines) {
+    const line = toPosixPath(rawLine).trimEnd();
+
+    if (line.includes("### Selected Files")) {
+      section = "selected";
+      baseDir = null;
+      prefixes.length = 0;
+      continue;
+    }
+
+    if (line.includes("### Codemaps")) {
+      section = "codemaps";
+      baseDir = null;
+      prefixes.length = 0;
+      continue;
+    }
+
+    if (line.endsWith("/") && !line.includes("──") && !line.includes(" — ")) {
+      baseDir = normalizeDir(line);
+      prefixes.length = 0;
+      prefixes.push(baseDir);
+      continue;
+    }
+
+    const markerMatch = line.match(/(├──|└──)\s+(.*)$/);
+    if (!markerMatch) {
+      continue;
+    }
+
+    const marker = markerMatch[1] ?? "";
+    const markerIdx = line.indexOf(marker);
+    const indentPrefix = markerIdx >= 0 ? line.slice(0, markerIdx) : "";
+
+    const indentDepth = Math.floor(indentPrefix.length / 4);
+
+    const rest = (markerMatch[2] ?? "").trim();
+    const name = rest.split(" — ")[0]?.trim() ?? "";
+
+    if (!name) {
+      continue;
+    }
+
+    const parentPrefix = prefixes[indentDepth] ?? baseDir ?? (indentDepth === 0 ? "" : null);
+    if (parentPrefix === null) {
       continue;
     }
 
@@ -203,6 +329,30 @@ export async function countFileLines(absolutePath: string): Promise<number> {
   return lines;
 }
 
+export function isWholeFileReadFromArgs(
+  startLine: number | undefined,
+  limit: number | undefined,
+  totalLines: number | undefined
+): boolean {
+  if (typeof totalLines !== "number" || totalLines <= 0 || typeof startLine !== "number") {
+    return false;
+  }
+
+  if (startLine > 0) {
+    if (typeof limit !== "number" || limit <= 0) {
+      return false;
+    }
+
+    return startLine === 1 && totalLines <= limit;
+  }
+
+  if (startLine < 0) {
+    return Math.abs(startLine) >= totalLines;
+  }
+
+  return false;
+}
+
 export function computeSliceRangeFromReadArgs(
   startLine: number | undefined,
   limit: number | undefined,
@@ -212,6 +362,10 @@ export function computeSliceRangeFromReadArgs(
     return null;
   }
 
+  if (isWholeFileReadFromArgs(startLine, limit, totalLines)) {
+    return null;
+  }
+
   // Positive range reads
   if (startLine > 0) {
     if (typeof limit !== "number" || limit <= 0) {
@@ -241,3 +395,80 @@ export function computeSliceRangeFromReadArgs(
 
   return null;
 }
+
+function normalizeSelectionRanges(ranges: AutoSelectionEntryRangeData[]): AutoSelectionEntryRangeData[] {
+  const normalized = ranges
+    .map((range) => ({
+      start_line: Number(range.start_line),
+      end_line: Number(range.end_line),
+    }))
+    .filter((range) => Number.isFinite(range.start_line) && Number.isFinite(range.end_line))
+    .filter((range) => range.start_line > 0 && range.end_line >= range.start_line)
+    .sort((a, b) => {
+      if (a.start_line !== b.start_line) {
+        return a.start_line - b.start_line;
+      }
+      return a.end_line - b.end_line;
+    });
+
+  const merged: AutoSelectionEntryRangeData[] = [];
+  for (const range of normalized) {
+    const last = merged[merged.length - 1];
+    if (!last) {
+      merged.push(range);
+      continue;
+    }
+
+    if (range.start_line <= last.end_line + 1) {
+      last.end_line = Math.max(last.end_line, range.end_line);
+      continue;
+    }
+
+    merged.push(range);
+  }
+
+  return merged;
+}
+
+export function applyFullReadToSelectionState(
+  state: AutoSelectionEntryData,
+  selectionPath: string
+): AutoSelectionEntryData {
+  const normalizedPath = toPosixPath(selectionPath);
+
+  return {
+    ...state,
+    fullPaths: [...state.fullPaths, normalizedPath],
+    slicePaths: state.slicePaths.filter((entry) => entry.path !== normalizedPath),
+  };
+}
+
+export function applySliceReadToSelectionState(
+  state: AutoSelectionEntryData,
+  selectionPath: string,
+  range: AutoSelectionEntryRangeData
+): AutoSelectionEntryData {
+  const normalizedPath = toPosixPath(selectionPath);
+
+  if (state.fullPaths.includes(normalizedPath)) {
+    return {
+      ...state,
+      fullPaths: [...state.fullPaths],
+      slicePaths: [...state.slicePaths],
+    };
+  }
+
+  const existing = state.slicePaths.find((entry) => entry.path === normalizedPath);
+
+  const nextSlicePaths: AutoSelectionEntrySliceData[] = state.slicePaths.filter((entry) => entry.path !== normalizedPath);
+  nextSlicePaths.push({
+    path: normalizedPath,
+    ranges: normalizeSelectionRanges([...(existing?.ranges ?? []), range]),
+  });
+
+  return {
+    ...state,
+    fullPaths: [...state.fullPaths],
+    slicePaths: nextSlicePaths,
+  };
+}