@oh-my-pi/pi-coding-agent 10.2.1 → 10.2.3

package/src/tools/bash.ts

@@ -11,7 +11,7 @@ import type { Theme } from "../modes/theme/theme";
 import bashDescription from "../prompts/tools/bash.md" with { type: "text" };
 import { renderOutputBlock, renderStatusLine } from "../tui";
 import type { ToolSession } from ".";
-import { checkBashInterception, checkSimpleLsInterception } from "./bash-interceptor";
+import { checkBashInterception } from "./bash-interceptor";
 import { applyHeadTail, normalizeBashCommand } from "./bash-normalize";
 import type { OutputMeta } from "./output-meta";
 import { allocateOutputArtifact, createTailBuffer } from "./output-utils";
@@ -83,12 +83,6 @@ export class BashTool implements AgentTool<typeof bashSchema, BashToolDetails> {
 			if (interception.block) {
 				throw new ToolError(interception.message ?? "Command blocked");
 			}
-			if (this.session.settings.get("bashInterceptor.simpleLs")) {
-				const lsInterception = checkSimpleLsInterception(command, ctx?.toolNames ?? []);
-				if (lsInterception.block) {
-					throw new ToolError(lsInterception.message ?? "Command blocked");
-				}
-			}
 		}
 
 		const commandCwd = cwd ? resolveToCwd(cwd, this.session.cwd) : this.session.cwd;

package/src/tools/index.ts

@@ -22,7 +22,6 @@ import { ExitPlanModeTool } from "./exit-plan-mode";
 import { FetchTool } from "./fetch";
 import { FindTool } from "./find";
 import { GrepTool } from "./grep";
-import { LsTool } from "./ls";
 import { NotebookTool } from "./notebook";
 import { wrapToolsWithMetaNotice } from "./output-meta";
 import { PythonTool } from "./python";
@@ -76,7 +75,6 @@ export { FetchTool, type FetchToolDetails } from "./fetch";
 export { type FindOperations, FindTool, type FindToolDetails, type FindToolOptions } from "./find";
 export { setPreferredImageProvider } from "./gemini-image";
 export { type GrepOperations, GrepTool, type GrepToolDetails, type GrepToolOptions } from "./grep";
-export { type LsOperations, LsTool, type LsToolDetails, type LsToolOptions } from "./ls";
 export { NotebookTool, type NotebookToolDetails } from "./notebook";
 export { PythonTool, type PythonToolDetails, type PythonToolOptions } from "./python";
 export { ReadTool, type ReadToolDetails } from "./read";
@@ -170,7 +168,6 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	edit: s => new EditTool(s),
 	find: s => new FindTool(s),
 	grep: s => new GrepTool(s),
-	ls: s => new LsTool(s),
 	lsp: LspTool.createIf,
 	notebook: s => new NotebookTool(s),
 	read: s => new ReadTool(s),
@@ -278,6 +275,14 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "lsp") return enableLsp;
 		if (name === "bash") return allowBash;
 		if (name === "python") return allowPython;
