pi-vscode-sr 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Serhioromano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,102 @@
+# Pi VS Code
+
+Pi extension that integrates with VS Code's diff editor for reviewing code changes proposed by the Pi agent.
+
+## Architecture
+
+The project has **two components** in one repository:
+
+### 1. Pi Extension (root)
+
+- **`src/index.ts`** — Extension loaded by Pi agent (`@earendil-works/pi-tui`)
+- Published as npm package `pi-vscode-sr`
+- **Overrides `write` tool** — instead of writing directly, creates a review request in `.pi/review-requests/{uuid}.json`
+- Polls `.pi/review-results/{uuid}.json` for user's decision, then writes if approved
+
+### 2. VS Code Extension (`vscode-ext/`) — **Pi Companion**
+
+- **`vscode-ext/src/extension.ts`** — VS Code extension (package name: `vscode-pi-sr`) with approve/reject buttons in diff editor
+- Watches `.pi/review-requests/` for new review requests from Pi
+- Opens diff editors with **✓ Approve / ✗ Reject** buttons in the editor title bar
+- Writes results to `.pi/review-results/` for Pi to read
+
+## Protocol
+
+### Review Request (Pi → VS Code Extension)
+
+File: `.pi/review-requests/{uuid}.json`
+
+```json
+{
+  "id": "550e8400-e29b-41d4-a716-446655440000",
+  "title": "Add input validation to login",
+  "files": [
+    {
+      "path": "src/auth/login.ts",
+      "original": "export function login(email: string, password: string) {\n  return api.post('/login', { email, password });\n}",
+      "proposed": "export function login(email: string, password: string) {\n  if (!email.includes('@')) throw new Error('Invalid email');\n  if (password.length < 8) throw new Error('Password too short');\n  return api.post('/login', { email, password });\n}",
+      "description": "Added email and password validation",
+      "language": "typescript"
+    }
+  ]
+}
+```
+
+### Review Result (VS Code Extension → Pi)
+
+File: `.pi/review-results/{uuid}.json`
+
+```json
+{
+  "id": "550e8400-e29b-41d4-a716-446655440000",
+  "status": "approved",
+  "files": [
+    {
+      "path": "src/auth/login.ts",
+      "status": "approved",
+      "final": "export function login(email: string, password: string) {\n  if (!email.includes('@')) throw new Error('Invalid email');\n  if (password.length < 8) throw new Error('Password too short');\n  return api.post('/login', { email, password });\n}"
+    }
+  ]
+}
+```
+
+## Quick Start
+
+### VS Code Extension Dev
+1. Open this project in VS Code
+2. Press **F5** (or run "Run VS Code Extension" in Run & Debug)
+3. A new VS Code window opens with the extension loaded
+4. In that window, create a test request:
+   ```bash
+   mkdir -p .pi/review-requests
+   cp /home/sergey/www/pi-vscode/.pi/review-requests/test.json .pi/review-requests/
+   ```
+5. The extension will open a diff editor with **✓ Approve / ✗ Reject** buttons
+6. Edit the right side, then click Approve or Reject
+
+### Pi Extension (npm)
+Run Pi with the extension:
+```bash
+pi -e /path/to/pi-vscode/src/index.ts
+```
+When Pi calls `write`, the extension creates a review request instead of writing directly.
+
+## Development
+
+```bash
+# Compile Pi extension (root)
+npm run compile
+
+# Compile VS Code extension
+cd vscode-ext && npm run compile
+
+# Watch mode (VS Code extension)
+cd vscode-ext && npm run watch
+
+# Package VS Code extension as .vsix
+cd vscode-ext && npm run package
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function (pi: ExtensionAPI): void;

package/dist/index.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const pi_coding_agent_1 = require("@earendil-works/pi-coding-agent");
+const typebox_1 = require("typebox");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = require("path");
+// ─── Session state ───────────────────────────────────────────────────
+const sessionReviewIds = new Set();
+const sessionApproveAll = new Set(); // review IDs auto-approved
+async function createReviewAndWait(ctx, filePath, original, proposed, description) {
+    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" };
+        }
+        return { status: "approved", final: proposed };
+    }
+    // Phase 2: show TUI and keep polling VS Code in parallel (every 500ms)
+    const tuiPromise = showTuiSelector(ctx, filePath);
+    const pollPromise = pollResultFile(resultPath, deadline, 500);
+    const outcome = await Promise.race([tuiPromise, pollPromise]);
+    // ── Process outcome (return result, never throw) ──
+    if (outcome === "abort") {
+        writeSyncResult(resultsDir, uuid, "rejected");
+        ctx.abort();
+        return { status: "rejected" };
+    }
+    if (outcome === "file-rejected" || outcome === "rejected") {
+        return { status: "rejected" };
+    }
+    if (outcome === "file-approved" || outcome === "approved") {
+        return { status: "approved", final: proposed };
+    }
+    if (outcome === "approve-all") {
+        for (const rid of sessionReviewIds) {
+            sessionApproveAll.add(rid);
+        }
+        writeSyncResult(resultsDir, uuid, "approved", proposed);
+        return { status: "approved", final: proposed };
+    }
+    return { status: "timeout" };
+}
+function writeSyncResult(resultsDir, uuid, status, content) {
+    (0, fs_1.writeFileSync)((0, path_1.join)(resultsDir, `${uuid}.json`), JSON.stringify({
+        id: uuid,
+        files: [{ path: "", status, final: content ?? "" }],
+    }, null, 2), "utf-8");
+}
+async function pollResultFile(resultPath, deadline, interval = 500) {
+    while (Date.now() < deadline) {
+        try {
+            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);
+                    continue;
+                }
+                const result = JSON.parse(raw);
+                const fileResult = result.files?.[0];
+                if (result.status === "rejected" || fileResult?.status === "rejected") {
+                    return "file-rejected";
+                }
+                return "file-approved";
+            }
+        }
+        catch {
+            // File may be partially written or malformed — retry
+        }
+        await sleep(interval);
+    }
+    return "timeout";
+}
+async function showTuiSelector(ctx, filePath) {
+    const choice = await ctx.ui.select(`📝 Review: ${filePath}`, [
+        "✅ Approve",
+        "❌ Reject",
+        "⭐ Approve All for this session",
+        "🚪 Abort",
+    ]);
+    if (!choice)
+        return "timeout";
+    if (choice.startsWith("🚪"))
+        return "abort";
+    if (choice.startsWith("⭐"))
+        return "approve-all";
+    if (choice.startsWith("✅"))
+        return "approved";
+    if (choice.startsWith("❌"))
+        return "rejected";
+    return "timeout";
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+// ─── Apply edits in-memory (mirrors built-in edit logic) ─────────────
+function applyEdits(content, edits) {
+    let result = content;
+    for (const edit of edits) {
+        const idx = result.indexOf(edit.oldText);
+        if (idx === -1) {
+            throw new Error(`oldText not found in file`);
+        }
+        const nextIdx = result.indexOf(edit.oldText, idx + 1);
+        if (nextIdx !== -1) {
+            throw new Error(`oldText is not unique in file`);
+        }
+        result = result.replace(edit.oldText, edit.newText);
+    }
+    return result;
+}
+// ─── Override `write` ────────────────────────────────────────────────
+function registerWriteOverride(pi) {
+    pi.registerTool({
+        name: "write",
+        label: "write (with review)",
+        description: "Write content to a file. Instead of writing directly, creates a review request so the user " +
+            "can approve or reject the change in VS Code or directly in the terminal. Returns only after " +
+            "the user makes a decision.",
+        promptSnippet: "Create or overwrite files with user review",
+        promptGuidelines: [
+            "Use write for any file creation or complete rewrite — user review is required.",
+            "The tool blocks until the user approves or rejects.",
+            "If content is identical to existing file, no review is created.",
+        ],
+        parameters: typebox_1.Type.Object({
+            path: typebox_1.Type.String({ description: "Path to the file to write (relative or absolute)" }),
+            content: typebox_1.Type.String({ description: "Content to write to the file" }),
+        }),
+        executionMode: "sequential",
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            const absolutePath = (0, path_1.resolve)(ctx.cwd, params.path);
+            let original = "";
+            let fileExists = false;
+            try {
+                original = (0, fs_1.readFileSync)(absolutePath, "utf-8");
+                fileExists = true;
+            }
+            catch {
+                // new file
+            }
+            if (fileExists && original === params.content) {
+                return {
+                    content: [{ type: "text", text: `No changes — ${params.path} content is identical.` }],
+                    details: { path: params.path, status: "no-change" },
+                };
+            }
+            const description = fileExists ? `Update: ${params.path}` : `Create: ${params.path}`;
+            const result = await createReviewAndWait(ctx, params.path, original, params.content, description);
+            switch (result.status) {
+                case "timeout":
+                    return {
+                        content: [{ type: "text", text: `⏰ Review timed out for ${params.path} (10m)` }],
+                        details: { path: params.path, status: "timeout" },
+                    };
+                case "approved":
+                    return (0, pi_coding_agent_1.withFileMutationQueue)(absolutePath, async () => {
+                        (0, fs_1.mkdirSync)((0, path_1.dirname)(absolutePath), { recursive: true });
+                        (0, fs_1.writeFileSync)(absolutePath, result.final, "utf-8");
+                        return {
+                            content: [{ type: "text", text: `✅ ${params.path} — approved (${result.final.length} bytes)` }],
+                            details: { path: params.path, status: "approved", bytes: result.final.length },
+                        };
+                    });
+                case "rejected":
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `❌ ${params.path} — change REJECTED by user. File was NOT modified.` }],
+                        details: { path: params.path, status: "rejected" },
+                    };
+                default:
+                    throw new Error(`Unexpected review status: ${result.status}`);
+            }
+        },
+    });
+}
+// ─── Override `edit` ─────────────────────────────────────────────────
+function registerEditOverride(pi) {
+    pi.registerTool({
+        name: "edit",
+        label: "edit (with review)",
+        description: "Edit a file by replacing exact text passages. Instead of editing directly, creates a review " +
+            "request so the user can approve or reject in VS Code or directly in the terminal.",
+        promptSnippet: "Make targeted edits to existing files with user review",
+        promptGuidelines: [
+            "Use edit for targeted changes to existing files — user review is required.",
+            "The tool blocks until the user approves or rejects.",
+        ],
+        parameters: typebox_1.Type.Object({
+            path: typebox_1.Type.String({ description: "Path to the file to edit (relative or absolute)" }),
+            edits: typebox_1.Type.Array(typebox_1.Type.Object({
+                oldText: typebox_1.Type.String({ description: "Exact unique text to replace" }),
+                newText: typebox_1.Type.String({ description: "Replacement text" }),
+            }), {
+                description: "Targeted replacements. Each oldText must be unique and non-overlapping.",
+            }),
+        }),
+        executionMode: "sequential",
+        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+            const absolutePath = (0, path_1.resolve)(ctx.cwd, params.path);
+            let original;
+            try {
+                original = (0, fs_1.readFileSync)(absolutePath, "utf-8");
+            }
+            catch {
+                return {
+                    content: [{ type: "text", text: `❌ File not found: ${params.path}` }],
+                    details: { path: params.path, status: "error", error: "not found" },
+                };
+            }
+            // Apply edits in-memory to get proposed content
+            let proposed;
+            try {
+                proposed = applyEdits(original, params.edits);
+            }
+            catch (e) {
+                return {
+                    content: [{ type: "text", text: `❌ Edit failed: ${e.message} in ${params.path}` }],
+                    details: { path: params.path, status: "error", error: e.message },
+                };
+            }
+            if (original === proposed) {
+                return {
+                    content: [{ type: "text", text: `No changes — ${params.path} content is identical after edits.` }],
+                    details: { path: params.path, status: "no-change" },
+                };
+            }
+            const result = await createReviewAndWait(ctx, params.path, original, proposed, `Edit: ${params.path}`);
+            switch (result.status) {
+                case "timeout":
+                    return {
+                        content: [{ type: "text", text: `⏰ Review timed out for ${params.path} (10m)` }],
+                        details: { path: params.path, status: "timeout" },
+                    };
+                case "approved":
+                    return (0, pi_coding_agent_1.withFileMutationQueue)(absolutePath, async () => {
+                        (0, fs_1.mkdirSync)((0, path_1.dirname)(absolutePath), { recursive: true });
+                        (0, fs_1.writeFileSync)(absolutePath, result.final, "utf-8");
+                        return {
+                            content: [{ type: "text", text: `✅ ${params.path} — edit approved (${result.final.length} bytes)` }],
+                            details: { path: params.path, status: "approved", bytes: result.final.length },
+                        };
+                    });
+                case "rejected":
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `❌ ${params.path} — edit REJECTED by user. File was NOT modified.` }],
+                        details: { path: params.path, status: "rejected" },
+                    };
+                default:
+                    throw new Error(`Unexpected review status: ${result.status}`);
+            }
+        },
+    });
+}
+// ─── Extension entry point ───────────────────────────────────────────
+function default_1(pi) {
+    // Reset review ID tracking on new session
+    pi.on("session_start", () => {
+        sessionReviewIds.clear();
+    });
+    // Reset Approve All on message boundaries
+    const clearApproveAll = () => {
+        sessionApproveAll.clear();
+    };
+    pi.on("message_start", clearApproveAll);
+    pi.on("message_end", clearApproveAll);
+    registerWriteOverride(pi);
+    registerEditOverride(pi);
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "pi-vscode-sr",
+  "version": "1.1.0",
+  "description": "Code diff assistant for VS Code.",
+  "license": "MIT",
+  "author": "Serhioromano",
+  "repository": "github:Serhioromano/pi-vscode",
+  "scripts": {
+    "postinstall": "mkdir -p ~/.pi"
+  },
+  "keywords": [
+    "pi",
+    "ai-agent",
+    "pi-extension",
+    "pi-package",
+    "security",
+    "protection",
+    "vs-code-extension"
+  ],
+  "dependencies": {
+    "@earendil-works/pi-tui": "^0.74.0",
+    "yaml": "^2.7.0"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/Serhioromano/pi-vscode/refs/heads/master/images/pi-vscode.png"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@types/node": "^25.7.0",
+    "typescript": "^6.0.3"
+  }
+}