@oh-my-pi/pi-coding-agent 6.8.2 → 6.8.4

package/src/core/tools/todo-write.ts

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { mkdirSync } from "node:fs";
 import path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
@@ -13,7 +12,6 @@ import todoWriteDescription from "../../prompts/tools/todo-write.md" with { type
 import type { RenderResultOptions } from "../custom-tools/types";
 import { renderPromptTemplate } from "../prompt-templates";
 import type { ToolSession } from "../sdk";
-import { ensureArtifactsDir, getArtifactsDir } from "./task/artifacts";
 
 const todoWriteSchema = Type.Object({
 	todos: Type.Array(
@@ -135,10 +133,6 @@ async function loadTodoFile(filePath: string): Promise<TodoFile | null> {
 	}
 }
 
-async function saveTodoFile(filePath: string, data: TodoFile): Promise<void> {
-	await Bun.write(filePath, JSON.stringify(data, null, 2));
-}
-
 function formatTodoSummary(todos: TodoItem[]): string {
 	if (todos.length === 0) return "Todo list cleared.";
 	const completed = todos.filter((t) => t.status === "completed").length;
@@ -200,24 +194,14 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 			};
 		}
 
-		const artifactsDir = getArtifactsDir(sessionFile);
-		if (!artifactsDir) {
-			return {
-				content: [{ type: "text", text: formatTodoSummary(todos) }],
-				details: { todos, updatedAt, storage: "memory" },
-			};
-		}
-
-		ensureArtifactsDir(artifactsDir);
-		const todoPath = path.join(artifactsDir, TODO_FILE_NAME);
+		const todoPath = path.join(sessionFile.slice(0, -6), TODO_FILE_NAME);
 		const existing = await loadTodoFile(todoPath);
 		const storedTodos = existing?.todos ?? [];
 		const merged = todos.length > 0 ? todos : [];
 		const fileData: TodoFile = { updatedAt, todos: merged };
 
 		try {
-			mkdirSync(artifactsDir, { recursive: true });
-			await saveTodoFile(todoPath, fileData);
+			await Bun.write(todoPath, JSON.stringify(fileData, null, 2));
 		} catch (error) {
 			logger.error("Failed to write todo file", { path: todoPath, error: String(error) });
 			return {

package/src/core/tools/truncate.ts

@@ -289,3 +289,95 @@ export function truncateLine(
 	}
 	return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
 }
+
+// =============================================================================
+// Truncation notice formatting
+// =============================================================================
+
+export interface TailTruncationNoticeOptions {
+	/** Path to full output file (e.g., from bash/python executor) */
+	fullOutputPath?: string;
+	/** Original content for computing last line size when lastLinePartial */
+	originalContent?: string;
+	/** Additional suffix to append inside the brackets */
+	suffix?: string;
+}
+
+/**
+ * Format a truncation notice for tail-truncated output (bash, python, ssh).
+ * Returns empty string if not truncated.
+ *
+ * Examples:
+ * - "[Showing last 50KB of line 1000 (line is 2.1MB). Full output: /tmp/out.txt]"
+ * - "[Showing lines 500-1000 of 1000. Full output: /tmp/out.txt]"
+ * - "[Showing lines 500-1000 of 1000 (50KB limit). Full output: /tmp/out.txt]"
+ */
+export function formatTailTruncationNotice(
+	truncation: TruncationResult,
+	options: TailTruncationNoticeOptions = {},
+): string {
+	if (!truncation.truncated) {
+		return "";
+	}
+
+	const { fullOutputPath, originalContent, suffix = "" } = options;
+	const startLine = truncation.totalLines - truncation.outputLines + 1;
+	const endLine = truncation.totalLines;
+	const fullOutputPart = fullOutputPath ? `. Full output: ${fullOutputPath}` : "";
+
+	let notice: string;
+
+	if (truncation.lastLinePartial) {
+		let lastLineSizePart = "";
+		if (originalContent) {
+			const lastLine = originalContent.split("\n").pop() || "";
+			lastLineSizePart = ` (line is ${formatSize(Buffer.byteLength(lastLine, "utf-8"))})`;
+		}
+		notice = `[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine}${lastLineSizePart}${fullOutputPart}${suffix}]`;
+	} else if (truncation.truncatedBy === "lines") {
+		notice = `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}${fullOutputPart}${suffix}]`;
+	} else {
+		notice = `[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(truncation.maxBytes)} limit)${fullOutputPart}${suffix}]`;
+	}
+
+	return `\n\n${notice}`;
+}
+
+export interface HeadTruncationNoticeOptions {
+	/** 1-indexed start line number (default: 1) */
+	startLine?: number;
+	/** Total lines in the original file (for "of N" display) */
+	totalFileLines?: number;
+}
+
+/**
+ * Format a truncation notice for head-truncated output (read tool).
+ * Returns empty string if not truncated.
+ *
+ * Examples:
+ * - "[Showing lines 1-2000 of 5000. Use offset=2001 to continue]"
+ * - "[Showing lines 100-2099 of 5000 (50KB limit). Use offset=2100 to continue]"
+ */
+export function formatHeadTruncationNotice(
+	truncation: TruncationResult,
+	options: HeadTruncationNoticeOptions = {},
+): string {
+	if (!truncation.truncated) {
+		return "";
+	}
+
+	const startLineDisplay = options.startLine ?? 1;
+	const totalFileLines = options.totalFileLines ?? truncation.totalLines;
+	const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
+	const nextOffset = endLineDisplay + 1;
+
+	let notice: string;
+
+	if (truncation.truncatedBy === "lines") {
+		notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue]`;
+	} else {
+		notice = `[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(truncation.maxBytes)} limit). Use offset=${nextOffset} to continue]`;
+	}
+
+	return `\n\n${notice}`;
+}

package/src/core/tools/web-fetch.ts

@@ -24,7 +24,9 @@ import { convertWithMarkitdown, fetchBinary } from "./web-scrapers/utils";
 // Types and Constants
 // =============================================================================
 
-const DEFAULT_TIMEOUT = 20;
+const MIN_TIMEOUT = 1_000;
+const DEFAULT_TIMEOUT = 20_000;
+const MAX_TIMEOUT = 45_000;
 
 // Convertible document types (markitdown supported)
 const CONVERTIBLE_MIMES = new Set([
@@ -109,7 +111,7 @@ async function exec(
 ): Promise<{ stdout: string; stderr: string; ok: boolean }> {
 	const proc = ptree.cspawn([cmd, ...args], {
 		stdin: options?.input ? "pipe" : null,
-		timeout: options?.timeout,
+		timeout: options?.timeout ? options.timeout * 1000 : undefined,
 	});
 
 	if (options?.input) {
@@ -244,7 +246,7 @@ async function tryMdSuffix(url: string, timeout: number, signal?: AbortSignal):
 		if (signal?.aborted) {
 			return null;
 		}
-		const result = await loadPage(candidate, { timeout: Math.min(timeout, 5), signal });
+		const result = await loadPage(candidate, { timeout: Math.min(timeout, MAX_TIMEOUT), signal });
 		if (result.ok && result.content.trim().length > 100 && !looksLikeHtml(result.content)) {
 			return result.content;
 		}
@@ -910,7 +912,7 @@ export class WebFetchTool implements AgentTool<typeof webFetchSchema, WebFetchTo
 		}
 
 		// Clamp timeout
-		const effectiveTimeout = Math.min(Math.max(timeout, 1), 120);
+		const effectiveTimeout = Math.min(Math.max(timeout, MIN_TIMEOUT), MAX_TIMEOUT);
 
 		const result = await renderUrl(url, effectiveTimeout, raw, signal);
 

package/src/core/tools/web-scrapers/utils.ts

@@ -1,36 +1,13 @@
 import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import * as path from "node:path";
-import { $ } from "bun";
+import { ptree } from "@oh-my-pi/pi-utils";
 import { nanoid } from "nanoid";
 import { ensureTool } from "../../../utils/tools-manager";
 import { createRequestSignal } from "./types";
 
 const MAX_BYTES = 50 * 1024 * 1024; // 50MB for binary files
 
-interface ExecResult {
-	stdout: string;
-	stderr: string;
-	ok: boolean;
-	exitCode: number;
-}
-
-async function exec(
-	cmd: string,
-	args: string[],
-	options?: { timeout?: number; input?: string | Buffer },
-): Promise<ExecResult> {
-	void options;
-	const result = await $`${cmd} ${args}`.quiet().nothrow();
-	const decoder = new TextDecoder();
-	return {
-		stdout: result.stdout ? decoder.decode(result.stdout) : "",
-		stderr: result.stderr ? decoder.decode(result.stderr) : "",
-		ok: result.exitCode === 0,
-		exitCode: result.exitCode ?? -1,
-	};
-}
-
 export interface ConvertResult {
 	content: string;
 	ok: boolean;
@@ -72,16 +49,16 @@ export async function convertWithMarkitdown(
 
 	try {
 		await Bun.write(tmpFile, content);
-		const result = await exec(markitdown, [tmpFile], { timeout });
-		if (!result.ok) {
-			const stderr = result.stderr.trim();
+		const result = await ptree.cspawn([markitdown, tmpFile], { timeout });
+		const [stdout, stderr, exitCode] = await Promise.all([result.stdout.text(), result.stderr.text(), result.exited]);
+		if (exitCode !== 0) {
 			return {
-				content: result.stdout,
+				content: stdout,
 				ok: false,
-				error: stderr.length > 0 ? stderr : `markitdown failed (exit ${result.exitCode})`,
+				error: stderr.length > 0 ? stderr : `markitdown failed (exit ${exitCode})`,
 			};
 		}
-		return { content: result.stdout, ok: true };
+		return { content: stdout, ok: true };
 	} finally {
 		try {
 			await rm(tmpFile, { force: true });

package/src/core/tools/web-search/providers/anthropic.ts

@@ -64,7 +64,6 @@ function buildSystemBlocks(
 
 	return buildAnthropicSystemBlocks(systemPrompt, {
 		includeClaudeCodeInstruction: includeClaudeCode,
-		includeCacheControl: auth.isOAuth,
 		extraInstructions,
 	});
 }

package/src/index.ts

@@ -194,7 +194,6 @@ export {
 export { type FileSlashCommand, loadSlashCommands as discoverSlashCommands } from "./core/slash-commands";
 // Tools (detail types and utilities)
 export {
-	type BashOperations,
 	type BashToolDetails,
 	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,

package/src/modes/interactive/components/todo-display.ts

@@ -1,7 +1,6 @@
 import * as path from "node:path";
 import { Text } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
-import { getArtifactsDir } from "../../../core/tools/task/artifacts";
 import { theme } from "../theme/theme";
 import type { TodoItem } from "../types";
 
@@ -40,13 +39,7 @@ export class TodoDisplayComponent {
 			return;
 		}
 
-		const artifactsDir = getArtifactsDir(this.sessionFile);
-		if (!artifactsDir) {
-			this.todos = [];
-			this.visible = false;
-			return;
-		}
-
+		const artifactsDir = this.sessionFile.slice(0, -6); // strip .jsonl extension
 		const todoPath = path.join(artifactsDir, TODO_FILE_NAME);
 		const data = await loadTodoFile(todoPath);
 		this.todos = data?.todos ?? [];

package/src/modes/interactive/components/tree-selector.ts

@@ -707,7 +707,7 @@ class TreeList implements Component {
 				this.searchQuery = this.searchQuery.slice(0, -1);
 				this.applyFilter();
 			}
-		} else if (keyData === "l" && !this.searchQuery) {
+		} else if (matchesKey(keyData, "shift+l") && !this.searchQuery) {
 			const selected = this.filteredNodes[this.selectedIndex];
 			if (selected && this.onLabelEdit) {
 				this.onLabelEdit(selected.node.entry.id, selected.node.label);
@@ -821,7 +821,7 @@ export class TreeSelectorComponent extends Container {
 			new TruncatedText(
 				theme.fg(
 					"muted",
-					"  Up/Down: move. Left/Right: page. l: label. Ctrl+O/Shift+Ctrl+O: filter. Alt+D/T/U/L/A: filter. Type to search",
+					"  Up/Down: move. Left/Right: page. Shift+L: label. Ctrl+O/Shift+Ctrl+O: filter. Alt+D/T/U/L/A: filter. Type to search",
 				),
 				0,
 				0,

package/src/modes/interactive/interactive-mode.ts

@@ -28,7 +28,6 @@ import { getRecentSessions } from "../../core/session-manager";
 import type { SettingsManager } from "../../core/settings-manager";
 import { loadSlashCommands } from "../../core/slash-commands";
 import { setTerminalTitle } from "../../core/title-generator";
-import { getArtifactsDir } from "../../core/tools/task/artifacts";
 import { VoiceSupervisor } from "../../core/voice-supervisor";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
@@ -384,15 +383,6 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		// Initial top border update
 		this.updateEditorTopBorder();
-
-		if (!startupQuiet) {
-			const templateNames = this.session.promptTemplates.map((template) => template.name).sort();
-			if (templateNames.length > 0) {
-				const preview = templateNames.slice(0, 3).join(", ");
-				const suffix = templateNames.length > 3 ? ` +${templateNames.length - 3} more` : "";
-				this.showStatus(`Loaded prompt templates: ${preview}${suffix}`);
-			}
-		}
 	}
 
 	async getUserInput(): Promise<{ text: string; images?: ImageContent[] }> {
@@ -481,11 +471,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.renderTodoList();
 			return;
 		}
-		const artifactsDir = getArtifactsDir(sessionFile);
-		if (!artifactsDir) {
-			this.renderTodoList();
-			return;
-		}
+		const artifactsDir = sessionFile.slice(0, -6);
 		const todoPath = path.join(artifactsDir, TODO_FILE_NAME);
 		const file = Bun.file(todoPath);
 		if (!(await file.exists())) {

package/src/utils/clipboard.ts

@@ -32,33 +32,40 @@ function selectPreferredImageMimeType(mimeTypes: string[]): string | null {
 }
 
 export async function copyToClipboard(text: string): Promise<void> {
-	let promise: Promise<void>;
+	const p = platform();
+	const timeout = 5000;
+
 	try {
-		switch (platform()) {
-			case "darwin":
-				promise = $`pbcopy ${text}`.quiet().then(() => void 0);
-				break;
-			case "win32":
-				promise = $`clip ${text}`.quiet().then(() => void 0);
-				break;
-			case "linux":
-				if (isWaylandSession()) {
-					$`wl-copy ${text}`.quiet(); // fire and forget
+		if (p === "darwin") {
+			await Bun.spawn(["pbcopy"], { stdin: Buffer.from(text), timeout }).exited;
+		} else if (p === "win32") {
+			await Bun.spawn(["clip"], { stdin: Buffer.from(text), timeout }).exited;
+		} else {
+			const wayland = isWaylandSession();
+			if (wayland) {
+				const wlCopyPath = Bun.which("wl-copy");
+				if (wlCopyPath) {
+					// Fire-and-forget: wl-copy may not exit promptly, so we unref to avoid blocking
+					void Bun.spawn([wlCopyPath], { stdin: Buffer.from(text), timeout }).unref();
 					return;
-				} else {
-					promise = $`xclip -selection clipboard -t text/plain -i ${text}`.quiet().then(() => void 0);
 				}
-				break;
-			default:
-				throw new Error(`Unsupported platform: ${platform()}`);
+			}
+
+			// Linux - try xclip first, fall back to xsel
+			try {
+				await Bun.spawn(["xclip", "-selection", "clipboard"], { stdin: Buffer.from(text), timeout }).exited;
+			} catch {
+				await Bun.spawn(["xsel", "--clipboard", "--input"], { stdin: Buffer.from(text), timeout }).exited;
+			}
 		}
 	} catch (error) {
-		if (error instanceof Error) {
-			throw new Error(`Failed to copy to clipboard: ${error.message}`, { cause: error });
+		const msg = error instanceof Error ? error.message : String(error);
+		if (p === "linux") {
+			const tools = isWaylandSession() ? "wl-copy, xclip, or xsel" : "xclip or xsel";
+			throw new Error(`Failed to copy to clipboard. Install ${tools}: ${msg}`);
 		}
-		throw new Error(`Failed to copy to clipboard: ${String(error)}`, { cause: error });
+		throw new Error(`Failed to copy to clipboard: ${msg}`);
 	}
-	await Promise.race([promise, Bun.sleep(3000)]);
 }
 
 export interface ClipboardImage {

package/src/core/tools/task/artifacts.ts

@@ -1,112 +0,0 @@
-/**
- * Session artifacts for subagent outputs.
- *
- * When a session exists, writes agent outputs to a sibling directory.
- * Otherwise uses temp files that are cleaned up after execution.
- */
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { nanoid } from "nanoid";
-
-/**
- * Derive artifacts directory from session file path.
- *
- * /path/to/sessions/project/2026-01-01T14-28-11-636Z_uuid.jsonl
- *   → /path/to/sessions/project/2026-01-01T14-28-11-636Z_uuid/
- */
-export function getArtifactsDir(sessionFile: string | null): string | null {
-	if (!sessionFile) return null;
-	// Strip .jsonl extension to get directory path
-	if (sessionFile.endsWith(".jsonl")) {
-		return sessionFile.slice(0, -6);
-	}
-	return sessionFile;
-}
-
-/**
- * Ensure artifacts directory exists.
- */
-export function ensureArtifactsDir(dir: string): void {
-	if (!fs.existsSync(dir)) {
-		fs.mkdirSync(dir, { recursive: true });
-	}
-}
-
-/**
- * Generate artifact file paths for an agent run.
- */
-export function getArtifactPaths(
-	dir: string,
-	taskId: string,
-): { inputPath: string; outputPath: string; jsonlPath: string } {
-	return {
-		inputPath: path.join(dir, `${taskId}.in.md`),
-		outputPath: path.join(dir, `${taskId}.out.md`),
-		jsonlPath: path.join(dir, `${taskId}.jsonl`),
-	};
-}
-
-/**
- * Write artifacts for an agent run.
- */
-export async function writeArtifacts(
-	dir: string,
-	taskId: string,
-	input: string,
-	output: string,
-	jsonlEvents?: string[],
-): Promise<{ inputPath: string; outputPath: string; jsonlPath?: string }> {
-	ensureArtifactsDir(dir);
-
-	const paths = getArtifactPaths(dir, taskId);
-
-	// Write input
-	await Bun.write(paths.inputPath, input);
-
-	// Write output
-	await Bun.write(paths.outputPath, output);
-
-	// Write JSONL if events provided
-	if (jsonlEvents && jsonlEvents.length > 0) {
-		await Bun.write(paths.jsonlPath, jsonlEvents.join("\n"));
-		return paths;
-	}
-
-	return { inputPath: paths.inputPath, outputPath: paths.outputPath };
-}
-
-/**
- * Create a temporary artifacts directory.
- */
-export function createTempArtifactsDir(runId?: string): string {
-	const id = runId || nanoid();
-	const dir = path.join(os.tmpdir(), `omp-task-${id}`);
-	ensureArtifactsDir(dir);
-	return dir;
-}
-
-/**
- * Clean up temporary artifacts.
- */
-export async function cleanupTempArtifacts(paths: string[]): Promise<void> {
-	for (const p of paths) {
-		try {
-			await fs.promises.unlink(p);
-		} catch {
-			// Ignore cleanup errors
-		}
-	}
-}
-
-/**
- * Clean up a temporary directory and its contents.
- */
-export async function cleanupTempDir(dir: string): Promise<void> {
-	try {
-		await fs.promises.rm(dir, { recursive: true, force: true });
-	} catch {
-		// Ignore cleanup errors
-	}
-}