pi-vscode-sr 1.4.6 → 1.4.7

package/README.md

@@ -17,8 +17,8 @@ Secure code review bridge between **Pi coding agent** and **VS Code**. Every fil
 | ✅ **Approve** | Apply this file's changes |
 | ❌ **Reject** | Discard this file's changes — agent sees an error and must retry |
 | 💭 **Rethink** | Open a text input dialog to give the agent feedback — e.g. «use async/await instead of promise chains». Changes are not applied, agent sees your feedback and can retry with corrections. |
-| ⭐ **Approve All** | Auto-approve every future change for this session |
-| 🚪 **Abort** | Stop the agent session immediately |
+| ⭐ **Approve All** | Auto-approve every future change for this prompt run. Clear on next prompt. |
+| 🚪 **Abort** | Stop the agent session immediately. |
 
 You can also approve/reject from the diff tab.
 
@@ -31,6 +31,7 @@ You can also approve/reject from the diff tab.
 > - .pi/review-requests/
 > - .pi/review-results/
 > - .pi/tmp/
+> - .pi/.vscode-ready
 
 ### 1. Pi Extension
 
@@ -38,7 +39,11 @@ You can also approve/reject from the diff tab.
 pi install npm:pi-vscode-sr
 ```
 
-Or install locally:
+Or install locally (**Recommended**):
+
+> [!IMPORTANT]
+> I recommend to install it locally because not every folder is a project of Visual Studio Code. Although there is a mechanism to detect if project is opened in VS Code or not anyway it could lead to unexpected behavior.
+
 
 ```bash
 pi install npm:pi-vscode-sr -l

package/dist/index.js

@@ -9,61 +9,89 @@ const path_1 = require("path");
 // ─── Session state ───────────────────────────────────────────────────
 const sessionReviewIds = new Set();
 const sessionApproveAll = new Set(); // review IDs auto-approved
