@oh-my-pi/pi-coding-agent 8.4.3 → 8.5.0

package/src/tools/read.ts

@@ -16,7 +16,7 @@ import { renderCodeCell, renderOutputBlock, renderStatusLine } from "../tui";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { detectSupportedImageMimeTypeFromFile } from "../utils/mime";
 import { ensureTool } from "../utils/tools-manager";
-import { runFd } from "./find";
+import { runRg } from "./grep";
 import { applyListLimit } from "./list-limit";
 import { LsTool } from "./ls";
 import type { OutputMeta } from "./output-meta";
@@ -164,18 +164,26 @@ async function listCandidateFiles(
 	signal?: AbortSignal,
 	notify?: (message: string) => void,
 ): Promise<{ files: string[]; truncated: boolean; error?: string }> {
-	let fdPath: string | undefined;
+	let rgPath: string | undefined;
 	try {
-		fdPath = await ensureTool("fd", { silent: true, notify });
+		rgPath = await ensureTool("rg", { silent: true, notify });
 	} catch {
-		return { files: [], truncated: false, error: "fd not available" };
+		return { files: [], truncated: false, error: "rg not available" };
 	}
 
-	if (!fdPath) {
-		return { files: [], truncated: false, error: "fd not available" };
+	if (!rgPath) {
+		return { files: [], truncated: false, error: "rg not available" };
 	}
 
-	const args: string[] = ["--type", "f", "--color=never", "--hidden", "--max-results", String(MAX_FUZZY_CANDIDATES)];
+	const args: string[] = [
+		"--files",
+		"--color=never",
+		"--hidden",
+		"--glob",
+		"!**/.git/**",
+		"--glob",
+		"!**/node_modules/**",
+	];
 
 	const gitignoreFiles = new Set<string>();
 	const rootGitignore = path.join(searchRoot, ".gitignore");
@@ -185,20 +193,19 @@ async function listCandidateFiles(
 
 	try {
 		const gitignoreArgs = [
-			"--type",
-			"f",
+			"--files",
 			"--color=never",
 			"--hidden",
-			"--absolute-path",
+			"--no-ignore",
+			"--glob",
+			"!**/.git/**",
+			"--glob",
+			"!**/node_modules/**",
 			"--glob",
 			".gitignore",
-			"--exclude",
-			"node_modules",
-			"--exclude",
-			".git",
 			searchRoot,
 		];
-		const { stdout } = await runFd(fdPath, gitignoreArgs, signal);
+		const { stdout } = await runRg(rgPath, gitignoreArgs, signal);
 		const output = stdout.trim();
 		if (output) {
 			const nestedGitignores = output
@@ -224,15 +231,15 @@ async function listCandidateFiles(
 		args.push("--ignore-file", gitignorePath);
 	}
 
-	args.push(".", searchRoot);
+	args.push(searchRoot);
 
-	const { stdout, stderr, exitCode } = await runFd(fdPath, args, signal);
+	const { stdout, stderr, exitCode } = await runRg(rgPath, args, signal);
 	const output = stdout.trim();
 
 	if (!output) {
-		// fd exit codes: 0 = found, 1 = no matches, other = error
+		// rg exit codes: 0 = ok, 1 = no matches, other = error
 		if (exitCode !== 0 && exitCode !== 1) {
-			return { files: [], truncated: false, error: stderr.trim() || `fd failed (exit ${exitCode})` };
+			return { files: [], truncated: false, error: stderr.trim() || `rg failed (exit ${exitCode})` };
 		}
 		return { files: [], truncated: false };
 	}
@@ -242,7 +249,10 @@ async function listCandidateFiles(
 		.map(line => line.replace(/\r$/, "").trim())
 		.filter(line => line.length > 0);
 
-	return { files, truncated: files.length >= MAX_FUZZY_CANDIDATES };
+	const truncated = files.length > MAX_FUZZY_CANDIDATES;
+	const limited = truncated ? files.slice(0, MAX_FUZZY_CANDIDATES) : files;
+
+	return { files: limited, truncated };
 }
 
 async function findReadPathSuggestions(

package/src/prompts/tools/enter-plan-mode.md

@@ -1,92 +0,0 @@
-Transitions to plan mode for designing implementation approaches before writing code.
-
-<conditions>
-Prefer using EnterPlanMode for implementation tasks unless they're simple. Use it when ANY of these conditions apply:
-1. **New Feature Implementation**: Adding meaningful new functionality
-   - Example: "Add a logout button" — where should it go? What should happen on click?
-   - Example: "Add form validation" — what rules? What error messages?
-2. **Multiple Valid Approaches**: The task can be solved in several different ways
-   - Example: "Add caching to the API" — could use Redis, in-memory, file-based, etc.
-   - Example: "Improve performance" — many optimization strategies possible
-3. **Code Modifications**: Changes that affect existing behavior or structure
-   - Example: "Update the login flow" — what exactly should change?
-   - Example: "Refactor this component" — what's the target architecture?
-4. **Architectural Decisions**: The task requires choosing between patterns or technologies
-   - Example: "Add real-time updates" — WebSockets vs SSE vs polling
-   - Example: "Implement state management" — Redux vs Context vs custom solution
-5. **Multi-File Changes**: The task will likely touch more than 2-3 files
-   - Example: "Refactor the authentication system"
-   - Example: "Add a new API endpoint with tests"
-6. **Unclear Requirements**: You need to explore before understanding the full scope
-   - Example: "Make the app faster" — need to profile and identify bottlenecks
-   - Example: "Fix the bug in checkout" — need to investigate root cause
-7. **User Preferences Matter**: The implementation could reasonably go multiple ways
-   - If you would use `ask` to clarify the approach, use EnterPlanMode instead
-   - Plan mode lets you explore first, then present options with context
-</conditions>
-
-<instruction>
-In plan mode:
-1. Explore codebase with `find`, `grep`, `read`, `ls`
-2. Understand existing patterns and architecture
-3. Design implementation approach
-4. Use `ask` if clarification needed
-5. Call `exit_plan_mode` when ready
-</instruction>
-
-<output>
-Requires user approval to enter. Once approved, you enter read-only exploration mode with restricted tool access.
-</output>
-
-<example name="auth">
-User: "Add user authentication to the app"
-→ Use plan mode: architectural decisions (session vs JWT, where to store tokens, middleware structure)
-</example>
-
-<example name="optimization">
-User: "Optimize the database queries"
-→ Use plan mode: multiple approaches possible, need to profile first, significant impact
-</example>
-
-<example name="dark-mode">
-User: "Implement dark mode"
-→ Use plan mode: architectural decision on theme system, affects many components
-</example>
-
-<example name="delete-button">
-User: "Add a delete button to the user profile"
-→ Use plan mode: seems simple but involves placement, confirmation dialog, API call, error handling, state updates
-</example>
-
-<example name="error-handling">
-User: "Update the error handling in the API"
-→ Use plan mode: affects multiple files, user should approve the approach
-</example>
-
-<example name="typo-skip">
-User: "Fix the typo in the README"
-→ Skip plan mode: straightforward, no planning needed
-</example>
-
-<example name="debug-skip">
-User: "Add a console.log to debug this function"
-→ Skip plan mode: simple, obvious implementation
-</example>
-
-<example name="research-skip">
-User: "What files handle routing?"
-→ Skip plan mode: research task, not implementation planning
-</example>
-
-<avoid>
-- Single-line or few-line fixes (typos, obvious bugs)
-- Adding a single function with clear requirements
-- Tasks with very specific, detailed instructions
-- Pure research/exploration tasks
-</avoid>
-
-<critical>
-- This tool REQUIRES user approval — they must consent to entering plan mode
-- If unsure whether to use it, err on the side of planning — alignment upfront beats rework
-- Users appreciate being consulted before significant changes are made to their codebase
-</critical>

package/src/tools/enter-plan-mode.ts

@@ -1,76 +0,0 @@
-import * as fs from "node:fs/promises";
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { isEnoent } from "@oh-my-pi/pi-utils";
-import { Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
-import { resolvePlanUrlToPath } from "../internal-urls";
-import enterPlanModeDescription from "../prompts/tools/enter-plan-mode.md" with { type: "text" };
-import type { ToolSession } from ".";
-import { ToolError } from "./tool-errors";
-
-const enterPlanModeSchema = Type.Object({
-	workflow: Type.Optional(Type.Union([Type.Literal("parallel"), Type.Literal("iterative")])),
-});
-
-export interface EnterPlanModeDetails {
-	planFilePath: string;
-	planExists: boolean;
-	workflow?: "parallel" | "iterative";
-}
-
-export class EnterPlanModeTool implements AgentTool<typeof enterPlanModeSchema, EnterPlanModeDetails> {
-	public readonly name = "enter_plan_mode";
-	public readonly label = "EnterPlanMode";
-	public readonly description: string;
-	public readonly parameters = enterPlanModeSchema;
-
-	private readonly session: ToolSession;
-
-	constructor(session: ToolSession) {
-		this.session = session;
-		this.description = renderPromptTemplate(enterPlanModeDescription);
-	}
-
-	public async execute(
-		_toolCallId: string,
-		params: { workflow?: "parallel" | "iterative" },
-		_signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<EnterPlanModeDetails>,
-		_context?: AgentToolContext,
-	): Promise<AgentToolResult<EnterPlanModeDetails>> {
-		const state = this.session.getPlanModeState?.();
-		if (state?.enabled) {
-			throw new ToolError("Plan mode is already active.");
-		}
-
-		const sessionId = this.session.getSessionId?.();
-		if (!sessionId) {
-			throw new ToolError("Plan mode requires an active session.");
-		}
-
-		const settingsManager = this.session.settingsManager;
-		if (!settingsManager) {
-			throw new ToolError("Settings manager unavailable for plan mode.");
-		}
-
-		const planFilePath = `plan://${sessionId}/plan.md`;
-		const resolvedPlanPath = resolvePlanUrlToPath(planFilePath, {
-			getPlansDirectory: settingsManager.getPlansDirectory.bind(settingsManager),
-			cwd: this.session.cwd,
-		});
-		let planExists = false;
-		try {
-			const stat = await fs.stat(resolvedPlanPath);
-			planExists = stat.isFile();
-		} catch (error) {
-			if (!isEnoent(error)) {
-				throw error;
-			}
-		}
-
-		return {
-			content: [{ type: "text", text: "Plan mode requested." }],
-			details: { planFilePath, planExists, workflow: params.workflow },
-		};
-	}
-}