pi-vscode-sr 1.1.0

package/vscode-ext/package-lock.json

@@ -0,0 +1,59 @@
+{
+  "name": "pi-vscode-review",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "pi-vscode-review",
+      "version": "0.1.0",
+      "license": "MIT",
+      "devDependencies": {
+        "@types/node": "^25.9.2",
+        "@types/vscode": "^1.82.0",
+        "typescript": "^5.3.0"
+      },
+      "engines": {
+        "vscode": "^1.82.0"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "25.9.2",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.9.2.tgz",
+      "integrity": "sha512-G05zqtJhcDLb8uslf5EjCxXg9G1KQxiV8OS0R26IC//Eoyitzqe8z37I7cqvnZlrlSfgocQRfSn/AHBZJJFyGw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": ">=7.24.0 <7.24.7"
+      }
+    },
+    "node_modules/@types/vscode": {
+      "version": "1.120.0",
+      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.120.0.tgz",
+      "integrity": "sha512-feaT4Rst+FkTch5zz/ZbNCxoIvo55YU80Be2kiL7OJcod4+CUYf2lUBPdIJzozNnSEMq1VRTGrWEcCGFB3fBmA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.24.6",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.24.6.tgz",
+      "integrity": "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}

package/vscode-ext/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "vscode-pi-sr",
+  "displayName": "Pi Companion",
+  "description": "Review and approve file changes proposed by Pi agent",
+  "version": "0.1.0",
+  "publisher": "Serhioromano",
+  "icon": "icon.png",
+  "license": "MIT",
+  "repository": "github:Serhioromano/pi-vscode",
+  "engines": {
+    "vscode": "^1.82.0"
+  },
+  "categories": [
+    "Other"
+  ],
+  "activationEvents": [
+    "onStartupFinished"
+  ],
+  "main": "./dist/extension.js",
+  "contributes": {
+    "commands": [
+      {
+        "command": "pi-sr.approveCurrent",
+        "title": "Pi SR: Accept",
+        "icon": "$(check)"
+      },
+      {
+        "command": "pi-sr.rejectCurrent",
+        "title": "Pi SR: Reject",
+        "icon": "$(close)"
+      }
+    ],
+    "menus": {
+      "editor/title": [
+        {
+          "command": "pi-sr.approveCurrent",
+          "when": "piSr.isActive",
+          "group": "navigation@1"
+        },
+        {
+          "command": "pi-sr.rejectCurrent",
+          "when": "piSr.isActive",
+          "group": "navigation@2"
+        }
+      ]
+    }
+  },
+  "scripts": {
+    "compile": "tsc -p tsconfig.json",
+    "watch": "tsc -watch -p tsconfig.json",
+    "package": "npx @vscode/vsce package"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.2",
+    "@types/vscode": "^1.82.0",
+    "@vscode/vsce": "^3.2.0",
+    "typescript": "^5.3.0"
+  }
+}

package/vscode-ext/src/extension.ts

