@oh-my-pi/pi-coding-agent 13.12.9 → 13.13.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [Unreleased]
 
+## [13.13.0] - 2026-03-18
+
+### Added
+
+- Added `edit.blockAutoGenerated` setting to control whether auto-generated file detection is enforced (enabled by default)
+- Improved auto-generated file detection to use language-specific comment parsing instead of broad regex patterns, reducing false positives
+- Added auto-generated file detection to prevent accidental modification of generated code (protoc, sqlc, buf, swagger, etc.)
+- Added validation in Edit and Write tools to block modifications to files with auto-generated markers or naming patterns
+
+### Changed
+
+- Enhanced auto-generated marker detection to only scan leading header comments rather than entire file prefix, improving accuracy for files with generated markers in code
+
+## [13.12.10] - 2026-03-17
+### Added
+
+- Added `args` field to ShellResult to capture the executed command
+- Added `exit_code` property to ShellResult as an alias for `returncode`
+- Added `check_returncode()` method to ShellResult to raise CalledProcessError on non-zero exit codes
+
+### Changed
+
+- Renamed `code` field to `returncode` in ShellResult (accessible via `code` property for backward compatibility)
+- Updated `run()` command documentation to clarify available ShellResult fields
+
 ## [13.12.9] - 2026-03-17
 ### Added
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.12.9",
+	"version": "13.13.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.12.9",
-		"@oh-my-pi/pi-agent-core": "13.12.9",
-		"@oh-my-pi/pi-ai": "13.12.9",
-		"@oh-my-pi/pi-natives": "13.12.9",
-		"@oh-my-pi/pi-tui": "13.12.9",
-		"@oh-my-pi/pi-utils": "13.12.9",
+		"@oh-my-pi/omp-stats": "13.13.0",
+		"@oh-my-pi/pi-agent-core": "13.13.0",
+		"@oh-my-pi/pi-ai": "13.13.0",
+		"@oh-my-pi/pi-natives": "13.13.0",
+		"@oh-my-pi/pi-tui": "13.13.0",
+		"@oh-my-pi/pi-utils": "13.13.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/config/settings-schema.ts

