pi-repoprompt-cli 0.2.0 → 0.2.6

package/extensions/repoprompt-cli/readcache/replay.ts

@@ -0,0 +1,366 @@
+// readcache/replay.ts - replay-aware trust reconstruction for rp_exec(read_file)
+
+import type { ExtensionContext, SessionEntry } from "@mariozechner/pi-coding-agent";
+
+import { SCOPE_FULL } from "./constants.js";
+import { extractInvalidationFromSessionEntry, extractReadMetaFromSessionEntry } from "./meta.js";
+import type {
+    KnowledgeMap,
+    RpReadcacheInvalidationV1,
+    RpReadcacheMetaV1,
+    ScopeKey,
+    ScopeRangeKey,
+    ScopeTrust,
+} from "./types.js";
+
+type SessionManagerView = ExtensionContext["sessionManager"];
+
+type RangeBlockersByPath = Map<string, Set<ScopeRangeKey>>;
+
+const OVERLAY_SEQ_START = 1_000_000_000;
+
+interface ReplayMemoEntry {
+    knowledge: KnowledgeMap;
+    blockedRangesByPath: RangeBlockersByPath;
+}
+
+interface OverlayState {
+    leafId: string | null;
+    knowledge: KnowledgeMap;
+}
+
+export interface ReplayRuntimeState {
+    memoByLeaf: Map<string, ReplayMemoEntry>;
+    overlayBySession: Map<string, OverlayState>;
+    nextOverlaySeq: number;
+}
+
+export interface ReplayBoundary {
+    startIndex: number;
+    boundaryKey: string;
+}
+
+function cloneKnowledgeMap(source: KnowledgeMap): KnowledgeMap {
+    const cloned: KnowledgeMap = new Map();
+    for (const [pathKey, scopes] of source.entries()) {
+        const clonedScopes = new Map<ScopeKey, ScopeTrust>();
+        for (const [scopeKey, trust] of scopes.entries()) {
+            clonedScopes.set(scopeKey, { ...trust });
+        }
+        cloned.set(pathKey, clonedScopes);
+    }
+    return cloned;
+}
+
+function cloneRangeBlockersByPath(source: RangeBlockersByPath): RangeBlockersByPath {
+    const cloned: RangeBlockersByPath = new Map();
+    for (const [pathKey, scopes] of source.entries()) {
+        cloned.set(pathKey, new Set(scopes));
+    }
+    return cloned;
+}
+
+function cloneReplayMemoEntry(source: ReplayMemoEntry): ReplayMemoEntry {
+    return {
+        knowledge: cloneKnowledgeMap(source.knowledge),
+        blockedRangesByPath: cloneRangeBlockersByPath(source.blockedRangesByPath),
+    };
+}
+
+function getMemoKey(sessionId: string, leafId: string | null, boundaryKey: string): string {
+    return `${sessionId}:${leafId ?? "null"}:${boundaryKey}`;
+}
+
+function ensureScopeMap(knowledge: KnowledgeMap, pathKey: string): Map<ScopeKey, ScopeTrust> {
+    const existing = knowledge.get(pathKey);
+    if (existing) {
+        return existing;
+    }
+    const created = new Map<ScopeKey, ScopeTrust>();
+    knowledge.set(pathKey, created);
+    return created;
+}
+
+function isRangeScope(scopeKey: ScopeKey): scopeKey is ScopeRangeKey {
+    return scopeKey !== SCOPE_FULL;
+}
+
+function ensureRangeBlockerSet(blockedRangesByPath: RangeBlockersByPath, pathKey: string): Set<ScopeRangeKey> {
+    const existing = blockedRangesByPath.get(pathKey);
+    if (existing) {
+        return existing;
+    }
+    const created = new Set<ScopeRangeKey>();
+    blockedRangesByPath.set(pathKey, created);
+    return created;
+}
+
+function setRangeBlocker(blockedRangesByPath: RangeBlockersByPath, pathKey: string, scopeKey: ScopeRangeKey): void {
+    const scopes = ensureRangeBlockerSet(blockedRangesByPath, pathKey);
+    scopes.add(scopeKey);
+}
+
+function clearRangeBlocker(blockedRangesByPath: RangeBlockersByPath, pathKey: string, scopeKey: ScopeRangeKey): void {
+    const scopes = blockedRangesByPath.get(pathKey);
+    if (!scopes) {
+        return;
+    }
+    scopes.delete(scopeKey);
+    if (scopes.size === 0) {
+        blockedRangesByPath.delete(pathKey);
+    }
+}
+
+export function getTrust(knowledge: KnowledgeMap, pathKey: string, scopeKey: ScopeKey): ScopeTrust | undefined {
+    return knowledge.get(pathKey)?.get(scopeKey);
+}
+
+export function setTrust(knowledge: KnowledgeMap, pathKey: string, scopeKey: ScopeKey, hash: string, seq: number): void {
+    const scopes = ensureScopeMap(knowledge, pathKey);
+    scopes.set(scopeKey, { hash, seq });
+}
+
+function mergeKnowledge(base: KnowledgeMap, overlay: KnowledgeMap): KnowledgeMap {
+    const merged = cloneKnowledgeMap(base);
+    for (const [pathKey, overlayScopes] of overlay.entries()) {
+        const targetScopes = ensureScopeMap(merged, pathKey);
+        for (const [scopeKey, trust] of overlayScopes.entries()) {
+            targetScopes.set(scopeKey, { ...trust });
+        }
+    }
+    return merged;
+}
+
+function ensureOverlayForLeaf(runtimeState: ReplayRuntimeState, sessionId: string, leafId: string | null): OverlayState {
+    const existing = runtimeState.overlayBySession.get(sessionId);
+    if (!existing || existing.leafId !== leafId) {
+        const fresh: OverlayState = {
+            leafId,
+            knowledge: new Map(),
+        };
+        runtimeState.overlayBySession.set(sessionId, fresh);
+        return fresh;
+    }
+    return existing;
+}
+
+function leafHasChildren(sessionManager: SessionManagerView, leafId: string | null): boolean {
+    if (!leafId) {
+        return false;
+    }
+    return sessionManager.getEntries().some((entry) => entry.parentId === leafId);
+}
+
+function replaySnapshotFromBranch(branchEntries: SessionEntry[], startIndex: number): ReplayMemoEntry {
+    const knowledge: KnowledgeMap = new Map();
+    const blockedRangesByPath: RangeBlockersByPath = new Map();
+    const normalizedStart = Math.max(0, Math.min(startIndex, branchEntries.length));
+    let seq = 0;
+
+    for (let index = normalizedStart; index < branchEntries.length; index += 1) {
+        const entry = branchEntries[index];
+        if (!entry) {
+            continue;
+        }
+
+        const meta = extractReadMetaFromSessionEntry(entry);
+        if (meta) {
+            seq += 1;
+            applyReadMetaTransition(knowledge, meta, seq, blockedRangesByPath);
+            continue;
+        }
+
+        const invalidation = extractInvalidationFromSessionEntry(entry);
+        if (invalidation) {
+            applyInvalidation(knowledge, invalidation, blockedRangesByPath);
+        }
+    }
+
+    return {
+        knowledge,
+        blockedRangesByPath,
+    };
+}
+
+function getReplayMemoEntryForLeaf(
+    sessionManager: SessionManagerView,
+    runtimeState: ReplayRuntimeState,
+): { memoEntry: ReplayMemoEntry; sessionId: string; leafId: string | null } {
+    const sessionId = sessionManager.getSessionId();
+    const leafId = sessionManager.getLeafId();
+    const branchEntries = sessionManager.getBranch();
+    const boundary = findReplayStartIndex(branchEntries);
+    const memoKey = getMemoKey(sessionId, leafId, boundary.boundaryKey);
+
+    let memoEntry = runtimeState.memoByLeaf.get(memoKey);
+    if (!memoEntry) {
+        const replayMemo = replaySnapshotFromBranch(branchEntries, boundary.startIndex);
+        memoEntry = cloneReplayMemoEntry(replayMemo);
+        runtimeState.memoByLeaf.set(memoKey, memoEntry);
+    }
+
+    return {
+        memoEntry,
+        sessionId,
+        leafId,
+    };
+}
+
+export function createReplayRuntimeState(): ReplayRuntimeState {
+    return {
+        memoByLeaf: new Map(),
+        overlayBySession: new Map(),
+        nextOverlaySeq: OVERLAY_SEQ_START,
+    };
+}
+
+export function clearReplayRuntimeState(runtimeState: ReplayRuntimeState): void {
+    runtimeState.memoByLeaf.clear();
+    runtimeState.overlayBySession.clear();
+    runtimeState.nextOverlaySeq = OVERLAY_SEQ_START;
+}
+
+export function findReplayStartIndex(branchEntries: SessionEntry[]): ReplayBoundary {
+    for (let index = branchEntries.length - 1; index >= 0; index -= 1) {
+        const entry = branchEntries[index];
+        if (!entry || entry.type !== "compaction") {
+            continue;
+        }
+
+        return {
+            startIndex: Math.min(index + 1, branchEntries.length),
+            boundaryKey: `compaction:${entry.id}`,
+        };
+    }
+
+    return {
+        startIndex: 0,
+        boundaryKey: "root",
+    };
+}
+
+export function applyReadMetaTransition(
+    knowledge: KnowledgeMap,
+    meta: RpReadcacheMetaV1,
+    seq: number,
+    blockedRangesByPath?: RangeBlockersByPath,
+): void {
+    const { pathKey, scopeKey, servedHash, baseHash, mode } = meta;
+    const fullTrust = getTrust(knowledge, pathKey, SCOPE_FULL);
+    const rangeTrust = scopeKey === SCOPE_FULL ? undefined : getTrust(knowledge, pathKey, scopeKey);
+
+    if (mode === "full" || mode === "baseline_fallback") {
+        setTrust(knowledge, pathKey, scopeKey, servedHash, seq);
+        if (blockedRangesByPath && isRangeScope(scopeKey)) {
+            clearRangeBlocker(blockedRangesByPath, pathKey, scopeKey);
+        }
+        return;
+    }
+
+    if (mode === "unchanged" && scopeKey === SCOPE_FULL) {
+        if (!baseHash) {
+            return;
+        }
+        if (!fullTrust || fullTrust.hash !== baseHash) {
+            return;
+        }
+        if (servedHash !== baseHash) {
+            return;
+        }
+        setTrust(knowledge, pathKey, SCOPE_FULL, servedHash, seq);
+        return;
+    }
+
+    if (mode === "diff" && scopeKey === SCOPE_FULL) {
+        if (!baseHash) {
+            return;
+        }
+        if (!fullTrust || fullTrust.hash !== baseHash) {
+            return;
+        }
+        setTrust(knowledge, pathKey, SCOPE_FULL, servedHash, seq);
+        return;
+    }
+
+    if (mode === "unchanged_range" && scopeKey !== SCOPE_FULL) {
+        if (!baseHash) {
+            return;
+        }
+        if (rangeTrust?.hash !== baseHash && fullTrust?.hash !== baseHash) {
+            return;
+        }
+        setTrust(knowledge, pathKey, scopeKey, servedHash, seq);
+    }
+}
+
+export function applyInvalidation(
+    knowledge: KnowledgeMap,
+    invalidation: RpReadcacheInvalidationV1,
+    blockedRangesByPath?: RangeBlockersByPath,
+): void {
+    const scopes = knowledge.get(invalidation.pathKey);
+
+    if (invalidation.scopeKey === SCOPE_FULL) {
+        knowledge.delete(invalidation.pathKey);
+        blockedRangesByPath?.delete(invalidation.pathKey);
+        return;
+    }
+
+    if (blockedRangesByPath && isRangeScope(invalidation.scopeKey)) {
+        setRangeBlocker(blockedRangesByPath, invalidation.pathKey, invalidation.scopeKey);
+    }
+
+    if (!scopes) {
+        return;
+    }
+
+    scopes.delete(invalidation.scopeKey);
+    if (scopes.size === 0) {
+        knowledge.delete(invalidation.pathKey);
+    }
+}
+
+export function buildKnowledgeForLeaf(sessionManager: SessionManagerView, runtimeState: ReplayRuntimeState): KnowledgeMap {
+    const { memoEntry, sessionId, leafId } = getReplayMemoEntryForLeaf(sessionManager, runtimeState);
+    const overlayState = ensureOverlayForLeaf(runtimeState, sessionId, leafId);
+    if (leafHasChildren(sessionManager, leafId)) {
+        overlayState.knowledge.clear();
+    }
+    return mergeKnowledge(memoEntry.knowledge, overlayState.knowledge);
+}
+
+export function isRangeScopeBlockedByInvalidation(
+    sessionManager: SessionManagerView,
+    runtimeState: ReplayRuntimeState,
+    pathKey: string,
+    scopeKey: ScopeKey,
+): boolean {
+    if (!isRangeScope(scopeKey)) {
+        return false;
+    }
+
+    const { memoEntry, sessionId, leafId } = getReplayMemoEntryForLeaf(sessionManager, runtimeState);
+    const blockedScopes = memoEntry.blockedRangesByPath.get(pathKey);
+    if (!blockedScopes?.has(scopeKey)) {
+        return false;
+    }
+
+    const overlayState = ensureOverlayForLeaf(runtimeState, sessionId, leafId);
+    const overlayScopeTrust = overlayState.knowledge.get(pathKey)?.get(scopeKey);
+    return overlayScopeTrust === undefined;
+}
+
+export function overlaySet(
+    runtimeState: ReplayRuntimeState,
+    sessionManager: SessionManagerView,
+    pathKey: string,
+    scopeKey: ScopeKey,
+    servedHash: string,
+): void {
+    const sessionId = sessionManager.getSessionId();
+    const leafId = sessionManager.getLeafId();
+    const overlayState = ensureOverlayForLeaf(runtimeState, sessionId, leafId);
+    const seq = runtimeState.nextOverlaySeq;
+    runtimeState.nextOverlaySeq += 1;
+    setTrust(overlayState.knowledge, pathKey, scopeKey, servedHash, seq);
+}

