@oh-my-pi/pi-coding-agent 14.4.1 → 14.4.4

package/src/tools/grep.ts

@@ -6,13 +6,11 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { type ChunkedGrepMatch, describeChunkedGrepMatch } from "../edit/modes/chunk";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
+import type { Theme } from "../modes/theme/theme";
 import grepDescription from "../prompts/tools/grep.md" with { type: "text" };
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead } from "../session/streaming-output";
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
-import { resolveEditMode } from "../utils/edit-mode";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
 import { createFileRecorder } from "./file-recorder";
@@ -83,7 +81,6 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 		this.description = prompt.render(grepDescription, {
 			IS_HASHLINE_MODE: displayMode.hashLines,
 			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
-			IS_CHUNK_MODE: displayMode.chunked,
 		});
 	}
 
@@ -98,7 +95,6 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 
 		return untilAborted(signal, async () => {
 			const normalizedPattern = pattern.trim();
-			const chunkMode = resolveEditMode(this.session) === "chunk";
 			if (!normalizedPattern) {
 				throw new ToolError("Pattern must not be empty");
 			}
@@ -297,124 +293,6 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				}
 				matchesByFile.get(relativePath)!.push(match);
 			}
-			if (chunkMode) {
-				const annotatedMatches = await Promise.all(
-					selectedMatches.map(match => {
-						const relativePath = match.path.startsWith("/") ? match.path.slice(1) : match.path;
-						const absoluteFilePath = isDirectory ? path.join(searchPath, relativePath) : searchPath;
-						return describeChunkedGrepMatch({
-							filePath: absoluteFilePath,
-							lineNumber: match.lineNumber,
-							line: match.line,
-							cwd: this.session.cwd,
-							language: getLanguageFromPath(absoluteFilePath),
-						});
-					}),
-				);
-				const chunkMatchesByFile = new Map<string, ChunkedGrepMatch[]>();
-				for (const match of annotatedMatches) {
-					recordFile(match.displayPath);
-					if (!chunkMatchesByFile.has(match.displayPath)) {
-						chunkMatchesByFile.set(match.displayPath, []);
-					}
-					chunkMatchesByFile.get(match.displayPath)!.push(match);
-				}
-				const renderChunkedMatchesForFile = (relativePath: string): string[] => {
-					const renderedLines: string[] = [];
-					const fileMatches = chunkMatchesByFile.get(relativePath) ?? [];
-					if (fileMatches.length === 0) {
-						return renderedLines;
-					}
-					const matchesByChunk = new Map<string, ChunkedGrepMatch[]>();
-					for (const match of fileMatches) {
-						const chunkKey = match.chunkPath ?? "";
-						if (!matchesByChunk.has(chunkKey)) {
-							matchesByChunk.set(chunkKey, []);
-						}
-						matchesByChunk.get(chunkKey)!.push(match);
-					}
-					for (const [chunkPath, chunkMatches] of matchesByChunk) {
-						if (chunkPath) {
-							const chunkChecksum = chunkMatches[0]?.chunkChecksum;
-							const dashes = "-".repeat(chunkPath.split(".").length - 1);
-							const anchor = chunkChecksum
-								? `${dashes}@${chunkPath}#${chunkChecksum}`
-								: `${dashes}@${chunkPath}`;
-							renderedLines.push(anchor);
-						}
-						for (const match of chunkMatches) {
-							renderedLines.push(`    ${match.lineNumber}|${match.line}`);
-							fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
-						}
-					}
-					return renderedLines;
-				};
-				if (isDirectory) {
-					const filesByDirectory = new Map<string, string[]>();
-					for (const relativePath of fileList) {
-						const directory = path.dirname(relativePath).replace(/\\/g, "/");
-						if (!filesByDirectory.has(directory)) {
-							filesByDirectory.set(directory, []);
-						}
-						filesByDirectory.get(directory)!.push(relativePath);
-					}
-					for (const [directory, directoryFiles] of filesByDirectory) {
-						if (directory === ".") {
-							for (const relativePath of directoryFiles) {
-								const renderedLines = renderChunkedMatchesForFile(relativePath);
-								if (renderedLines.length === 0) continue;
-								if (outputLines.length > 0) {
-									outputLines.push("");
-								}
-								outputLines.push(`# ${path.basename(relativePath)}`);
-								outputLines.push(...renderedLines);
-							}
-							continue;
-						}
-						const renderedFiles = directoryFiles
-							.map(relativePath => ({ relativePath, lines: renderChunkedMatchesForFile(relativePath) }))
-							.filter(file => file.lines.length > 0);
-						if (renderedFiles.length === 0) continue;
-						if (outputLines.length > 0) {
-							outputLines.push("");
-						}
-						outputLines.push(`# ${directory}`);
-						for (const { relativePath, lines } of renderedFiles) {
-							outputLines.push(`## └─ ${path.basename(relativePath)}`);
-							outputLines.push(...lines);
-						}
-					}
-				} else {
-					for (const relativePath of fileList) {
-						outputLines.push(...renderChunkedMatchesForFile(relativePath));
-					}
-				}
-				if (matchLimitReached || result.limitReached) {
-					outputLines.push("", limitMessage);
-				}
-				const rawOutput = outputLines.join("\n");
-				const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
-				const truncated = Boolean(matchLimitReached || result.limitReached || truncation.truncated);
-				const details: GrepToolDetails = {
-					scopePath,
-					matchCount: selectedMatches.length,
-					fileCount: fileList.length,
-					files: fileList,
-					fileMatches: fileList.map(path => ({
-						path,
-						count: fileMatchCounts.get(path) ?? 0,
-					})),
-					truncated,
-					matchLimitReached: matchLimitReached ? effectiveLimit : undefined,
-					resultLimitReached: result.limitReached ? internalLimit : undefined,
-				};
-				if (truncation.truncated) details.truncation = truncation;
-				const resultBuilder = toolResult(details).text(truncation.content);
-				if (truncation.truncated) {
-					resultBuilder.truncation(truncation, { direction: "head" });
-				}
-				return resultBuilder.done();
-			}
 			const displayLines: string[] = [];
 			const renderMatchesForFile = (relativePath: string): { model: string[]; display: string[] } => {
 				const modelOut: string[] = [];
@@ -502,7 +380,9 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				}
 			}
 			if (hasContextLines && outputLines.length > 0) {
-				outputLines.unshift("[grep] match lines use '>'; context lines use ':'.");
+				outputLines.unshift(
+					"[grep] '*' marks match lines; leading space marks context. Anchor and content are separated by '|'.",
+				);
 			}
 			if (matchLimitReached || result.limitReached) {
 				outputLines.push("", limitMessage);

package/src/tools/index.ts

@@ -12,6 +12,7 @@ import { checkPythonKernelAvailability } from "../ipy/kernel";
 import { LspTool } from "../lsp";
 import type { DiscoverableMCPSearchIndex, DiscoverableMCPTool } from "../mcp/discoverable-tool-metadata";
 import type { PlanModeState } from "../plan-mode/state";
+import type { AgentRegistry } from "../registry/agent-registry";
 import type { CustomMessage } from "../session/messages";
 import type { ToolChoiceQueue } from "../session/tool-choice-queue";
 import { TaskTool } from "../task";
@@ -24,7 +25,6 @@ import { AstGrepTool } from "./ast-grep";
 import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
 import { CalculatorTool } from "./calculator";
-import { CancelJobTool } from "./cancel-job";
 import { type CheckpointState, CheckpointTool, RewindTool } from "./checkpoint";
 import { DebugTool } from "./debug";
 import { ExitPlanModeTool } from "./exit-plan-mode";
@@ -32,9 +32,10 @@ import { FindTool } from "./find";
 import { GithubTool } from "./gh";
 import { GrepTool } from "./grep";
 import { InspectImageTool } from "./inspect-image";
+import { IrcTool } from "./irc";
+import { JobTool } from "./job";
 import { NotebookTool } from "./notebook";
 import { wrapToolWithMetaNotice } from "./output-meta";
-import { PollTool } from "./poll-tool";
 import { PythonTool } from "./python";
 import { ReadTool } from "./read";
 import { RenderMermaidTool } from "./render-mermaid";
@@ -62,7 +63,6 @@ export * from "./ast-grep";
 export * from "./bash";
 export * from "./browser";
 export * from "./calculator";
-export * from "./cancel-job";
 export * from "./checkpoint";
 export * from "./debug";
 export * from "./exit-plan-mode";
@@ -71,8 +71,9 @@ export * from "./gh";
 export * from "./grep";
 export * from "./image-gen";
 export * from "./inspect-image";
+export * from "./irc";
+export * from "./job";
 export * from "./notebook";
-export * from "./poll-tool";
 export * from "./python";
 export * from "./read";
 export * from "./render-mermaid";
@@ -135,6 +136,10 @@ export interface ToolSession {
 	trackPythonExecution?<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
 	/** Get session ID */
 	getSessionId?: () => string | null;
+	/** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
+	getAgentId?: () => string | null;
+	/** Agent registry for IRC routing across live sessions. */
+	agentRegistry?: AgentRegistry;
 	/** Get artifacts directory for artifact:// URLs */
 	getArtifactsDir?: () => string | null;
 	/** Allocate a new artifact path and ID for session-scoped truncated output. */
@@ -218,8 +223,8 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	checkpoint: CheckpointTool.createIf,
 	rewind: RewindTool.createIf,
 	task: TaskTool.create,
-	cancel_job: CancelJobTool.createIf,
-	poll: PollTool.createIf,
+	job: JobTool.createIf,
+	irc: IrcTool.createIf,
 	todo_write: s => new TodoWriteTool(s),
 	web_search: s => new SearchTool(s),
 	search_tool_bm25: SearchToolBm25Tool.createIf,
@@ -386,6 +391,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "calc") return session.settings.get("calc.enabled");
 		if (name === "browser") return session.settings.get("browser.enabled");
 		if (name === "checkpoint" || name === "rewind") return session.settings.get("checkpoint.enabled");
+		if (name === "irc") return session.settings.get("irc.enabled");
 		if (name === "task") {
 			const maxDepth = session.settings.get("task.maxRecursionDepth") ?? 2;
 			const currentDepth = session.taskDepth ?? 0;

package/src/tools/irc.ts

@@ -0,0 +1,258 @@
+/**
+ * IRC tool — agent-to-agent messaging.
+ *
+ * Lets any live agent send a short prose message to any other live agent in
+ * this process and (optionally) get a prose reply.
+ *
+ * Routing happens via the global AgentRegistry. Replies are produced by an
+ * ephemeral side-channel call (`AgentSession.respondAsBackground`) that
+ * mirrors `/btw`: the recipient's current model, system prompt, and message
+ * history are used to compute a reply without persisting it through the
+ * normal stream path. After the reply is generated, both the incoming
+ * message and the auto-reply are queued for injection into the recipient's
+ * persisted history (deferred until the recipient is idle), so the model
+ * sees the exchange on its next turn.
+ *
+ * This avoids the deadlock that arises when the recipient is blocked on a
+ * long-running tool call: the side-channel call does not depend on the
+ * recipient's main agent loop being free.
+ */
+
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { prompt } from "@oh-my-pi/pi-utils";
+import { type Static, Type } from "@sinclair/typebox";
+import ircDescription from "../prompts/tools/irc.md" with { type: "text" };
+import type { AgentRef, AgentRegistry } from "../registry/agent-registry";
+import type { ToolSession } from ".";
+
+const ircSchema = Type.Object({
+	op: Type.Union(
+		[
+			Type.Literal("send", { description: "Send a message to one peer or to all peers" }),
+			Type.Literal("list", { description: "List currently visible peers" }),
+		],
+		{ description: "IRC operation" },
+	),
+	to: Type.Optional(
+		Type.String({
+			description: 'Recipient agent id (e.g. "0-Main", "0-AuthLoader") or "all" to broadcast',
+			examples: ["0-Main", "all"],
+		}),
+	),
+	message: Type.Optional(
+		Type.String({
+			description: "Message body to deliver",
+			examples: ["Should we use JWT or session cookies?"],
+		}),
+	),
+	awaitReply: Type.Optional(
+		Type.Boolean({
+			description: "Wait for the recipient's prose reply (default: true for DM, false for broadcast)",
+		}),
+	),
+});
+
+type IrcParams = Static<typeof ircSchema>;
+
+interface IrcReply {
+	from: string;
+	text: string;
+}
+
+export interface IrcDetails {
+	op: "send" | "list";
+	from?: string;
+	to?: string;
+	delivered?: string[];
+	replies?: IrcReply[];
+	failed?: Array<{ id: string; error: string }>;
+	notFound?: string[];
+	peers?: Array<{ id: string; displayName: string; kind: string; status: string; parentId?: string }>;
+	channels?: string[];
+}
+
+export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
+	readonly name = "irc";
+	readonly label = "IRC";
+	readonly description: string;
+	readonly parameters = ircSchema;
+	readonly strict = true;
+
+	constructor(private readonly session: ToolSession) {
+		this.description = prompt.render(ircDescription);
+	}
+
+	static createIf(session: ToolSession): IrcTool | null {
+		if (!session.settings.get("irc.enabled")) return null;
+		if (!session.agentRegistry || !session.getAgentId) return null;
+		return new IrcTool(session);
+	}
+
+	async execute(
+		_toolCallId: string,
+		params: IrcParams,
+		signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<IrcDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<IrcDetails>> {
+		const registry = this.session.agentRegistry;
+		const senderId = this.session.getAgentId?.() ?? null;
+		if (!registry) {
+			return errorResult("IRC is unavailable in this session.", { op: params.op });
+		}
+		if (!senderId) {
+			return errorResult("IRC is unavailable: caller has no agent id.", { op: params.op });
+		}
+
+		if (params.op === "list") {
+			return this.#executeList(registry, senderId);
+		}
+		if (params.op === "send") {
+			return this.#executeSend(registry, senderId, params, signal);
+		}
+		return errorResult("Unknown irc op.", { op: params.op as "send" | "list" });
+	}
+
+	#executeList(registry: AgentRegistry, senderId: string): AgentToolResult<IrcDetails> {
+		const peers = registry.listVisibleTo(senderId);
+		const lines: string[] = [];
+		if (peers.length === 0) {
+			lines.push("No other live agents.");
+		} else {
+			lines.push(`${peers.length} peer(s):`);
+			for (const peer of peers) {
+				lines.push(`- ${peer.id} [${peer.displayName} · ${peer.kind} · ${peer.status}]`);
+			}
+		}
+		const channels = ["all", ...peers.map(p => p.id)];
+		return {
+			content: [{ type: "text", text: lines.join("\n") }],
+			details: {
+				op: "list",
+				from: senderId,
+				peers: peers.map(p => ({
+					id: p.id,
+					displayName: p.displayName,
+					kind: p.kind,
+					status: p.status,
+					parentId: p.parentId,
+				})),
+				channels,
+			},
+		};
+	}
+
+	async #executeSend(
+		registry: AgentRegistry,
+		senderId: string,
+		params: IrcParams,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<IrcDetails>> {
+		const to = params.to?.trim();
+		const message = params.message?.trim();
+		if (!to) {
+			return errorResult('`to` is required for op="send".', { op: "send", from: senderId });
+		}
+		if (!message) {
+			return errorResult('`message` is required for op="send".', { op: "send", from: senderId });
+		}
+
+		// Resolve target peers.
+		let targets: AgentRef[];
+		const notFound: string[] = [];
+		const isBroadcast = to === "all";
+		if (isBroadcast) {
+			targets = registry.listVisibleTo(senderId);
+		} else {
+			const ref = registry.get(to);
+			if (!ref || ref.id === senderId) {
+				notFound.push(to);
+				targets = [];
+			} else if (ref.status !== "running" && ref.status !== "idle") {
+				notFound.push(to);
+				targets = [];
+			} else {
+				targets = [ref];
+			}
+		}
+
+		const awaitReply = params.awaitReply ?? !isBroadcast;
+
+		const delivered: string[] = [];
+		const replies: IrcReply[] = [];
+		const failed: Array<{ id: string; error: string }> = [];
+
+		// Dispatch to each target in parallel via the recipient's ephemeral
+		// side-channel. Independent calls so a slow recipient cannot stall the
+		// others. The recipient's main loop never has to be unblocked: the
+		// side-channel runs alongside any in-flight tool call.
+		const dispatches = targets.map(async target => {
+			const targetSession = target.session;
+			if (!targetSession) {
+				notFound.push(target.id);
+				return;
+			}
+			try {
+				const result = await targetSession.respondAsBackground({
+					from: senderId,
+					message,
+					awaitReply,
+					signal,
+				});
+				delivered.push(target.id);
+				if (awaitReply && result.replyText) {
+					replies.push({ from: target.id, text: result.replyText });
+				}
+			} catch (err) {
+				failed.push({ id: target.id, error: err instanceof Error ? err.message : String(err) });
+			}
+		});
+		await Promise.all(dispatches);
+
+		const lines: string[] = [];
+		if (delivered.length === 0) {
+			lines.push("No recipients received the message.");
+		} else {
+			lines.push(`Delivered to ${delivered.length} peer(s): ${delivered.join(", ")}`);
+		}
+		if (replies.length > 0) {
+			lines.push("");
+			lines.push("## Replies");
+			for (const reply of replies) {
+				lines.push(`### ${reply.from}`);
+				lines.push(reply.text);
+			}
+		}
+		if (failed.length > 0) {
+			lines.push("");
+			lines.push("## Failed");
+			for (const f of failed) {
+				lines.push(`- ${f.id}: ${f.error}`);
+			}
+		}
+		if (notFound.length > 0) {
+			lines.push("");
+			lines.push(`Unknown / unavailable peers: ${notFound.join(", ")}`);
+		}
+
+		return {
+			content: [{ type: "text", text: lines.join("\n") }],
+			details: {
+				op: "send",
+				from: senderId,
+				to,
+				delivered,
+				...(replies.length > 0 ? { replies } : {}),
+				...(failed.length > 0 ? { failed } : {}),
+				...(notFound.length > 0 ? { notFound } : {}),
+			},
+		};
+	}
+}
+
+function errorResult(text: string, details: IrcDetails): AgentToolResult<IrcDetails> {
+	return {
+		content: [{ type: "text", text }],
+		details,
+	};
+}