@@ -549,6 +549,16 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"startup.checkUpdate": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "interaction",
+			label: "Check for Updates",
+			description: "If false, skip update check",
+		},
+	},
+
 	collapseChangelog: {
 		type: "boolean",
 		default: false,
@@ -849,7 +859,16 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	// Read tool
+	"edit.blockAutoGenerated": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "editing",
+			label: "Block Auto-Generated Files",
+			description: "Prevent editing of files that appear to be auto-generated (protoc, sqlc, swagger, etc.)",
+		},
+	},
+
 	readLineNumbers: {
 		type: "boolean",
 		default: false,

package/src/ipy/prelude.py

@@ -305,23 +305,40 @@ if "__omp_prelude_loaded__" not in globals():
 
     class ShellResult:
         """Result from shell command execution."""
-        __slots__ = ("stdout", "stderr", "code")
-        def __init__(self, stdout: str, stderr: str, code: int):
+        __slots__ = ("args", "stdout", "stderr", "returncode")
+        def __init__(self, args: str, stdout: str, stderr: str, returncode: int):
+            self.args = args
             self.stdout = stdout
             self.stderr = stderr
-            self.code = code
+            self.returncode = returncode
+
+        @property
+        def code(self) -> int:
+            return self.returncode
+
+        @property
+        def exit_code(self) -> int:
+            return self.returncode
+
+        def check_returncode(self) -> None:
+            if self.returncode != 0:
+                raise subprocess.CalledProcessError(
+                    self.returncode, self.args, output=self.stdout, stderr=self.stderr
+                )
+
         def __repr__(self):
-            if self.code == 0:
+            if self.returncode == 0:
                 return ""
-            return f"exit code {self.code}"
+            return f"exit code {self.returncode}"
+
         def __bool__(self):
-            return self.code == 0
+            return self.returncode == 0
 
     def _make_shell_result(proc: subprocess.CompletedProcess[str], cmd: str) -> ShellResult:
         """Create ShellResult and emit status."""
         output = proc.stdout + proc.stderr if proc.stderr else proc.stdout
         _emit_status("sh", cmd=cmd[:80], code=proc.returncode, output=output[:500])
-        return ShellResult(proc.stdout, proc.stderr, proc.returncode)
+        return ShellResult(cmd, proc.stdout, proc.stderr, proc.returncode)
 
     import signal as _signal
 
@@ -356,7 +373,7 @@ if "__omp_prelude_loaded__" not in globals():
 
     @_category("Shell")
     def run(cmd: str, *, cwd: str | Path | None = None, timeout: int | None = None) -> ShellResult:
-        """Run a shell command."""
+        """Run a shell command. Returns ShellResult with stdout/stderr and returncode/exit_code fields."""
         shell_path = shutil.which("bash") or shutil.which("sh") or "/bin/sh"
         args = [shell_path, "-c", cmd]
         return _run_with_interrupt(args, str(cwd) if cwd else None, timeout, cmd)

package/src/main.ts

@@ -34,6 +34,9 @@ import { resolvePromptInput } from "./system-prompt";
 import { getChangelogPath, getNewEntries, parseChangelog } from "./utils/changelog";
 
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
+	if (!settings.get("startup.checkUpdate")) {
+		return;
+	}
 	try {
 		const response = await fetch("https://registry.npmjs.org/@oh-my-pi/pi-coding-agent/latest");
 		if (!response.ok) return undefined;
@@ -109,6 +112,9 @@ async function runInteractiveMode(
 
 	versionCheckPromise
 		.then(newVersion => {
+			if (!settings.get("startup.checkUpdate")) {
+				return;
+			}
 			if (newVersion) {
 				mode.showNewVersionNotification(newVersion);
 			}

package/src/patch/index.ts

@@ -25,6 +25,7 @@ import hashlineDescription from "../prompts/tools/hashline.md" with { type: "tex
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
 import type { ToolSession } from "../tools";
+import { checkAutoGeneratedFile, checkAutoGeneratedFileContent } from "../tools/auto-generated-guard";
 import {
 	invalidateFsScanAfterDelete,
 	invalidateFsScanAfterRename,
@@ -546,6 +547,7 @@ export class EditTool implements AgentTool<TInput> {
 			const anchorEdits = resolveEditAnchors(edits);
 
 			const rawContent = await fs.readFile(absolutePath, "utf-8");
+			await checkAutoGeneratedFileContent(rawContent, path);
 			const { bom, text } = stripBom(rawContent);
 			const originalEnding = detectLineEnding(text);
 			const originalNormalized = normalizeToLF(text);
@@ -685,6 +687,8 @@ export class EditTool implements AgentTool<TInput> {
 				throw new Error("Cannot edit Jupyter notebooks with the Edit tool. Use the NotebookEdit tool instead.");
 			}
 
+			await checkAutoGeneratedFile(resolvedPath, path);
+
 			const input: PatchInput = { path: resolvedPath, op, rename: resolvedRename, diff };
 			const fs = new LspFileSystem(this.#writethrough, signal, batchRequest);
 			const result = await applyPatch(input, {

package/src/tools/auto-generated-guard.ts

@@ -0,0 +1,310 @@
+/**
+ * Auto-generated file detection guard.
+ *
+ * Prevents editing of files that appear to be automatically generated
+ * by code generation tools (protoc, sqlc, buf, swagger, etc.).
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { settings } from "../config/settings";
+import { ToolError } from "./tool-errors";
+
+/**
+ * Number of bytes to read from the start of a file for auto-generated detection.
+ */
+const CHECK_BYTE_COUNT = 1024;
+const HEADER_LINE_LIMIT = 40;
+
+const KNOWN_GENERATOR_PATTERN =
+	"(?:protoc(?:-gen-[\\w-]+)?|sqlc|buf|swagger(?:-codegen)?|openapi(?:-generator)?|grpc-gateway|mockery|stringer|easyjson|deepcopy-gen|defaulter-gen|conversion-gen|client-gen|lister-gen|informer-gen)";
+
+/**
+ * Strong marker patterns for generated-file headers.
+ *
+ * Keep these strict: broad patterns like /auto-generated/ cause false positives
+ * in normal hand-written files (including this guard implementation itself).
+ */
+const AUTO_GENERATED_HEADER_MARKERS: readonly RegExp[] = [
+	/@generated\b/i,
+	/\bcode\s+generated\s+by\s+[a-z0-9_.-]+/i,
+	/\bthis\s+file\s+was\s+automatically\s+generated\b/i,
+	new RegExp(`\\bgenerated\\s+by\\s+${KNOWN_GENERATOR_PATTERN}\\b`, "i"),
+];
+
+type CommentStyle = "slash" | "hash" | "sql" | "html";
+
+const COMMENT_STYLES_BY_EXTENSION = new Map<string, readonly CommentStyle[]>([
+	[".c", ["slash"]],
+	[".cc", ["slash"]],
+	[".cpp", ["slash"]],
+	[".cs", ["slash"]],
+	[".dart", ["slash"]],
+	[".go", ["slash"]],
+	[".h", ["slash"]],
+	[".hpp", ["slash"]],
+	[".java", ["slash"]],
+	[".js", ["slash"]],
+	[".jsx", ["slash"]],
+	[".kt", ["slash"]],
+	[".kts", ["slash"]],
+	[".mjs", ["slash"]],
+	[".cjs", ["slash"]],
+	[".php", ["slash"]],
+	[".rs", ["slash"]],
+	[".scala", ["slash"]],
+	[".swift", ["slash"]],
+	[".ts", ["slash"]],
+	[".tsx", ["slash"]],
+	[".py", ["hash"]],
+	[".rb", ["hash"]],
+	[".sh", ["hash"]],
+	[".bash", ["hash"]],
+	[".zsh", ["hash"]],
+	[".yml", ["hash"]],
+	[".yaml", ["hash"]],
+	[".toml", ["hash"]],
+	[".ini", ["hash"]],
+	[".cfg", ["hash"]],
+	[".conf", ["hash"]],
+	[".env", ["hash"]],
+	[".pl", ["hash"]],
+	[".r", ["hash"]],
+	[".sql", ["sql"]],
+	[".html", ["html"]],
+	[".htm", ["html"]],
+	[".xml", ["html"]],
+	[".svg", ["html"]],
+	[".xhtml", ["html"]],
+]);
+
+const COMMENT_STYLES_BY_BASENAME = new Map<string, readonly CommentStyle[]>([
+	["dockerfile", ["hash"]],
+	["makefile", ["hash"]],
+	["justfile", ["hash"]],
+]);
+
+/**
+ * File name patterns that strongly indicate auto-generated files.
+ * These are checked against the file name (not content).
+ */
+const AUTO_GENERATED_FILENAME_PATTERNS = [
+	/^zz_generated\./,
+	/\.pb\.(go|cc|h|c|js|ts)$/,
+	/_pb2\.py$/,
+	/_pb2_grpc\.py$/,
+	/\.gen\.(go|ts|js|py)$/,
+	/^generated\.(go|ts|js|py)$/,
+	/\.swagger\.json$/,
+	/\.openapi\.json$/,
+	/\.mock\.(go|ts)$/,
+	/\.mocks?\.(go|ts|js)$/,
+];
+
+function stripBom(content: string): string {
+	if (content.charCodeAt(0) === 0xfeff) {
+		return content.slice(1);
+	}
+	return content;
+}
+
+function getCommentStylesForPath(filePath: string): readonly CommentStyle[] {
+	const normalizedPath = filePath.toLowerCase();
+	const fileName = path.basename(normalizedPath);
+	const stylesByName = COMMENT_STYLES_BY_BASENAME.get(fileName);
+	if (stylesByName) return stylesByName;
+
+	const ext = path.extname(fileName);
+	const stylesByExt = COMMENT_STYLES_BY_EXTENSION.get(ext);
+	return stylesByExt ?? [];
+}
+
+function extractLeadingHeaderCommentText(content: string, commentStyles: readonly CommentStyle[]): string {
+	if (commentStyles.length === 0) return "";
+
+	const includeSlash = commentStyles.includes("slash");
+	const includeHash = commentStyles.includes("hash");
+	const includeSql = commentStyles.includes("sql");
+	const includeHtml = commentStyles.includes("html");
+
+	const lines = stripBom(content).split(/\r?\n/);
+	const headerLines: string[] = [];
+	let started = false;
+	let inSlashBlock = false;
+	let inHtmlBlock = false;
+
+	for (let lineIndex = 0; lineIndex < lines.length && lineIndex < HEADER_LINE_LIMIT; lineIndex += 1) {
+		const trimmed = lines[lineIndex]?.trim() ?? "";
+		if (lineIndex === 0 && trimmed.startsWith("#!")) {
+			continue;
+		}
+
+		if (inSlashBlock) {
+			headerLines.push(trimmed);
+			if (trimmed.includes("*/")) inSlashBlock = false;
+			continue;
+		}
+
+		if (inHtmlBlock) {
+			headerLines.push(trimmed);
+			if (trimmed.includes("-->")) inHtmlBlock = false;
+			continue;
+		}
+
+		if (trimmed.length === 0) {
+			if (started) headerLines.push("");
+			continue;
+		}
+
+		if (includeSlash && trimmed.startsWith("//")) {
+			started = true;
+			headerLines.push(trimmed);
+			continue;
+		}
+
+		if (includeSlash && trimmed.startsWith("/*")) {
+			started = true;
+			headerLines.push(trimmed);
+			if (!trimmed.includes("*/")) {
+				inSlashBlock = true;
+			}
+			continue;
+		}
+
+		if (includeHash && trimmed.startsWith("#")) {
+			started = true;
+			headerLines.push(trimmed);
+			continue;
+		}
+
+		if (includeSql && trimmed.startsWith("--")) {
+			started = true;
+			headerLines.push(trimmed);
+			continue;
+		}
+
+		if (includeHtml && trimmed.startsWith("<!--")) {
+			started = true;
+			headerLines.push(trimmed);
+			if (!trimmed.includes("-->")) {
+				inHtmlBlock = true;
+			}
+			continue;
+		}
+
+		if (started) break;
+		break;
+	}
+
+	return headerLines.join("\n");
+}
+
+/**
+ * Check if a file name indicates it might be auto-generated.
+ * This is a quick pre-check before reading file content.
+ */
+function isAutoGeneratedFileName(filePath: string): boolean {
+	const fileName = filePath.split("/").pop() ?? "";
+	return AUTO_GENERATED_FILENAME_PATTERNS.some(pattern => pattern.test(fileName));
+}
+
+/**
+ * Check if leading header comments contain auto-generated markers.
+ * Returns the matched marker text if found, null otherwise.
+ */
+function detectAutoGeneratedMarker(content: string, filePath: string): string | null {
+	const commentStyles = getCommentStylesForPath(filePath);
+	const headerCommentText = extractLeadingHeaderCommentText(content, commentStyles);
+	if (!headerCommentText) return null;
+
+	for (const markerPattern of AUTO_GENERATED_HEADER_MARKERS) {
+		const match = markerPattern.exec(headerCommentText);
+		if (match?.[0]) return match[0];
+	}
+
+	return null;
+}
+
+/**
+ * Read the first N bytes of a file as a UTF-8 string.
+ * More efficient than reading the entire file.
+ */
+async function readFilePrefix(filePath: string, bytes: number): Promise<string | null> {
+	const handle = await fs.open(filePath, "r").catch(() => null);
+	if (!handle) {
+		return null;
+	}
+
+	try {
+		const buffer = Buffer.allocUnsafe(bytes);
+		const { bytesRead } = await handle.read(buffer, 0, bytes, 0);
+		return buffer.toString("utf-8", 0, bytesRead);
+	} catch {
+		return null;
+	} finally {
+		await handle.close();
+	}
+}
+
+/**
+ * Build the error message for an auto-generated file.
+ */
+function buildAutoGeneratedError(displayPath: string, detected: string): ToolError {
+	return new ToolError(
+		`Cannot modify auto-generated file: ${displayPath}\n\n` +
+			`This file appears to be automatically generated (detected marker: "${detected}").\n` +
+			`Auto-generated files should not be edited directly. Instead:\n` +
+			`1. Find the source file or generator configuration\n` +
+			`2. Make changes to the source\n` +
+			`3. Regenerate the file`,
+	);
+}
+
+/**
+ * Check if a file is auto-generated by examining its content.
+ * Throws ToolError if the file appears to be auto-generated.
+ *
+ * @param absolutePath - Absolute path to the file
+ * @param displayPath - Path to show in error messages (relative or as provided)
+ */
+export async function checkAutoGeneratedFile(absolutePath: string, displayPath?: string): Promise<void> {
+	if (!settings.get("edit.blockAutoGenerated")) {
+		return;
+	}
+
+	const pathForDisplay = displayPath ?? absolutePath;
+
+	if (isAutoGeneratedFileName(absolutePath)) {
+		const fileName = absolutePath.split("/").pop() ?? "";
+		throw buildAutoGeneratedError(pathForDisplay, fileName);
+	}
+
+	const content = await readFilePrefix(absolutePath, CHECK_BYTE_COUNT);
+	if (content === null) {
+		return;
+	}
+
+	const marker = detectAutoGeneratedMarker(content, absolutePath);
+	if (marker) {
+		throw buildAutoGeneratedError(pathForDisplay, marker);
+	}
+}
+
+/**
+ * Check if file content is auto-generated.
+ * Uses only the first CHECK_BYTE_COUNT characters of the content.
+ * Throws ToolError if the content appears to be auto-generated.
+ *
+ * @param content - File content to check (can be full content or prefix)
+ * @param displayPath - Path to show in error messages
+ */
+export async function checkAutoGeneratedFileContent(content: string, displayPath: string): Promise<void> {
+	if (!settings.get("edit.blockAutoGenerated")) {
+		return;
+	}
+
+	const prefix = content.slice(0, CHECK_BYTE_COUNT);
+	const marker = detectAutoGeneratedMarker(prefix, displayPath);
+	if (marker) {
+		throw buildAutoGeneratedError(displayPath, marker);
+	}
+}

package/src/tools/write.ts

@@ -1,3 +1,4 @@
+import * as fs from "node:fs/promises";
 import type {
 	AgentTool,
 	AgentToolContext,
@@ -16,6 +17,7 @@ import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
 import writeDescription from "../prompts/tools/write.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
+import { checkAutoGeneratedFile } from "./auto-generated-guard";
 import { invalidateFsScanAfterWrite } from "./fs-cache-invalidation";
 import { type OutputMeta, outputMeta } from "./output-meta";
 import { enforcePlanModeWrite, resolvePlanPath } from "./plan-mode-guard";
@@ -102,6 +104,11 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 			const absolutePath = resolvePlanPath(this.session, path);
 			const batchRequest = getLspBatchRequest(context?.toolCall);
 
+			// Check if file exists and is auto-generated before overwriting
+			if (await fs.exists(absolutePath)) {
+				await checkAutoGeneratedFile(absolutePath, path);
+			}
+
 			const diagnostics = await this.#writethrough(absolutePath, content, signal, undefined, batchRequest);
 			invalidateFsScanAfterWrite(absolutePath);