package/extensions/repoprompt-cli/readcache/resolve.ts

@@ -0,0 +1,235 @@
+// readcache/resolve.ts - resolve rp-cli read_file paths to local absolute paths
+
+import { access } from "node:fs/promises";
+import * as path from "node:path";
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+export interface ResolvePathResult {
+    absolutePath: string | null;
+    repoRoot: string | null;
+    pathDisplay: string;
+}
+
+async function fileExists(absolutePath: string): Promise<boolean> {
+    try {
+        await access(absolutePath);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function normalizeRootLine(line: string): string | null {
+    let trimmed = line.trim();
+
+    if (!trimmed) {
+        return null;
+    }
+
+    // Handle bullet lists like "- /path" or "• /path"
+    trimmed = trimmed.replace(/^[-*•]\s+/, "");
+
+    // Expand home
+    if (trimmed.startsWith("~")) {
+        // We intentionally don't expand here; rp-cli roots should be absolute already
+        return null;
+    }
+
+    if (path.isAbsolute(trimmed)) {
+        return trimmed;
+    }
+
+    return null;
+}
+
+function parseRootList(text: string): string[] {
+    const roots = new Set<string>();
+
+    for (const line of text.split("\n")) {
+        const root = normalizeRootLine(line);
+        if (root) {
+            roots.add(root);
+        }
+    }
+
+    return [...roots];
+}
+
+const ROOTS_CACHE = new Map<number, string[]>();
+
+export function clearRootsCache(windowId?: number): void {
+    if (windowId !== undefined) {
+        ROOTS_CACHE.delete(windowId);
+        return;
+    }
+    ROOTS_CACHE.clear();
+}
+
+async function fetchWindowRootsViaCli(pi: ExtensionAPI, windowId: number, tab?: string): Promise<string[]> {
+    const args: string[] = ["-w", String(windowId)];
+    if (tab) {
+        args.push("-t", tab);
+    }
+
+    // Use rp-cli exec mode to call the underlying MCP tool. This reliably returns one absolute root per line.
+    // (Using `tree type=roots` is NOT supported by rp-cli and can return an error string instead of roots.)
+    args.push("-q", "-e", 'call get_file_tree {"type":"roots"}');
+
+    const result = await pi.exec("rp-cli", args, { timeout: 10_000 });
+    const stdout = result.stdout ?? "";
+    const stderr = result.stderr ?? "";
+    const output = [stdout, stderr].filter(Boolean).join("\n");
+
+    return parseRootList(output);
+}
+
+async function getWindowRootsCached(pi: ExtensionAPI, windowId: number, tab?: string): Promise<string[]> {
+    const cached = ROOTS_CACHE.get(windowId);
+    if (cached) {
+        return cached;
+    }
+
+    const roots = await fetchWindowRootsViaCli(pi, windowId, tab);
+    ROOTS_CACHE.set(windowId, roots);
+    return roots;
+}
+
+function parseRootPrefixedPath(rawPath: string): { rootHint: string; relPath: string } | null {
+    // rootHint:rel/path
+    const colonIdx = rawPath.indexOf(":");
+    if (colonIdx > 0) {
+        const rootHint = rawPath.slice(0, colonIdx).trim();
+        const relPath = rawPath.slice(colonIdx + 1).replace(/^\/+/, "");
+        if (rootHint && relPath) {
+            return { rootHint, relPath };
+        }
+    }
+
+    // rootHint/rel/path (common in RP outputs)
+    const parts = rawPath.split(/[\\/]+/).filter(Boolean);
+    if (parts.length >= 2) {
+        return { rootHint: parts[0] ?? "", relPath: parts.slice(1).join("/") };
+    }
+
+    return null;
+}
+
+function pickRepoRootForFile(absolutePath: string, roots: string[]): string | null {
+    const normalized = path.resolve(absolutePath);
+
+    let best: string | null = null;
+    let bestDepth = -1;
+
+    for (const root of roots) {
+        const resolvedRoot = path.resolve(root);
+
+        if (normalized === resolvedRoot) {
+            const depth = resolvedRoot.split(path.sep).filter(Boolean).length;
+            if (depth > bestDepth) {
+                best = resolvedRoot;
+                bestDepth = depth;
+            }
+            continue;
+        }
+
+        const rel = path.relative(resolvedRoot, normalized);
+        if (rel.startsWith("..") || path.isAbsolute(rel)) {
+            continue;
+        }
+
+        const depth = resolvedRoot.split(path.sep).filter(Boolean).length;
+        if (depth > bestDepth) {
+            best = resolvedRoot;
+            bestDepth = depth;
+        }
+    }
+
+    return best;
+}
+
+export async function resolveReadFilePath(
+    pi: ExtensionAPI,
+    inputPath: string,
+    cwd: string,
+    windowId: number,
+    tab?: string,
+): Promise<ResolvePathResult> {
+    const pathDisplay = inputPath;
+
+    const roots = await getWindowRootsCached(pi, windowId, tab);
+
+    if (path.isAbsolute(inputPath)) {
+        const absolutePath = (await fileExists(inputPath)) ? inputPath : null;
+        if (!absolutePath) {
+            return { absolutePath: null, repoRoot: null, pathDisplay };
+        }
+
+        return {
+            absolutePath,
+            repoRoot: pickRepoRootForFile(absolutePath, roots),
+            pathDisplay,
+        };
+    }
+
+    // rootHint:relPath or rootHint/relPath
+    const rootPrefixed = parseRootPrefixedPath(inputPath);
+    if (rootPrefixed) {
+        const { rootHint, relPath } = rootPrefixed;
+
+        const matches: Array<{ abs: string; root: string }> = [];
+
+        for (const root of roots) {
+            const baseName = path.basename(root);
+            if (baseName !== rootHint) {
+                continue;
+            }
+
+            const abs = path.join(root, relPath);
+            if (await fileExists(abs)) {
+                matches.push({ abs, root });
+            }
+        }
+
+        if (matches.length === 1) {
+            const match = matches[0];
+            return {
+                absolutePath: match?.abs ?? null,
+                repoRoot: match?.root ?? null,
+                pathDisplay,
+            };
+        }
+
+        if (matches.length > 1) {
+            // Ambiguous: same rootHint resolves to multiple roots
+            return { absolutePath: null, repoRoot: null, pathDisplay };
+        }
+    }
+
+    // Try path under each root
+    const matches: Array<{ abs: string; root: string }> = [];
+    for (const root of roots) {
+        const abs = path.join(root, inputPath);
+        if (await fileExists(abs)) {
+            matches.push({ abs, root });
+        }
+    }
+
+    if (matches.length === 1) {
+        const match = matches[0];
+        return {
+            absolutePath: match?.abs ?? null,
+            repoRoot: match?.root ?? null,
+            pathDisplay,
+        };
+    }
+
+    if (matches.length > 1) {
+        // Ambiguous: multiple roots contain this relative path
+        // Fail open: do NOT fall back to Pi's process cwd, as that can mismatch RepoPrompt's own path resolution
+        return { absolutePath: null, repoRoot: null, pathDisplay };
+    }
+
+    // No match under any root
+    return { absolutePath: null, repoRoot: null, pathDisplay };
+}

package/extensions/repoprompt-cli/readcache/text.ts

@@ -0,0 +1,43 @@
+// readcache/text.ts - line helpers + truncation
+
+import { truncateHead, type TruncationOptions, type TruncationResult } from "@mariozechner/pi-coding-agent";
+
+function validateRange(start: number, end: number): void {
+    if (!Number.isInteger(start) || start <= 0) {
+        throw new Error(`Invalid start line "${start}". Line numbers must be positive integers.`);
+    }
+    if (!Number.isInteger(end) || end <= 0) {
+        throw new Error(`Invalid end line "${end}". Line numbers must be positive integers.`);
+    }
+    if (end < start) {
+        throw new Error(`Invalid range ${start}-${end}. End line must be greater than or equal to start line.`);
+    }
+}
+
+export function splitLines(text: string): string[] {
+    // Match typical editor line counting semantics: a trailing newline does not create an extra empty line
+    const lines = text.split("\n");
+    if (lines.length > 1 && lines[lines.length - 1] === "") {
+        return lines.slice(0, -1);
+    }
+    return lines;
+}
+
+export function sliceByLineRange(text: string, start: number, end: number): string {
+    validateRange(start, end);
+    const lines = splitLines(text);
+    if (start > lines.length) {
+        return "";
+    }
+
+    const clampedEnd = Math.min(end, lines.length);
+    return lines.slice(start - 1, clampedEnd).join("\n");
+}
+
+export function compareSlices(oldText: string, newText: string, start: number, end: number): boolean {
+    return sliceByLineRange(oldText, start, end) === sliceByLineRange(newText, start, end);
+}
+
+export function truncateForReadcache(content: string, options?: TruncationOptions): TruncationResult {
+    return truncateHead(content, options);
+}