+let projectCwd = null;
+let vscodeNotOpenWarned = false;
+// ─── Helper: check if VS Code is watching this project ─────────────
+function isVscodeReady(cwd) {
+    try {
+        const readyFile = (0, path_1.join)(cwd, '.pi', '.vscode-ready');
+        if (!(0, fs_1.existsSync)(readyFile))
+            return false;
+        const ts = parseInt((0, fs_1.readFileSync)(readyFile, 'utf-8').trim(), 10);
+        if (isNaN(ts))
+            return false;
+        // Timestamp must be within last 30 seconds (heartbeat = 15s interval)
+        return Date.now() - ts < 30_000;
+    }
+    catch {
+        return false;
+    }
+}
 async function createReviewAndWait(ctx, filePath, original, proposed, description) {
+    // Normalize path: LLM may pass absolute-looking path without leading /
+    const normalizedPath = resolveSafe(ctx.cwd, filePath);
     const uuid = (0, crypto_1.randomUUID)();
-    const requestsDir = (0, path_1.join)(ctx.cwd, ".pi", "review-requests");
     const resultsDir = (0, path_1.join)(ctx.cwd, ".pi", "review-results");
-    (0, fs_1.mkdirSync)(requestsDir, { recursive: true });
     (0, fs_1.mkdirSync)(resultsDir, { recursive: true });
-    const reviewRequest = {
-        id: uuid,
-        title: description,
-        files: [{ path: filePath, original, proposed, description }],
-    };
-    (0, fs_1.writeFileSync)((0, path_1.join)(requestsDir, `${uuid}.json`), JSON.stringify(reviewRequest, null, 2), "utf-8");
-    ctx.ui.notify(`📝 Review: ${filePath} — check VS Code diff`, "info");
     sessionReviewIds.add(uuid);
     // Check if approve-all was already chosen
     if (sessionApproveAll.size > 0) {
         writeSyncResult(resultsDir, uuid, "approved", proposed);
         return { status: "approved", final: proposed };
     }
-    // Phase 1: give VS Code a head start (2s, poll every 100ms) so TUI doesn't
-    // pop up when the user is already reviewing in editor.
-    // 2 seconds with 100ms intervals = 20 checks — catches VS Code response quickly.
-    const resultPath = (0, path_1.join)(resultsDir, `${uuid}.json`);
-    const deadline = Date.now() + 10 * 60 * 1000;
-    const early = await pollResultFile(resultPath, Date.now() + 2000, 100);
-    if (early !== "timeout") {
-        if (early === "file-rejected")
-            return { status: "rejected" };
-        return { status: "approved", final: proposed };
-    }
-    // Sync check: VS Code may have written the result file between poll intervals.
-    if ((0, fs_1.existsSync)(resultPath)) {
-        const result = JSON.parse((0, fs_1.readFileSync)(resultPath, "utf-8"));
-        if (result.status === "rejected" || result.files?.[0]?.status === "rejected") {
-            return { status: "rejected" };
-        }
+    // Detect whether VS Code is open with this project.
+    // If not: bypass review entirely — direct write, no TUI, no polling.
+    // Warning is shown once at session_start, not here on every tool call.
+    if (!isVscodeReady(ctx.cwd)) {
         return { status: "approved", final: proposed };
     }
-    // Phase 2: show TUI and keep polling VS Code in parallel (every 500ms)
-    const tuiPromise = showTuiSelector(ctx, filePath);
+    // VS Code is open — create review request, poll for results, show TUI
+    const requestsDir = (0, path_1.join)(ctx.cwd, ".pi", "review-requests");
+    (0, fs_1.mkdirSync)(requestsDir, { recursive: true });
+    const reviewRequest = {
+        id: uuid,
+        title: description,
+        files: [{ path: normalizedPath, original, proposed, description }],
+    };
+    (0, fs_1.writeFileSync)((0, path_1.join)(requestsDir, `${uuid}.json`), JSON.stringify(reviewRequest, null, 2), "utf-8");
+    ctx.ui.notify(`📝 Review: ${filePath} — check VS Code diff`, "info");
+    // TUI selector races with VS Code result polling
+    const resultPath = (0, path_1.join)(resultsDir, `${uuid}.json`);
+    const deadline = Date.now() + 10 * 60 * 1000;
+    const tuiController = new AbortController();
+    const tuiPromise = showTuiSelector(ctx, filePath, { signal: tuiController.signal });
     const pollPromise = pollResultFile(resultPath, deadline, 500);
     const outcome = await Promise.race([tuiPromise, pollPromise]);
+    // If poll resolved first (VS Code responded), dismiss the TUI selector
+    if (outcome.action === "file-approved" || outcome.action === "file-rejected") {
+        tuiController.abort();
+        await tuiPromise.catch(() => { });
+    }
     // ── Process outcome (return result, never throw) ──
-    if (outcome === "abort") {
+    if (outcome.action === "abort") {
         writeSyncResult(resultsDir, uuid, "rejected");
         ctx.abort();
         return { status: "rejected" };
     }
-    if (outcome === "file-rejected" || outcome === "rejected") {
+    if (outcome.action === "rethink") {
+        writeSyncResult(resultsDir, uuid, "rejected");
+        return { status: "rethink", prompt: outcome.prompt };
+    }
+    if (outcome.action === "file-rejected") {
+        return { status: "rejected" };
+    }
+    if (outcome.action === "rejected") {
+        writeSyncResult(resultsDir, uuid, "rejected");
         return { status: "rejected" };
     }
-    if (outcome === "file-approved" || outcome === "approved") {
+    if (outcome.action === "file-approved") {
+        return { status: "approved", final: proposed };
+    }
+    if (outcome.action === "approved") {
+        writeSyncResult(resultsDir, uuid, "approved", proposed);
         return { status: "approved", final: proposed };
     }
-    if (outcome === "approve-all") {
+    if (outcome.action === "approve-all") {
         for (const rid of sessionReviewIds) {
             sessionApproveAll.add(rid);
         }
@@ -84,16 +112,16 @@ async function pollResultFile(resultPath, deadline, interval = 500) {
             if ((0, fs_1.existsSync)(resultPath)) {
                 const raw = (0, fs_1.readFileSync)(resultPath, "utf-8");
                 if (!raw.trim()) {
-                    // File exists but is empty — still being written
-                    await sleep(200);
+                    // File exists but is empty — still being written, retry next cycle
+                    await sleep(interval);
                     continue;
                 }
                 const result = JSON.parse(raw);
                 const fileResult = result.files?.[0];
                 if (result.status === "rejected" || fileResult?.status === "rejected") {
-                    return "file-rejected";
+                    return { action: "file-rejected" };
                 }
-                return "file-approved";
+                return { action: "file-approved" };
             }
         }
         catch {
@@ -101,26 +129,33 @@ async function pollResultFile(resultPath, deadline, interval = 500) {
         }
         await sleep(interval);
     }
-    return "timeout";
+    return { action: "timeout" };
 }
-async function showTuiSelector(ctx, filePath) {
+async function showTuiSelector(ctx, filePath, opts) {
     const choice = await ctx.ui.select(`📝 Review: ${filePath}`, [
         "✅ Approve",
         "❌ Reject",
+        "💭 Rethink",
         "⭐ Approve All for this session",
         "🚪 Abort",
-    ]);
+    ], opts);
     if (!choice)
-        return "timeout";
+        return { action: "timeout" };
     if (choice.startsWith("🚪"))
-        return "abort";
+        return { action: "abort" };
     if (choice.startsWith("⭐"))
-        return "approve-all";
+        return { action: "approve-all" };
+    if (choice.startsWith("💭")) {
+        const prompt = await ctx.ui.input("🔄 Rethink — what should the agent reconsider?", "Describe what needs to change...", opts);
+        if (!prompt || !prompt.trim())
+            return { action: "rejected" };
+        return { action: "rethink", prompt: prompt.trim() };
+    }
     if (choice.startsWith("✅"))
-        return "approved";
+        return { action: "approved" };
     if (choice.startsWith("❌"))
-        return "rejected";
-    return "timeout";
+        return { action: "rejected" };
+    return { action: "timeout" };
 }
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
@@ -141,6 +176,22 @@ function applyEdits(content, edits) {
     }
     return result;
 }
+// ─── Path normalization ──────────────────────────────────────────────
+/**
+ * Safe path resolution. If the LLM passes an absolute-looking path
+ * without a leading slash (e.g. "home/user/project/file.ts"), resolve()
+ * treats it as relative and doubles the cwd. Detect and fix this.
+ */
+function resolveSafe(cwd, filePath) {
+    // Strip leading/trailing slashes from cwd for comparison
+    const cwdClean = cwd.replace(/\/+$/, "").replace(/^\//, "");
+    // If filePath starts with cwdClean/ (LLM forgot the leading /),
+    // strip it so resolve doesn't double.
+    if (filePath.startsWith(cwdClean + "/")) {
+        filePath = filePath.substring(cwdClean.length + 1);
+    }
+    return (0, path_1.resolve)(cwd, filePath);
+}
 // ─── Override `write` ────────────────────────────────────────────────
 function registerWriteOverride(pi) {
     pi.registerTool({
@@ -161,7 +212,8 @@ function registerWriteOverride(pi) {
         }),
         executionMode: "sequential",
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-            const absolutePath = (0, path_1.resolve)(ctx.cwd, params.path);
+            projectCwd = ctx.cwd;
+            const absolutePath = resolveSafe(ctx.cwd, params.path);
             let original = "";
             let fileExists = false;
             try {
@@ -194,6 +246,12 @@ function registerWriteOverride(pi) {
                             details: { path: params.path, status: "approved", bytes: result.final.length },
                         };
                     });
+                case "rethink":
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `🔄 ${params.path} — rethinking requested: "${result.prompt}"\nPlease reconsider your changes based on this feedback.` }],
+                        details: { path: params.path, status: "rethink", prompt: result.prompt },
+                    };
                 case "rejected":
                     return {
                         isError: true,
@@ -229,7 +287,8 @@ function registerEditOverride(pi) {
         }),
         executionMode: "sequential",
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-            const absolutePath = (0, path_1.resolve)(ctx.cwd, params.path);
+            projectCwd = ctx.cwd;
+            const absolutePath = resolveSafe(ctx.cwd, params.path);
             let original;
             try {
                 original = (0, fs_1.readFileSync)(absolutePath, "utf-8");
@@ -273,6 +332,12 @@ function registerEditOverride(pi) {
                             details: { path: params.path, status: "approved", bytes: result.final.length },
                         };
                     });
+                case "rethink":
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `🔄 ${params.path} — rethinking requested: "${result.prompt}"\nPlease reconsider your changes based on this feedback.` }],
+                        details: { path: params.path, status: "rethink", prompt: result.prompt },
+                    };
                 case "rejected":
                     return {
                         isError: true,
@@ -287,16 +352,47 @@ function registerEditOverride(pi) {
 }
 // ─── Extension entry point ───────────────────────────────────────────
 function default_1(pi) {
-    // Reset review ID tracking on new session
+    // Reset review ID tracking on new session.
+    // Re-check VS Code availability — user may have opened/closed VS Code since last session.
     pi.on("session_start", () => {
         sessionReviewIds.clear();
+        sessionApproveAll.clear();
+        vscodeNotOpenWarned = false;
+        const cwd = process.cwd();
+        if (!isVscodeReady(cwd)) {
+            console.warn("⚠️  VS Code not detected — working without diff review. " +
+                "All file changes will be applied directly. " +
+                "Open this project in VS Code with Serhioromano.vscode-pi-sr extension " +
+                "installed to enable visual review.");
+            vscodeNotOpenWarned = true;
+        }
     });
-    // Reset Approve All on message boundaries
-    const clearApproveAll = () => {
+    // Approve All persists across turns within one prompt.
+    // before_agent_start fires once per user prompt — clears here.
+    pi.on("before_agent_start", () => {
         sessionApproveAll.clear();
-    };
-    pi.on("message_start", clearApproveAll);
-    pi.on("message_end", clearApproveAll);
+    });
+    pi.on("message_end", () => {
+        cleanupPiDir();
+    });
     registerWriteOverride(pi);
     registerEditOverride(pi);
 }
+function cleanupPiDir() {
+    if (!projectCwd)
+        return;
+    // Clean up all .pi subdirectories: tmp files, pending requests, and results.
+    // After message_end, every review is resolved — no files are needed anymore.
+    for (const sub of ["tmp", "review-requests", "review-results"]) {
+        const dir = (0, path_1.join)(projectCwd, ".pi", sub);
+        try {
+            const files = (0, fs_1.readdirSync)(dir);
+            for (const f of files) {
+                (0, fs_1.rmSync)((0, path_1.join)(dir, f), { recursive: true, force: true });
+            }
+        }
+        catch {
+            // Directory doesn't exist or is empty — ok
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vscode-sr",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "description": "Code diff assistant for VS Code.",
   "license": "MIT",
   "author": "Serhioromano",

package/src/index.ts

@@ -10,9 +10,23 @@ import { dirname, join, resolve } from "path";
 const sessionReviewIds = new Set<string>();
 const sessionApproveAll = new Set<string>(); // review IDs auto-approved
 let projectCwd: string | null = null;
+let vscodeNotOpenWarned = false;
 
 
-// ─── Helper: create review request and wait for result ───────────────
+// ─── Helper: check if VS Code is watching this project ─────────────
+
+function isVscodeReady(cwd: string): boolean {
+    try {
+        const readyFile = join(cwd, '.pi', '.vscode-ready');
+        if (!existsSync(readyFile)) return false;
+        const ts = parseInt(readFileSync(readyFile, 'utf-8').trim(), 10);
+        if (isNaN(ts)) return false;
+        // Timestamp must be within last 30 seconds (heartbeat = 15s interval)
+        return Date.now() - ts < 30_000;
+    } catch {
+        return false;
+    }
+}
 
 type ReviewOutcome =
     | { status: "approved"; final: string }
@@ -30,20 +44,9 @@ async function createReviewAndWait(
     // Normalize path: LLM may pass absolute-looking path without leading /
     const normalizedPath = resolveSafe(ctx.cwd, filePath);
     const uuid = randomUUID();
-    const requestsDir = join(ctx.cwd, ".pi", "review-requests");
     const resultsDir = join(ctx.cwd, ".pi", "review-results");
-    mkdirSync(requestsDir, { recursive: true });
     mkdirSync(resultsDir, { recursive: true });
 
-    const reviewRequest = {
-        id: uuid,
-        title: description,
-        files: [{ path: normalizedPath, original, proposed, description }],
-    };
-
-    writeFileSync(join(requestsDir, `${uuid}.json`), JSON.stringify(reviewRequest, null, 2), "utf-8");
-    ctx.ui.notify(`📝 Review: ${filePath} — check VS Code diff`, "info");
-
     sessionReviewIds.add(uuid);
 
     // Check if approve-all was already chosen
@@ -52,8 +55,26 @@ async function createReviewAndWait(
         return { status: "approved", final: proposed };
     }
 
-    // Show TUI immediately and poll VS Code in parallel (every 500ms).
-    // AbortController dismisses the TUI if VS Code responds first.
+    // Detect whether VS Code is open with this project.
+    // If not: bypass review entirely — direct write, no TUI, no polling.
+    // Warning is shown once at session_start, not here on every tool call.
+    if (!isVscodeReady(ctx.cwd)) {
+        return { status: "approved", final: proposed };
+    }
+
+    // VS Code is open — create review request, poll for results, show TUI
+    const requestsDir = join(ctx.cwd, ".pi", "review-requests");
+    mkdirSync(requestsDir, { recursive: true });
+
+    const reviewRequest = {
+        id: uuid,
+        title: description,
+        files: [{ path: normalizedPath, original, proposed, description }],
+    };
+    writeFileSync(join(requestsDir, `${uuid}.json`), JSON.stringify(reviewRequest, null, 2), "utf-8");
+    ctx.ui.notify(`📝 Review: ${filePath} — check VS Code diff`, "info");
+
+    // TUI selector races with VS Code result polling
     const resultPath = join(resultsDir, `${uuid}.json`);
     const deadline = Date.now() + 10 * 60 * 1000;
     const tuiController = new AbortController();
@@ -62,11 +83,9 @@ async function createReviewAndWait(
 
     const outcome = await Promise.race([tuiPromise, pollPromise]);
 
-    // If poll resolved first (VS Code responded), dismiss the TUI selector.
-    // Without this, the TUI stays on screen even after the review is done.
+    // If poll resolved first (VS Code responded), dismiss the TUI selector
     if (outcome.action === "file-approved" || outcome.action === "file-rejected") {
         tuiController.abort();
-        // Wait for TUI to close gracefully (aborted select resolves quickly)
         await tuiPromise.catch(() => { });
     }
 
@@ -400,18 +419,32 @@ function registerEditOverride(pi: ExtensionAPI) {
 // ─── Extension entry point ───────────────────────────────────────────
 
 export default function (pi: ExtensionAPI) {
-    // Reset review ID tracking on new session
+    // Reset review ID tracking on new session.
+    // Re-check VS Code availability — user may have opened/closed VS Code since last session.
     pi.on("session_start", () => {
         sessionReviewIds.clear();
+        sessionApproveAll.clear();
+        vscodeNotOpenWarned = false;
+
+        const cwd = process.cwd();
+        if (!isVscodeReady(cwd)) {
+            console.warn(
+                "⚠️  VS Code not detected — working without diff review. " +
+                "All file changes will be applied directly. " +
+                "Open this project in VS Code with Serhioromano.vscode-pi-sr extension " +
+                "installed to enable visual review."
+            );
+            vscodeNotOpenWarned = true;
+        }
     });
 
-    // Reset Approve All on message boundaries
-    const clearApproveAll = () => {
+    // Approve All persists across turns within one prompt.
+    // before_agent_start fires once per user prompt — clears here.
+    pi.on("before_agent_start", () => {
         sessionApproveAll.clear();
-    };
-    pi.on("message_start", clearApproveAll);
+    });
+
     pi.on("message_end", () => {
-        clearApproveAll();
         cleanupPiDir();
     });