pi-critique 0.1.1 → 0.1.2

package/README.md

@@ -1,13 +1,15 @@
 # pi-critique
 
-Structured AI critique for writing and code in [pi](https://github.com/badlogic/pi-mono). Submits a critique prompt to the model, which returns numbered critiques (C1, C2, ...) with inline markers in the original document. Pairs well with [pi-annotated-reply](https://github.com/omaclaren/pi-annotated-reply) and [pi-markdown-preview](https://github.com/omaclaren/pi-markdown-preview) but works standalone.
+Structured AI critique for writing and code in [pi](https://github.com/badlogic/pi-mono). Submits a critique prompt to the model, which returns numbered critiques (C1, C2, ...) with inline markers in the document text. Pairs well with [pi-annotated-reply](https://github.com/omaclaren/pi-annotated-reply) and [pi-markdown-preview](https://github.com/omaclaren/pi-markdown-preview) but works standalone.
+
+**Non-destructive by default:** `/critique` is intended to analyze, not edit, your source file.
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
 | `/critique` | Critique the last assistant response |
-| `/critique <path>` | Critique a file |
+| `/critique <path>` | Critique a file (non-destructive; original file is unchanged) |
 | `/critique --code` | Force code review lens |
 | `/critique --writing` | Force writing critique lens |
 | `/critique --no-inline` | Critiques list only, no annotated document |
@@ -31,6 +33,13 @@ The model adapts critique types to the genre:
 
 Types are not fixed — the model chooses what fits the content.
 
+## Non-destructive behaviour
+
+- For normal files, the extension reads content and sends it to the model for critique. It does not directly edit your source file.
+- For large files (see below), the model is instructed to write annotations to a separate file: `<filename>.critique.<ext>`.
+- During auto-submitted `/critique <path>` runs, a safety guard blocks write/edit tool calls to prevent accidental in-place edits.
+- To actually apply changes to the original file, run a separate explicit editing step (for example via `/reply` + a follow-up prompt).
+
 ## Lenses
 
 The extension auto-detects whether content is code or writing based on file extension. Override with `--code` or `--writing`.
@@ -41,6 +50,8 @@ Code files (`.ts`, `.py`, `.rs`, `.go`, etc.) get a code review prompt. Writing
 
 Files over 500 lines are handled differently to save tokens: the extension passes the file path to the model (rather than embedding the content), and the model reads the file with its tools and writes an annotated copy to `<filename>.critique.<ext>` on disk.
 
+The original file path is preserved; annotations are written to the `*.critique.*` copy.
+
 ## Example output
 
 ```markdown

package/index.ts

@@ -195,6 +195,21 @@ function expandHome(pathInput: string): string {
 	return join(home, pathInput.slice(2));
 }
 
+function normalizePathForComparison(pathInput: string, cwd: string): string {
+	const withoutAt = pathInput.startsWith("@") ? pathInput.slice(1) : pathInput;
+	const expanded = expandHome(withoutAt.trim());
+	return isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
+}
+
+function pathsEqual(a: string, b: string): boolean {
+	if (process.platform === "win32") return a.toLowerCase() === b.toLowerCase();
+	return a === b;
+}
+
+type CritiqueWriteGuard =
+	| { mode: "deny-all"; sourcePath: string }
+	| { mode: "allow-annotated-only"; sourcePath: string; annotatedPath: string };
+
 function detectLens(filePath?: string): Lens {
 	if (!filePath) return "writing";
 	const ext = extname(filePath).toLowerCase();
@@ -230,9 +245,8 @@ function getLastAssistantMarkdown(ctx: ExtensionCommandContext): string | undefi
 	return undefined;
 }
 
-function readFileContent(filePath: string, cwd: string): { ok: true; content: string; label: string } | { ok: false; message: string } {
-	const expanded = expandHome(filePath.trim());
-	const resolved = isAbsolute(expanded) ? expanded : resolve(cwd, expanded);
+function readFileContent(filePath: string, cwd: string): { ok: true; content: string; label: string; resolvedPath: string } | { ok: false; message: string } {
+	const resolved = normalizePathForComparison(filePath, cwd);
 
 	try {
 		const stats = statSync(resolved);
@@ -249,7 +263,7 @@ function readFileContent(filePath: string, cwd: string): { ok: true; content: st
 		if (content.includes("\u0000")) {
 			return { ok: false, message: `File appears to be binary: ${filePath}` };
 		}
-		return { ok: true, content, label: filePath };
+		return { ok: true, content, label: filePath, resolvedPath: resolved };
 	} catch (error) {
 		const msg = error instanceof Error ? error.message : String(error);
 		return { ok: false, message: `Failed to read file: ${msg}` };
@@ -332,6 +346,38 @@ function parseArgs(args: string): ParsedArgs {
 }
 
 export default function (pi: ExtensionAPI) {
+	let critiqueWriteGuard: CritiqueWriteGuard | undefined;
+
+	pi.on("agent_end", async () => {
+		critiqueWriteGuard = undefined;
+	});
+
+	pi.on("tool_call", async (event, ctx) => {
+		if (!critiqueWriteGuard) return;
+		if (event.toolName !== "write" && event.toolName !== "edit") return;
+
+		const inputPath = (event.input as { path?: unknown } | undefined)?.path;
+		if (typeof inputPath !== "string" || !inputPath.trim()) {
+			return { block: true, reason: "Blocked by /critique safety guard: write/edit path is missing." };
+		}
+
+		const targetPath = normalizePathForComparison(inputPath, ctx.cwd);
+
+		if (critiqueWriteGuard.mode === "deny-all") {
+			return {
+				block: true,
+				reason: `Blocked by /critique safety guard: critique runs are non-destructive (source: ${critiqueWriteGuard.sourcePath}). Use a separate follow-up prompt to apply edits.`,
+			};
+		}
+
+		if (!pathsEqual(targetPath, critiqueWriteGuard.annotatedPath)) {
+			return {
+				block: true,
+				reason: `Blocked by /critique safety guard: only the annotated output path is writable (${critiqueWriteGuard.annotatedPath}); source preserved (${critiqueWriteGuard.sourcePath}).`,
+			};
+		}
+	});
+
 	pi.registerCommand("critique", {
 		description: "Critique a file or the last response. Usage: /critique [path] [--code|--writing] [--no-inline] [--edit]",
 		handler: async (args, ctx) => {
@@ -361,9 +407,11 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			await ctx.waitForIdle();
+			critiqueWriteGuard = undefined;
 
 			let content: string;
 			let label: string;
+			let sourcePath: string | undefined;
 
 			if (parsed.file) {
 				const result = readFileContent(parsed.file, ctx.cwd);
@@ -373,6 +421,7 @@ export default function (pi: ExtensionAPI) {
 				}
 				content = result.content;
 				label = result.label;
+				sourcePath = result.resolvedPath;
 			} else {
 				const markdown = getLastAssistantMarkdown(ctx);
 				if (!markdown) {
@@ -389,19 +438,24 @@ export default function (pi: ExtensionAPI) {
 
 			// Large files: pass filepath, model reads and writes annotated copy to disk
 			if (isLargeFile) {
-				const expanded = expandHome(parsed.file!.trim());
-				const resolvedPath = isAbsolute(expanded) ? expanded : resolve(ctx.cwd, expanded);
+				const resolvedPath = sourcePath ?? normalizePathForComparison(parsed.file!, ctx.cwd);
 				const ext = extname(resolvedPath);
 				const base = resolvedPath.slice(0, resolvedPath.length - ext.length);
 				const annotatedPath = `${base}.critique${ext}`;
+				const normalizedAnnotatedPath = normalizePathForComparison(annotatedPath, ctx.cwd);
 				const prompt = buildLargeFilePrompt(lens, resolvedPath, annotatedPath);
 
 				if (parsed.edit) {
 					ctx.ui.setEditorText(prompt);
 					ctx.ui.notify(`Critique prompt (${lens}) for ${label} loaded into editor. Edit and submit when ready.`, "info");
 				} else {
+					critiqueWriteGuard = {
+						mode: "allow-annotated-only",
+						sourcePath: resolvedPath,
+						annotatedPath: normalizedAnnotatedPath,
+					};
 					pi.sendUserMessage(prompt);
-					ctx.ui.notify(`Critiquing ${label} (${lens}, ${contentLines} lines). Annotated copy → ${annotatedPath}`, "info");
+					ctx.ui.notify(`Critiquing ${label} (${lens}, ${contentLines} lines). Original preserved; annotated copy → ${annotatedPath}`, "info");
 				}
 				return;
 			}
@@ -416,8 +470,9 @@ export default function (pi: ExtensionAPI) {
 				ctx.ui.setEditorText(prompt);
 				ctx.ui.notify(`Critique prompt (${lens}) for ${label} loaded into editor. Edit and submit when ready.`, "info");
 			} else {
+				critiqueWriteGuard = sourcePath ? { mode: "deny-all", sourcePath } : undefined;
 				pi.sendUserMessage(prompt);
-				ctx.ui.notify(`Critiquing ${label} (${lens}${parsed.inline ? ", inline" : ""})... Respond with [accept C1], [reject C2: reason], etc.`, "info");
+				ctx.ui.notify(`Critiquing ${label} (${lens}${parsed.inline ? ", inline" : ""})... Original file unchanged. Respond with [accept C1], [reject C2: reason], etc.`, "info");
 			}
 		},
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-critique",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Structured AI critique for writing and code. Pairs well with annotated-reply and markdown-preview but works standalone.",
   "type": "module",
   "license": "MIT",