+		if (name === "todo_write") return !includeSubmitResult && session.settings.get("todo.enabled");
+		if (name === "find") return session.settings.get("find.enabled");
+		if (name === "grep") return session.settings.get("grep.enabled");
+		if (name === "notebook") return session.settings.get("notebook.enabled");
+		if (name === "fetch") return session.settings.get("fetch.enabled");
+		if (name === "web_search") return session.settings.get("web_search.enabled");
+		if (name === "lsp") return session.settings.get("lsp.enabled");
+		if (name === "calc") return session.settings.get("calc.enabled");
 		return true;
 	};
 	if (includeSubmitResult && requestedTools && !requestedTools.includes("submit_result")) {

package/src/tools/read.ts

@@ -19,10 +19,9 @@ import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { detectSupportedImageMimeTypeFromFile } from "../utils/mime";
 import { ensureTool } from "../utils/tools-manager";
 import { applyListLimit } from "./list-limit";
-import { LsTool } from "./ls";
 import type { OutputMeta } from "./output-meta";
 import { resolveReadPath, resolveToCwd } from "./path-utils";
-import { shortenPath, wrapBrackets } from "./render-utils";
+import { formatAge, shortenPath, wrapBrackets } from "./render-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import {
@@ -519,7 +518,7 @@ const readSchema = Type.Object({
 
 export interface ReadToolDetails {
 	truncation?: TruncationResult;
-	redirectedTo?: "ls";
+	isDirectory?: boolean;
 	resolvedPath?: string;
 	meta?: OutputMeta;
 }
@@ -530,7 +529,7 @@ type ReadParams = { path: string; offset?: number; limit?: number; lines?: boole
  * Read tool implementation.
  *
  * Reads files with support for images, documents (via markitdown), and text.
- * Directories redirect to the ls tool.
+ * Directories return a formatted listing with modification times.
  */
 export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	public readonly name = "read";
@@ -542,20 +541,18 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	private readonly session: ToolSession;
 	private readonly autoResizeImages: boolean;
 	private readonly defaultLineNumbers: boolean;
-	private readonly lsTool: LsTool;
 
 	constructor(session: ToolSession) {
 		this.session = session;
 		this.autoResizeImages = session.settings.get("images.autoResize");
 		this.defaultLineNumbers = session.settings.get("readLineNumbers");
-		this.lsTool = new LsTool(session);
 		this.description = renderPromptTemplate(readDescription, {
 			DEFAULT_MAX_LINES: String(DEFAULT_MAX_LINES),
 		});
 	}
 
 	public async execute(
-		toolCallId: string,
+		_toolCallId: string,
 		params: ReadParams,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<ReadToolDetails>,
@@ -606,13 +603,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		}
 
 		if (isDirectory) {
-			const lsResult = await this.lsTool.execute(toolCallId, { path: readPath, limit }, signal);
-			const details: ReadToolDetails = {
-				redirectedTo: "ls",
-				truncation: lsResult.details?.truncation,
-				meta: lsResult.details?.meta,
-			};
-			return toolResult(details).content(lsResult.content).done();
+			return this.readDirectory(absolutePath, limit, signal);
 		}
 
 		const mimeType = await detectSupportedImageMimeTypeFromFile(absolutePath);
@@ -982,6 +973,75 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		}
 		return resultBuilder.done();
 	}
+
+	/** Read directory contents as a formatted listing */
+	private async readDirectory(
+		absolutePath: string,
+		limit: number | undefined,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<ReadToolDetails>> {
+		const DEFAULT_LIMIT = 500;
+		const effectiveLimit = limit ?? DEFAULT_LIMIT;
+
+		let entries: string[];
+		try {
+			entries = await fs.readdir(absolutePath);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new ToolError(`Cannot read directory: ${message}`);
+		}
+
+		// Sort alphabetically (case-insensitive)
+		entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+
+		const listLimit = applyListLimit(entries, { limit: effectiveLimit });
+		const limitedEntries = listLimit.items;
+		const limitMeta = listLimit.meta;
+
+		// Format entries with directory indicators and ages
+		const results: string[] = [];
+
+		for (const entry of limitedEntries) {
+			throwIfAborted(signal);
+			const fullPath = path.join(absolutePath, entry);
+			let suffix = "";
+			let age = "";
+
+			try {
+				const entryStat = await fs.stat(fullPath);
+				suffix = entryStat.isDirectory() ? "/" : "";
+				const ageSeconds = Math.floor((Date.now() - entryStat.mtimeMs) / 1000);
+				age = formatAge(ageSeconds);
+			} catch {
+				// Skip entries we can't stat
+				continue;
+			}
+
+			const line = age ? `${entry}${suffix} (${age})` : entry + suffix;
+			results.push(line);
+		}
+
+		if (results.length === 0) {
+			return { content: [{ type: "text", text: "(empty directory)" }], details: {} };
+		}
+
+		const output = results.join("\n");
+		const truncation = truncateHead(output, { maxLines: Number.MAX_SAFE_INTEGER });
+
+		const details: ReadToolDetails = {
+			isDirectory: true,
+		};
+
+		const resultBuilder = toolResult(details)
+			.text(truncation.content)
+			.limits({ resultLimit: limitMeta.resultLimit?.reached });
+		if (truncation.truncated) {
+			resultBuilder.truncation(truncation, { direction: "head" });
+			details.truncation = truncation;
+		}
+
+		return resultBuilder.done();
+	}
 }
 
 // =============================================================================
@@ -1029,9 +1089,6 @@ export const readToolRenderer = {
 		const warningLines: string[] = [];
 		const truncation = details?.meta?.truncation;
 		const fallback = details?.truncation;
-		if (details?.redirectedTo) {
-			warningLines.push(uiTheme.fg("warning", wrapBrackets(`Redirected to ${details.redirectedTo}`, uiTheme)));
-		}
 		if (details?.resolvedPath) {
 			warningLines.push(uiTheme.fg("dim", wrapBrackets(`Resolved path: ${details.resolvedPath}`, uiTheme)));
 		}

package/src/tools/renderers.ts

@@ -16,7 +16,6 @@ import { calculatorToolRenderer } from "./calculator";
 import { fetchToolRenderer } from "./fetch";
 import { findToolRenderer } from "./find";
 import { grepToolRenderer } from "./grep";
-import { lsToolRenderer } from "./ls";
 import { notebookToolRenderer } from "./notebook";
 import { pythonToolRenderer } from "./python";
 import { readToolRenderer } from "./read";
@@ -49,7 +48,6 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	edit: editToolRenderer as ToolRenderer,
 	find: findToolRenderer as ToolRenderer,
 	grep: grepToolRenderer as ToolRenderer,
-	ls: lsToolRenderer as ToolRenderer,
 	lsp: lspToolRenderer as ToolRenderer,
 	notebook: notebookToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,

package/src/lsp/rust-analyzer.ts

@@ -1,184 +0,0 @@
-import { sendNotification, sendRequest } from "./client";
-import type { Diagnostic, ExpandMacroResult, LspClient, RelatedTest, Runnable, WorkspaceEdit } from "./types";
-import { fileToUri } from "./utils";
-
-/**
- * Run flycheck (cargo check) and collect diagnostics.
- * Sends rust-analyzer/runFlycheck notification and waits for diagnostics to accumulate.
- *
- * @param client - LSP client instance
- * @param file - Optional file path to check (if not provided, checks entire workspace)
- * @returns Array of all collected diagnostics
- */
-export async function flycheck(client: LspClient, file?: string): Promise<Diagnostic[]> {
-	const textDocument = file ? { uri: fileToUri(file) } : null;
-
-	const countDiagnostics = (diagnostics: Map<string, Diagnostic[]>): number => {
-		let count = 0;
-		for (const diags of diagnostics.values()) {
-			count += diags.length;
-		}
-		return count;
-	};
-
-	// Capture current diagnostic version before triggering flycheck
-	const initialDiagnosticsVersion = client.diagnosticsVersion;
-	const initialDiagnosticsCount = countDiagnostics(client.diagnostics);
-
-	await sendNotification(client, "rust-analyzer/runFlycheck", { textDocument });
-
-	// Bounded polling: wait for diagnostics to stabilize or timeout
-	// Poll every 100ms for up to 8 seconds (80 iterations)
-	const pollIntervalMs = 100;
-	const maxPollIterations = 80;
-	const stabilityThreshold = 3; // Consider stable after 3 iterations without change
-	const minStableDurationMs = 2000; // Avoid early exit when diagnostics are re-published unchanged.
-	const startTime = Date.now();
-	let lastDiagnosticsVersion = initialDiagnosticsVersion;
-	let lastDiagnosticsCount = initialDiagnosticsCount;
-	let stableIterations = 0;
-
-	for (let i = 0; i < maxPollIterations; i++) {
-		await Bun.sleep(pollIntervalMs);
-
-		const currentDiagnosticsVersion = client.diagnosticsVersion;
-		const currentDiagnosticsCount = countDiagnostics(client.diagnostics);
-
-		// Check if diagnostics have stabilized
-		if (currentDiagnosticsVersion === lastDiagnosticsVersion && currentDiagnosticsCount === lastDiagnosticsCount) {
-			stableIterations++;
-			const elapsedMs = Date.now() - startTime;
-			const countChangedFromStart = currentDiagnosticsCount !== initialDiagnosticsCount;
-			if (
-				currentDiagnosticsVersion !== initialDiagnosticsVersion &&
-				stableIterations >= stabilityThreshold &&
-				(countChangedFromStart || elapsedMs >= minStableDurationMs)
-			) {
-				break;
-			}
-		} else {
-			stableIterations = 0;
-			lastDiagnosticsVersion = currentDiagnosticsVersion;
-			lastDiagnosticsCount = currentDiagnosticsCount;
-		}
-	}
-
-	// Collect all diagnostics from client
-	const allDiags: Diagnostic[] = [];
-	for (const diags of Array.from(client.diagnostics.values())) {
-		allDiags.push(...diags);
-	}
-
-	return allDiags;
-}
-
-/**
- * Expand macro at the given position.
- *
- * @param client - LSP client instance
- * @param file - File path containing the macro
- * @param line - 1-based line number
- * @param character - 1-based character offset
- * @returns ExpandMacroResult with macro name and expansion, or null if no macro at position
- */
-export async function expandMacro(
-	client: LspClient,
-	file: string,
-	line: number,
-	character: number,
-): Promise<ExpandMacroResult | null> {
-	const result = (await sendRequest(client, "rust-analyzer/expandMacro", {
-		textDocument: { uri: fileToUri(file) },
-		position: { line: line - 1, character: character - 1 },
-	})) as ExpandMacroResult | null;
-
-	return result;
-}
-
-/**
- * Perform structural search and replace (SSR).
- *
- * @param client - LSP client instance
- * @param pattern - Search pattern
- * @param replacement - Replacement pattern
- * @param parseOnly - If true, returns matches only; if false, returns WorkspaceEdit to apply
- * @returns WorkspaceEdit containing matches or changes to apply
- */
-export async function ssr(
-	client: LspClient,
-	pattern: string,
-	replacement: string,
-	parseOnly = true,
-): Promise<WorkspaceEdit> {
-	const result = (await sendRequest(client, "experimental/ssr", {
-		query: `${pattern} ==>> ${replacement}`,
-		parseOnly,
-		textDocument: { uri: "" }, // SSR searches workspace-wide
-		position: { line: 0, character: 0 },
-		selections: [],
-	})) as WorkspaceEdit;
-
-	return result;
-}
-
-/**
- * Get runnables (tests, binaries, examples) for a file.
- *
- * @param client - LSP client instance
- * @param file - File path to query
- * @param line - Optional 1-based line number to get runnables at specific position
- * @returns Array of Runnable items
- */
-export async function runnables(client: LspClient, file: string, line?: number): Promise<Runnable[]> {
-	const params: { textDocument: { uri: string }; position?: { line: number; character: number } } = {
-		textDocument: { uri: fileToUri(file) },
-	};
-
-	if (line !== undefined) {
-		params.position = { line: line - 1, character: 0 };
-	}
-
-	const result = (await sendRequest(client, "experimental/runnables", params)) as Runnable[];
-	return result ?? [];
-}
-
-/**
- * Get related tests for a position (e.g., tests for a function).
- *
- * @param client - LSP client instance
- * @param file - File path
- * @param line - 1-based line number
- * @param character - 1-based character offset
- * @returns Array of test runnable labels
- */
-export async function relatedTests(
-	client: LspClient,
-	file: string,
-	line: number,
-	character: number,
-): Promise<string[]> {
-	const tests = (await sendRequest(client, "rust-analyzer/relatedTests", {
-		textDocument: { uri: fileToUri(file) },
-		position: { line: line - 1, character: character - 1 },
-	})) as RelatedTest[];
-
-	if (!tests?.length) return [];
-
-	const labels: string[] = [];
-	for (const t of tests) {
-		if (t.runnable?.label) {
-			labels.push(t.runnable.label);
-		}
-	}
-
-	return labels;
-}
-
-/**
- * Reload workspace (re-index Cargo projects).
- *
- * @param client - LSP client instance
- */
-export async function reloadWorkspace(client: LspClient): Promise<void> {
-	await sendRequest(client, "rust-analyzer/reloadWorkspace", null);
-}