@oh-my-pi/pi-coding-agent 14.9.8 → 15.0.0

package/src/session/client-bridge.ts

@@ -0,0 +1,81 @@
+/**
+ * ClientBridge — abstraction over capabilities provided by an external client
+ * (e.g. ACP editor host) that the agent can route through instead of operating
+ * directly on the local filesystem / spawning local subprocesses.
+ *
+ * When `undefined`, tools fall back to local IO. When populated (currently
+ * only by `AcpAgent`), tools route requests through the client so it can
+ * surface unsaved buffer state, render terminals in the IDE, or gate
+ * destructive operations behind user permission prompts.
+ */
+
+export interface ClientBridgeCapabilities {
+	/** Client implements `fs/read_text_file`. */
+	readTextFile?: boolean;
+	/** Client implements `fs/write_text_file`. */
+	writeTextFile?: boolean;
+	/** Client implements the `terminal/*` family. */
+	terminal?: boolean;
+	/** Client implements `session/request_permission`. */
+	requestPermission?: boolean;
+}
+
+export interface ClientBridgePermissionToolCall {
+	toolCallId: string;
+	toolName: string;
+	title: string;
+	kind?: string;
+	rawInput?: unknown;
+	locations?: { path: string; line?: number }[];
+}
+
+export type ClientBridgePermissionOptionKind = "allow_once" | "allow_always" | "reject_once" | "reject_always";
+
+export interface ClientBridgePermissionOption {
+	optionId: string;
+	name: string;
+	kind: ClientBridgePermissionOptionKind;
+}
+
+export type ClientBridgePermissionOutcome =
+	| { outcome: "cancelled" }
+	| { outcome: "selected"; optionId: string; kind?: ClientBridgePermissionOptionKind };
+
+export interface ClientBridgeTerminalExitStatus {
+	exitCode?: number | null;
+	signal?: string | null;
+}
+
+export interface ClientBridgeTerminalOutput {
+	output: string;
+	truncated: boolean;
+	exitStatus?: ClientBridgeTerminalExitStatus | null;
+}
+
+export interface ClientBridgeTerminalHandle {
+	terminalId: string;
+	waitForExit(): Promise<ClientBridgeTerminalExitStatus>;
+	currentOutput(): Promise<ClientBridgeTerminalOutput>;
+	kill(): Promise<void>;
+	release(): Promise<void>;
+}
+
+export interface ClientBridgeCreateTerminalParams {
+	command: string;
+	args?: string[];
+	env?: Array<{ name: string; value: string }>;
+	cwd?: string;
+	outputByteLimit?: number;
+}
+
+export interface ClientBridge {
+	readonly capabilities: ClientBridgeCapabilities;
+	readTextFile?(params: { path: string; line?: number; limit?: number }): Promise<string>;
+	writeTextFile?(params: { path: string; content: string }): Promise<void>;
+	createTerminal?(params: ClientBridgeCreateTerminalParams): Promise<ClientBridgeTerminalHandle>;
+	requestPermission?(
+		toolCall: ClientBridgePermissionToolCall,
+		options: ClientBridgePermissionOption[],
+		signal?: AbortSignal,
+	): Promise<ClientBridgePermissionOutcome>;
+}

package/src/session/compaction/errors.ts

@@ -0,0 +1,31 @@
+/**
+ * Compaction error types.
+ *
+ * `CompactionCancelledError` is the canonical signal raised when a compaction
+ * is explicitly aborted — operator Esc, extension hook returning `cancel`,
+ * programmatic `session.abortCompaction()` call, or any other deliberate
+ * abort source. Downstream callers (e.g. `executeCompaction`) discriminate
+ * cancellation from other failures via `instanceof CompactionCancelledError`
+ * rather than introspecting error messages or `name` fields — the typed
+ * sentinel makes classification source-agnostic and refactor-stable.
+ */
+
+export class CompactionCancelledError extends Error {
+	readonly name = "CompactionCancelledError" as const;
+
+	constructor(message = "Compaction cancelled") {
+		super(message);
+	}
+}
+
+/**
+ * Outcome of a compaction attempt, surfaced by `CommandController.executeCompaction`
+ * so callers (e.g. the plan-mode approval flow) can distinguish a deliberate abort
+ * from an unrelated failure.
+ *
+ *   "ok"        — compaction completed; transcript was summarized.
+ *   "cancelled" — `CompactionCancelledError` was raised. Operator Esc, extension
+ *                 hook, programmatic abort — all source-agnostic.
+ *   "failed"    — any other rejection from `session.compact()`.
+ */
+export type CompactionOutcome = "ok" | "cancelled" | "failed";

package/src/session/compaction/index.ts

@@ -4,4 +4,5 @@
 
 export * from "./branch-summarization";
 export * from "./compaction";
+export * from "./errors";
 export * from "./utils";

package/src/slash-commands/acp-builtins.ts

@@ -0,0 +1,46 @@
+import type { AvailableCommand } from "@agentclientprotocol/sdk";
+import { BUILTIN_SLASH_COMMANDS_INTERNAL, lookupBuiltinSlashCommand } from "./builtin-registry";
+import { parseSlashCommand } from "./helpers/parse";
+import type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./types";
+
+export type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./types";
+
+/**
+ * Commands advertised to ACP clients. Entries without a text-mode `handle`
+ * (e.g. `/quit`, `/login`, dashboards) are filtered out so the client doesn't
+ * see commands it cannot drive.
+ */
+export const ACP_BUILTIN_SLASH_COMMANDS: AvailableCommand[] = BUILTIN_SLASH_COMMANDS_INTERNAL.filter(
+	command => command.handle !== undefined,
+).map(command => {
+	// Honor mode-specific copy: ACP clients receive concise text-mode
+	// descriptions/hints when the spec sets `acpDescription` / `acpInputHint`,
+	// otherwise fall back to the unified `description` / `inlineHint`.
+	const hint = command.acpInputHint ?? command.inlineHint;
+	return {
+		name: command.name,
+		description: command.acpDescription ?? command.description,
+		input: hint ? { hint } : undefined,
+	};
+});
+
+/**
+ * Dispatch a slash command in ACP/text mode. Returns:
+ * - `false` when no builtin matched (or matched a TUI-only entry); the caller
+ *   should forward the input as a prompt.
+ * - `{ consumed: true }` when the command handled the input entirely.
+ * - `{ prompt }` when the command was handled but a residual prompt should be
+ *   sent to the model.
+ */
+export async function executeAcpBuiltinSlashCommand(
+	text: string,
+	runtime: AcpBuiltinCommandRuntime,
+): Promise<AcpBuiltinSlashCommandResult> {
+	const parsed = parseSlashCommand(text);
+	if (!parsed) return false;
+	const command = lookupBuiltinSlashCommand(parsed.name);
+	if (!command?.handle) return false;
+	const result = await command.handle(parsed, runtime);
+	if (result === undefined) return { consumed: true };
+	return result;
+}