@oh-my-pi/pi-coding-agent 13.14.0 → 13.15.2

package/src/config/model-resolver.ts

@@ -141,6 +141,55 @@ function isAlias(id: string): boolean {
 	return !datePattern.test(id);
 }
 
+/**
+ * Find an exact model reference match.
+ * Supports either a bare model id or a canonical provider/modelId reference.
+ * When matching by bare id, ambiguous matches across providers are rejected.
+ */
+export function findExactModelReferenceMatch(
+	modelReference: string,
+	availableModels: Model<Api>[],
+): Model<Api> | undefined {
+	const trimmedReference = modelReference.trim();
+	if (!trimmedReference) {
+		return undefined;
+	}
+
+	const normalizedReference = trimmedReference.toLowerCase();
+
+	const canonicalMatches = availableModels.filter(
+		model => `${model.provider}/${model.id}`.toLowerCase() === normalizedReference,
+	);
+	if (canonicalMatches.length === 1) {
+		return canonicalMatches[0];
+	}
+	if (canonicalMatches.length > 1) {
+		return undefined;
+	}
+
+	const slashIndex = trimmedReference.indexOf("/");
+	if (slashIndex !== -1) {
+		const provider = trimmedReference.substring(0, slashIndex).trim();
+		const modelId = trimmedReference.substring(slashIndex + 1).trim();
+		if (provider && modelId) {
+			const providerMatches = availableModels.filter(
+				model =>
+					model.provider.toLowerCase() === provider.toLowerCase() &&
+					model.id.toLowerCase() === modelId.toLowerCase(),
+			);
+			if (providerMatches.length === 1) {
+				return providerMatches[0];
+			}
+			if (providerMatches.length > 1) {
+				return undefined;
+			}
+		}
+	}
+
+	const idMatches = availableModels.filter(model => model.id.toLowerCase() === normalizedReference);
+	return idMatches.length === 1 ? idMatches[0] : undefined;
+}
+
 /**
  * Try to match a pattern to a model from the available models list.
  * Returns the matched model or undefined if no match found.
@@ -150,17 +199,17 @@ function tryMatchModel(
 	availableModels: Model<Api>[],
 	context: ModelPreferenceContext,
 ): Model<Api> | undefined {
-	// Check for provider/modelId format (provider is everything before the first /)
+	// Try exact reference match first (handles provider/modelId and bare id with ambiguity rejection)
+	const exactRefMatch = findExactModelReferenceMatch(modelPattern, availableModels);
+	if (exactRefMatch) {
+		return exactRefMatch;
+	}
+
+	// Check for provider/modelId format — fuzzy match within provider
 	const slashIndex = modelPattern.indexOf("/");
 	if (slashIndex !== -1) {
 		const provider = modelPattern.substring(0, slashIndex);
 		const modelId = modelPattern.substring(slashIndex + 1);
-		const providerMatch = availableModels.find(
-			m => m.provider.toLowerCase() === provider.toLowerCase() && m.id.toLowerCase() === modelId.toLowerCase(),
-		);
-		if (providerMatch) {
-			return providerMatch;
-		}
 
 		const providerModels = availableModels.filter(m => m.provider.toLowerCase() === provider.toLowerCase());
 		if (providerModels.length > 0) {
@@ -187,10 +236,9 @@ function tryMatchModel(
 				return scored[0]?.model;
 			}
 		}
-		// No exact provider/model match - fall through to other matching
 	}
 
-	// Check for exact ID match (case-insensitive)
+	// Exact ID match (case-insensitive) — with ambiguity across providers handled by preference
 	const exactMatches = availableModels.filter(m => m.id.toLowerCase() === modelPattern.toLowerCase());
 	if (exactMatches.length > 0) {
 		return pickPreferredModel(exactMatches, context);

package/src/config/settings-schema.ts

@@ -139,6 +139,43 @@ type SettingDef =
 // under `as const` while still letting SettingValue infer the correct element type.
 const EMPTY_STRING_ARRAY: string[] = [];
 const EMPTY_STRING_RECORD: Record<string, string> = {};
+export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
+	{
+		pattern: "^\\s*(cat|head|tail|less|more)\\s+",
+		tool: "read",
+		message: "Use the `read` tool instead of cat/head/tail. It provides better context and handles binary files.",
+	},
+	{
+		pattern: "^\\s*(grep|rg|ripgrep|ag|ack)\\s+",
+		tool: "grep",
+		message: "Use the `grep` tool instead of grep/rg. It respects .gitignore and provides structured output.",
+	},
+	{
+		pattern: "^\\s*(find|fd|locate)\\s+.*(-name|-iname|-type|--type|-glob)",
+		tool: "find",
+		message: "Use the `find` tool instead of find/fd. It respects .gitignore and is faster for glob patterns.",
+	},
+	{
+		pattern: "^\\s*sed\\s+(-i|--in-place)",
+		tool: "edit",
+		message: "Use the `edit` tool instead of sed -i. It provides diff preview and fuzzy matching.",
+	},
+	{
+		pattern: "^\\s*perl\\s+.*-[pn]?i",
+		tool: "edit",
+		message: "Use the `edit` tool instead of perl -i. It provides diff preview and fuzzy matching.",
+	},
+	{
+		pattern: "^\\s*awk\\s+.*-i\\s+inplace",
+		tool: "edit",
+		message: "Use the `edit` tool instead of awk -i inplace. It provides diff preview and fuzzy matching.",
+	},
+	{
+		pattern: "^\\s*(echo|printf|cat\\s*<<)\\s+.*[^|]>\\s*\\S",
+		tool: "write",
+		message: "Use the `write` tool instead of echo/cat redirection. It handles encoding and provides confirmation.",
+	},
+];
 
 export const SETTINGS_SCHEMA = {
 	// ────────────────────────────────────────────────────────────────────────
@@ -943,16 +980,7 @@ export const SETTINGS_SCHEMA = {
 		default: false,
 		ui: { tab: "editing", label: "Bash Interceptor", description: "Block shell commands that have dedicated tools" },
 	},
-
-	"bashInterceptor.simpleLs": {
-		type: "boolean",
-		default: true,
-		ui: {
-			tab: "editing",
-			label: "Intercept `ls`",
-			description: "Intercept bare ls commands (when interceptor is enabled)",
-		},
-	},
+	"bashInterceptor.patterns": { type: "array", default: DEFAULT_BASH_INTERCEPTOR_RULES },
 
 	// Python
 	"python.toolMode": {

package/src/config/settings.ts

@@ -341,10 +341,7 @@ export class Settings {
 	 * Get bash interceptor rules (typed accessor for complex array config).
 	 */
 	getBashInterceptorRules(): BashInterceptorRule[] {
-		const patterns = (this.#merged.bashInterceptor as { patterns?: unknown[] })?.patterns;
-		if (!Array.isArray(patterns)) return [];
-
-		return patterns.filter((p): p is BashInterceptorRule => typeof p === "object" && p !== null && "pattern" in p);
+		return this.get("bashInterceptor.patterns");
 	}
 
 	/**

package/src/exec/bash-executor.ts

@@ -69,11 +69,16 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		onChunk: options?.onChunk,
 		artifactPath: options?.artifactPath,
 		artifactId: options?.artifactId,
+		// Throttle the streaming preview callback to avoid saturating the
+		// event loop when commands produce massive output (e.g. seq 1 50M).
+		chunkThrottleMs: options?.onChunk ? 50 : 0,
 	});
 
-	let pendingChunks = Promise.resolve();
+	// sink.push() is synchronous — buffer management, counters, and onChunk
+	// all run inline. File writes (artifact path) are handled asynchronously
+	// inside the sink. No promise chain needed.
 	const enqueueChunk = (chunk: string) => {
-		pendingChunks = pendingChunks.then(() => sink.push(chunk)).catch(() => {});
+		sink.push(chunk);
 	};
 
 	if (options?.signal?.aborted) {
@@ -160,8 +165,6 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			hardTimeoutDeferred.promise.then(() => ({ kind: "hard-timeout" as const })),
 		]);
 
-		await pendingChunks;
-
 		if (winner.kind === "hard-timeout") {
 			if (shellSession) {
 				resetSession = true;
@@ -215,7 +218,6 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		if (userSignal) {
 			userSignal.removeEventListener("abort", abortHandler);
 		}
-		await pendingChunks;
 		if (resetSession) {
 			shellSessions.delete(sessionKey);
 		}

package/src/export/html/template.css

@@ -2,6 +2,10 @@
 
     :root {
       --line-height: 18px; /* 12px font * 1.5 */
+      --sidebar-width: 400px;
+      --sidebar-min-width: 240px;
+      --sidebar-max-width: 840px;
+      --sidebar-resizer-width: 6px;
     }
 
     body {
@@ -12,6 +16,11 @@
       background: var(--body-bg);
     }
 