@@ -0,0 +1,250 @@
+import * as vscode from 'vscode';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ReviewRequest, ReviewResult, ReviewResultFile, DiffSession } from './types';
+
+// Global state
+let workspaceRoot: string;
+let requestsDir: string;
+let resultsDir: string;
+let watcher: fs.FSWatcher | null = null;
+
+// key = tmpFsPath (URI.fsPath of the active editor)
+const sessions = new Map<string, DiffSession>();
+// key = reviewId, value = set of file paths in this review
+const reviewFiles = new Map<string, Set<string>>();
+
+export function activate(context: vscode.ExtensionContext) {
+  const root = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+  if (!root) {
+    vscode.window.showWarningMessage('Pi Companion: open a workspace first');
+    return;
+  }
+  workspaceRoot = root;
+  requestsDir = path.join(workspaceRoot, '.pi', 'review-requests');
+  resultsDir = path.join(workspaceRoot, '.pi', 'review-results');
+
+  // Create directories
+  fs.mkdirSync(requestsDir, { recursive: true });
+  fs.mkdirSync(resultsDir, { recursive: true });
+
+  // Watch for new review requests
+  watcher = fs.watch(requestsDir, (_, filename) => {
+    if (!filename?.endsWith('.json')) return;
+    const fp = path.join(requestsDir, filename);
+    if (fs.existsSync(fp)) handleRequest(fp);
+  });
+
+  // Recover incomplete reviews
+  for (const f of fs.readdirSync(requestsDir)) {
+    if (f.endsWith('.json')) handleRequest(path.join(requestsDir, f));
+  }
+
+  // Commands for editor/title buttons
+  context.subscriptions.push(
+    vscode.commands.registerCommand('pi-sr.approveCurrent', () => approveCurrent()),
+    vscode.commands.registerCommand('pi-sr.rejectCurrent', () => rejectCurrent()),
+  );
+}
+
+export function deactivate() {
+  watcher?.close();
+}
+
+// ─── Handle new review request ────────────────────────────────────────
+
+function handleRequest(requestPath: string) {
+  let req: ReviewRequest;
+  try {
+    req = JSON.parse(fs.readFileSync(requestPath, 'utf-8'));
+  } catch {
+    vscode.window.showErrorMessage(`Pi Review: malformed JSON in ${requestPath}`);
+    return;
+  }
+
+  if (!req.id || !req.files?.length) return;
+
+  // Skip if this review is already being processed
+  if (reviewFiles.has(req.id)) return;
+
+  const fileSet = new Set<string>();
+  reviewFiles.set(req.id, fileSet);
+
+  // For each file: create tmp, open diff
+  req.files.forEach(file => {
+    fileSet.add(file.path);
+
+    const tmpDir = path.join(workspaceRoot, '.pi', 'tmp', req.id);
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    const tmpPath = path.join(tmpDir, path.basename(file.path));
+    fs.writeFileSync(tmpPath, file.proposed, 'utf-8');
+
+    // Create original file if it doesn't exist
+    const origPath = path.join(workspaceRoot, file.path);
+    if (!fs.existsSync(origPath)) {
+      fs.mkdirSync(path.dirname(origPath), { recursive: true });
+      fs.writeFileSync(origPath, file.original || '', 'utf-8');
+    }
+
+    const session: DiffSession = {
+      reviewId: req.id,
+      filePath: file.path,
+      originalFsPath: origPath,
+      tmpFsPath: tmpPath,
+      status: 'pending',
+    };
+    sessions.set(tmpPath, session);
+
+    // Open diff
+    vscode.commands.executeCommand(
+      'vscode.diff',
+      vscode.Uri.file(origPath),
+      vscode.Uri.file(tmpPath),
+      `Pi: ${file.path}`
+    ).then(() => {
+      vscode.commands.executeCommand('setContext', 'piSr.isActive', true);
+    });
+  });
+}
+
+// ─── Approve / Reject ─────────────────────────────────────────────────
+
+function getCurrentSession(): DiffSession | undefined {
+  // Tier 1: active editor (fast path — works when tmp side has focus)
+  const active = vscode.window.activeTextEditor;
+  if (active) {
+    const s = sessions.get(active.document.uri.fsPath);
+    if (s) return s;
+  }
+  // Tier 2: all visible editors (catches original side of diff)
+  for (const editor of vscode.window.visibleTextEditors) {
+    const s = sessions.get(editor.document.uri.fsPath);
+    if (s) return s;
+  }
+  // Tier 3: if exactly one pending session exists, return it
+  // (handles edge case where diff editor sides aren't in visibleTextEditors)
+  const pending: DiffSession[] = [];
+  for (const s of sessions.values()) {
+    if (s.status === 'pending') pending.push(s);
+  }
+  if (pending.length === 1) return pending[0];
+  return undefined;
+}
+
+async function approveCurrent() {
+  const s = getCurrentSession();
+  if (!s) {
+    vscode.window.showErrorMessage('Pi Companion: no review session found. Is the diff editor open?');
+    return;
+  }
+
+  // Read edited content from tmp file
+  const edited = fs.readFileSync(s.tmpFsPath, 'utf-8');
+
+  // Write to original
+  fs.writeFileSync(s.originalFsPath, edited, 'utf-8');
+
+  // Remove tmp
+  try { fs.unlinkSync(s.tmpFsPath); } catch {}
+
+  s.status = 'approved';
+
+  // Close diff tab
+  await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
+
+  checkReviewComplete(s.reviewId);
+}
+
+async function rejectCurrent() {
+  const s = getCurrentSession();
+  if (!s) {
+    vscode.window.showErrorMessage('Pi Companion: no review session found. Is the diff editor open?');
+    return;
+  }
+
+  // Remove tmp
+  try { fs.unlinkSync(s.tmpFsPath); } catch {}
+
+  s.status = 'rejected';
+
+  // Close diff tab
+  await vscode.commands.executeCommand('workbench.action.closeActiveEditor');
+
+  checkReviewComplete(s.reviewId);
+}
+
+// ─── Complete review ──────────────────────────────────────────────────
+
+function checkReviewComplete(reviewId: string) {
+  // Any pending sessions left for this review?
+  for (const s of sessions.values()) {
+    if (s.reviewId === reviewId && s.status === 'pending') return; // not done yet
+  }
+
+  // All files processed — build result
+  const files: ReviewResultFile[] = [];
+  const fileSet = reviewFiles.get(reviewId);
+  if (!fileSet) return;
+
+  let allApproved = true;
+  let processed = false;
+
+  for (const fp of fileSet) {
+    const session = [...sessions.values()].find(s => s.filePath === fp);
+
+    // Pending — shouldn't happen (checked above), but guard anyway
+    if (session?.status === 'pending') continue;
+
+    let status: 'approved' | 'rejected';
+    let final = '';
+
+    if (session?.status === 'rejected') {
+      status = 'rejected';
+    } else if (session?.status === 'approved') {
+      status = 'approved';
+      final = fs.readFileSync(path.join(workspaceRoot, fp), 'utf-8');
+    } else {
+      // Session went missing — fallback. Safer to treat as rejected.
+      console.error(`[Pi Companion] checkReviewComplete: session not found for ${fp} in review ${reviewId}`);
+      status = 'rejected';
+    }
+
+    files.push({ path: fp, status, final });
+    processed = true;
+
+    if (status !== 'approved') allApproved = false;
+  }
+
+  // Clean up sessions for this review
+  for (const [key, s] of sessions) {
+    if (s.reviewId === reviewId) sessions.delete(key);
+  }
+
+  const result: ReviewResult = {
+    id: reviewId,
+    status: !processed ? 'rejected' : allApproved ? 'approved' : 'rejected',
+    files,
+  };
+
+  // Write result
+  const resultPath = path.join(resultsDir, `${reviewId}.json`);
+  fs.writeFileSync(resultPath, JSON.stringify(result, null, 2), 'utf-8');
+
+  // Remove request file
+  const requestPath = path.join(requestsDir, `${reviewId}.json`);
+  try { fs.unlinkSync(requestPath); } catch {}
+
+  // Clean up tmp directory
+  const tmpDir = path.join(workspaceRoot, '.pi', 'tmp', reviewId);
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+
+  // Reset context
+  vscode.commands.executeCommand('setContext', 'piSr.isActive', false);
+
+  reviewFiles.delete(reviewId);
+
+  vscode.window.showInformationMessage(
+    `Pi Companion: ${result.status === 'approved' ? 'accepted' : 'rejected'} (${files.filter(f => f.status === 'approved').length}/${files.length})`
+  );
+}

package/vscode-ext/src/types.ts

@@ -0,0 +1,36 @@
+export interface ReviewFile {
+  path: string;
+  original: string;
+  proposed: string;
+  description?: string;
+  language?: string;
+}
+
+export interface ReviewRequest {
+  id: string;
+  title: string;
+  files: ReviewFile[];
+}
+
+export type FileStatus = 'pending' | 'approved' | 'rejected';
+
+export interface ReviewResultFile {
+  path: string;
+  status: 'approved' | 'rejected';
+  final: string;
+}
+
+export interface ReviewResult {
+  id: string;
+  status: 'approved' | 'rejected';
+  files: ReviewResultFile[];
+}
+
+/** Внутреннее состояние одного файла в ревью */
+export interface DiffSession {
+  reviewId: string;
+  filePath: string;
+  originalFsPath: string;   // путь к оригинальному файлу на диске
+  tmpFsPath: string;        // путь к временному файлу с proposed-контентом
+  status: FileStatus;
+}

package/vscode-ext/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "sourceMap": true
+  },
+  "include": ["src"]
+}