+    body.sidebar-resizing {
+      cursor: col-resize;
+      user-select: none;
+    }
+
     #app {
       display: flex;
       min-height: 100vh;
@@ -19,7 +28,9 @@
 
     /* Sidebar */
     #sidebar {
-      width: 400px;
+      width: var(--sidebar-width);
+      min-width: var(--sidebar-width);
+      max-width: var(--sidebar-width);
       background: var(--container-bg);
       flex-shrink: 0;
       display: flex;
@@ -203,8 +214,28 @@
       flex-shrink: 0;
     }
 
+    #sidebar-resizer {
+      width: var(--sidebar-resizer-width);
+      flex-shrink: 0;
+      position: sticky;
+      top: 0;
+      height: 100vh;
+      cursor: col-resize;
+      touch-action: none;
+      background: transparent;
+      border-right: 1px solid transparent;
+    }
+
+    #sidebar-resizer:hover,
+    body.sidebar-resizing #sidebar-resizer {
+      background: var(--selectedBg);
+      border-right-color: var(--dim);
+    }
+
     /* Main content */
     #content {
+      flex: 1;
+      min-width: 0;
       flex: 1;
       overflow-y: auto;
       padding: var(--line-height) calc(var(--line-height) * 2);
@@ -841,17 +872,19 @@
     @media (max-width: 900px) {
       #sidebar {
         position: fixed;
-        left: -400px;
-        width: 400px;
+        transform: translateX(-100%);
+        width: min(var(--sidebar-width), 100vw);
+        min-width: 0;
+        max-width: 100vw;
         top: 0;
         bottom: 0;
         height: 100vh;
         z-index: 99;
-        transition: left 0.3s;
+        transition: transform 0.3s;
       }
 
       #sidebar.open {
-        left: 0;
+        transform: translateX(0);
       }
 
       #sidebar-overlay.open {
@@ -866,6 +899,10 @@
         display: block;
       }
 
+      #sidebar-resizer {
+        display: none;
+      }
+
       #content {
         padding: var(--line-height) 16px;
       }
@@ -875,15 +912,8 @@
       }
     }
 
-    @media (max-width: 500px) {
-      #sidebar {
-        width: 100vw;
-        left: -100vw;
-      }
-    }
-
     @media print {
-      #sidebar, #sidebar-toggle { display: none !important; }
+      #sidebar, #sidebar-toggle, #sidebar-resizer { display: none !important; }
       body { background: white; color: black; }
       #content { max-width: none; }
     }