pi-acp 0.0.31 → 0.0.33

package/README.md

@@ -38,7 +38,7 @@ npm install -g @earendil-works/pi-coding-agent
 ```
 
 - Node.js 22+
-- `pi` installed and available on your `PATH` (the adapter runs the `pi` executable)
+- `pi` v0.80.4+ installed and available on your `PATH` (the adapter runs the `pi` executable)
 - Configure `pi` separately for your model providers/API keys
 
 ## Install

package/dist/index.js

@@ -526,6 +526,52 @@ function expandSlashCommand(text, fileCommands) {
   return substituteArgs(cmd.content, args);
 }
 
+// src/acp/translate/bash.ts
+function isBashTool(toolName) {
+  return toolName.toLowerCase() === "bash";
+}
+function bashCommand(value) {
+  const record = value;
+  const command = record?.command ?? record?.cmd ?? record?.args?.command ?? record?.args?.cmd ?? record?.input?.command ?? record?.input?.cmd ?? record?.rawInput?.command ?? record?.rawInput?.cmd ?? record?.toolInput?.command ?? record?.toolInput?.cmd ?? record?.details?.command ?? record?.details?.cmd;
+  return typeof command === "string" && command.trim() ? command : void 0;
+}
+function bashResultText(result) {
+  const record = result;
+  const content = record?.content;
+  if (Array.isArray(content)) {
+    const texts = content.map((c) => {
+      const block = c;
+      return block.type === "text" && typeof block.text === "string" ? block.text : "";
+    }).filter(Boolean);
+    if (texts.length) return texts.join("");
+  }
+  const details = record?.details;
+  const stdout = (typeof details?.stdout === "string" ? details.stdout : void 0) ?? (typeof record?.stdout === "string" ? record.stdout : void 0) ?? (typeof details?.output === "string" ? details.output : void 0) ?? (typeof record?.output === "string" ? record.output : void 0);
+  const stderr = (typeof details?.stderr === "string" ? details.stderr : void 0) ?? (typeof record?.stderr === "string" ? record.stderr : void 0);
+  return [stdout, stderr].filter((part) => typeof part === "string" && part.length > 0).join("\n");
+}
+function bashExitCode(result, isError) {
+  const record = result;
+  const details = record?.details;
+  const exitCode = details?.exitCode ?? record?.exitCode ?? details?.code ?? record?.code;
+  return typeof exitCode === "number" ? exitCode : isError ? 1 : 0;
+}
+function bashOutputDelta(previous, next) {
+  return next.startsWith(previous) ? next.slice(previous.length) : next;
+}
+function bashTerminalContent(toolCallId) {
+  return [{ type: "terminal", terminalId: toolCallId }];
+}
+function bashTerminalInfoMeta(toolCallId, cwd) {
+  return { terminal_info: { terminal_id: toolCallId, cwd } };
+}
+function bashTerminalOutputMeta(toolCallId, data) {
+  return { terminal_output: { terminal_id: toolCallId, data } };
+}
+function bashTerminalExitMeta(toolCallId, exitCode) {
+  return { terminal_exit: { terminal_id: toolCallId, exit_code: exitCode, signal: null } };
+}
+
 // src/acp/translate/pi-tools.ts
 function toolResultToText(result) {
   if (!result) return "";
@@ -741,14 +787,17 @@ var PiAcpSession = class {
   // Some pi events can arrive out of order (e.g. late toolcall_* deltas after execution starts),
   // and clients may hide progress if we ever downgrade back to `pending`.
   currentToolCalls = /* @__PURE__ */ new Map();
-  // pi can emit multiple `turn_end` events for a single user prompt (e.g. after tool_use).
-  // The overall agent loop completes when `agent_end` is emitted.
+  // pi can emit multiple `turn_end` and `agent_end` events for a single user prompt
+  // when retry, compaction, or queued continuations run. The session-level prompt
+  // completes only when `agent_settled` is emitted.
   inAgentLoop = false;
   // For ACP diff support: capture file contents before edit/write mutations,
   // then emit ToolCallContent {type:"diff"}. Compatible structured edit/write
   // events may need to be implemented in pi in the future.
   fileSnapshots = /* @__PURE__ */ new Map();
   fileMutationToolCallIds = /* @__PURE__ */ new Set();
+  bashToolCallIds = /* @__PURE__ */ new Set();
+  bashOutputSnapshots = /* @__PURE__ */ new Map();
   // Ensure `session/update` notifications are sent in order and can be awaited
   // before completing a `session/prompt` request.
   lastEmit = Promise.resolve();
@@ -832,6 +881,41 @@ var PiAcpSession = class {
   async flushEmits() {
     await this.lastEmit;
   }
+  emitBashToolCall(params) {
+    this.bashToolCallIds.add(params.toolCallId);
+    this.emit({
+      sessionUpdate: params.sessionUpdate,
+      toolCallId: params.toolCallId,
+      title: bashCommand(params.args) ?? params.toolName,
+      kind: "execute",
+      status: params.status,
+      locations: params.locations,
+      ...params.includeTerminal ? { content: bashTerminalContent(params.toolCallId) } : {},
+      ...params.includeTerminal ? { _meta: bashTerminalInfoMeta(params.toolCallId, this.cwd) } : {}
+    });
+  }
+  emitBashOutputUpdate(params) {
+    const text = bashResultText(params.result);
+    const previous = this.bashOutputSnapshots.get(params.toolCallId) ?? "";
+    const delta = bashOutputDelta(previous, text);
+    this.bashOutputSnapshots.set(params.toolCallId, text);
+    this.emit({
+      sessionUpdate: "tool_call_update",
+      toolCallId: params.toolCallId,
+      status: params.status,
+      _meta: {
+        ...delta ? bashTerminalOutputMeta(params.toolCallId, delta) : {},
+        ...params.status === "completed" || params.status === "failed" ? bashTerminalExitMeta(params.toolCallId, bashExitCode(params.result, Boolean(params.isError))) : {}
+      }
+    });
+  }
+  cleanupToolCall(toolCallId) {
+    this.currentToolCalls.delete(toolCallId);
+    this.fileSnapshots.delete(toolCallId);
+    this.fileMutationToolCallIds.delete(toolCallId);
+    this.bashToolCallIds.delete(toolCallId);
+    this.bashOutputSnapshots.delete(toolCallId);
+  }
   startTurn(t) {
     this.cancelRequested = false;
     this.inAgentLoop = false;
@@ -899,7 +983,18 @@ var PiAcpSession = class {
             const locations = toToolCallLocations(rawInput, this.cwd);
             const existingStatus = this.currentToolCalls.get(toolCallId);
             const status = existingStatus ?? "pending";
-            if (!existingStatus) {
+            if (isBashTool(toolName)) {
+              if (!existingStatus) this.currentToolCalls.set(toolCallId, "pending");
+              this.emitBashToolCall({
+                sessionUpdate: existingStatus ? "tool_call_update" : "tool_call",
+                toolCallId,
+                toolName,
+                args: rawInput,
+                status,
+                locations,
+                includeTerminal: !existingStatus
+              });
+            } else if (!existingStatus) {
               this.currentToolCalls.set(toolCallId, "pending");
               this.emit({
                 sessionUpdate: "tool_call",
@@ -929,6 +1024,21 @@ var PiAcpSession = class {
         const toolName = String(ev.toolName ?? "tool");
         const args = ev.args;
         let line;
+        if (isBashTool(toolName)) {
+          const locations2 = toToolCallLocations(args, this.cwd);
+          const existingStatus = this.currentToolCalls.get(toolCallId);
+          this.currentToolCalls.set(toolCallId, "in_progress");
+          this.emitBashToolCall({
+            sessionUpdate: existingStatus ? "tool_call_update" : "tool_call",
+            toolCallId,
+            toolName,
+            args,
+            status: "in_progress",
+            locations: locations2,
+            includeTerminal: !existingStatus
+          });
+          break;
+        }
         const isFileMutation = toolName === "edit" || toolName === "write";
         let snapshotOldText;
         if (isFileMutation) {
@@ -979,6 +1089,10 @@ var PiAcpSession = class {
         const toolCallId = String(ev.toolCallId ?? "");
         if (!toolCallId) break;
         const partial = ev.partialResult;
+        if (this.bashToolCallIds.has(toolCallId)) {
+          this.emitBashOutputUpdate({ toolCallId, status: "in_progress", result: partial });
+          break;
+        }
         const text = this.fileMutationToolCallIds.has(toolCallId) ? "" : toolResultToText(partial);
         this.emit({
           sessionUpdate: "tool_call_update",
@@ -994,6 +1108,16 @@ var PiAcpSession = class {
         if (!toolCallId) break;
         const result = ev.result;
         const isError = Boolean(ev.isError);
+        if (this.bashToolCallIds.has(toolCallId)) {
+          this.emitBashOutputUpdate({
+            toolCallId,
+            status: isError ? "failed" : "completed",
+            result,
+            isError
+          });
+          this.cleanupToolCall(toolCallId);
+          break;
+        }
         const text = toolResultToText(result);
         const snapshot = this.fileSnapshots.get(toolCallId);
         let content;
@@ -1026,9 +1150,7 @@ var PiAcpSession = class {
           content,
           ...hasStructuredDiff ? {} : { rawOutput: result }
         });
-        this.currentToolCalls.delete(toolCallId);
-        this.fileSnapshots.delete(toolCallId);
-        this.fileMutationToolCallIds.delete(toolCallId);
+        this.cleanupToolCall(toolCallId);
         break;
       }
       case "extension_ui_request": {
@@ -1084,6 +1206,10 @@ var PiAcpSession = class {
         break;
       }
       case "agent_end": {
+        this.inAgentLoop = false;
+        break;
+      }
+      case "agent_settled": {
         void this.flushEmits().finally(() => {
           const reason = this.cancelRequested ? "cancelled" : "end_turn";
           this.pendingTurn?.resolve(reason);
@@ -1137,7 +1263,8 @@ var PiAcpSession = class {
     if (method === "notify") {
       this.emit({
         sessionUpdate: "agent_message_chunk",
-        content: { type: "text", text: stringProp(ev, "message") ?? "Pi notification" }
+        content: { type: "text", text: stringProp(ev, "message") ?? "Pi notification" },
+        _meta: { piAcp: { notify: { level: stringProp(ev, "notifyType") ?? "info" } } }
       });
       await this.proc.sendExtensionUiResponse({ id, cancelled: true });
       return;
@@ -1238,7 +1365,7 @@ function toToolKind(toolName) {
     case "edit":
       return "edit";
     case "bash":
-      return "other";
+      return "execute";
     default:
       return "other";
   }
@@ -1815,7 +1942,8 @@ var PiAcpAgent = class {
         sessionCapabilities: {
           // **UNSTABLE** ACP capability used by Zed's codex-acp adapter.
           // Enables a native session picker in clients that support it.
-          list: {}
+          list: {},
+          delete: {}
         }
       }
     };
@@ -2384,6 +2512,35 @@ ${JSON.stringify(stats, null, 2)}`;
         const toolName = String(m?.toolName ?? "tool");
         const toolCallId = String(m?.toolCallId ?? crypto.randomUUID());
         const isError = Boolean(m?.isError);
+        const isBash = isBashTool(toolName);
+        if (isBash) {
+          const text2 = bashResultText(m);
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "tool_call",
+              toolCallId,
+              title: bashCommand(m) ?? toolName,
+              kind: "execute",
+              status: "completed",
+              content: bashTerminalContent(toolCallId),
+              _meta: bashTerminalInfoMeta(toolCallId, params.cwd)
+            }
+          });
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "tool_call_update",
+              toolCallId,
+              status: isError ? "failed" : "completed",
+              _meta: {
+                ...text2 ? bashTerminalOutputMeta(toolCallId, text2) : {},
+                ...bashTerminalExitMeta(toolCallId, bashExitCode(m, isError))
+              }
+            }
+          });
+          continue;
+        }
         await this.conn.sessionUpdate({
           sessionId: session.sessionId,
           update: {
@@ -2449,6 +2606,22 @@ ${JSON.stringify(stats, null, 2)}`;
     }, 0);
     return response;
   }
+  async deleteSession(params) {
+    const stored = this.store.get(params.sessionId);
+    const piSession = findPiSession(params.sessionId);
+    if (!stored && !piSession) {
+      return {};
+    }
+    const sessionFile = stored?.sessionFile ?? piSession?.sessionFile;
+    if (sessionFile) {
+      try {
+        if (existsSync4(sessionFile)) unlinkSync(sessionFile);
+      } catch {
+      }
+    }
+    this.store.delete(params.sessionId);
+    return {};
+  }
   async unstable_setSessionModel(params) {
     const session = await this.restoreSession(params.sessionId);
     await setSessionModel(session.proc, params.modelId);
@@ -2764,20 +2937,22 @@ function buildStartupInfo(opts) {
     for (const f of exts) extItems.push(join5(extDir, f));
   } catch {
   }
-  try {
-    const settingsPath = join5(process.env.HOME ?? "", ".pi", "agent", "settings.json");
-    const settings = JSON.parse(readFileSync6(settingsPath, "utf-8"));
-    const pkgs = Array.isArray(settings?.packages) ? settings.packages : [];
-    for (const pkg2 of pkgs) {
-      const s = String(pkg2);
-      if (s.startsWith("npm:")) {
-        extItems.push(`${s}
+  const settingsPaths = [join5(getAgentDir(), "settings.json"), join5(opts.cwd, ".pi", "settings.json")];
+  for (const settingsPath of settingsPaths) {
+    try {
+      const settings = JSON.parse(readFileSync6(settingsPath, "utf-8"));
+      const pkgs = Array.isArray(settings?.packages) ? settings.packages : [];
+      for (const pkg2 of pkgs) {
+        const s = String(pkg2);
+        if (s.startsWith("npm:")) {
+          extItems.push(`${s}
   - index.ts`);
-      } else {
-        extItems.push(s);
+        } else {
+          extItems.push(s);
+        }
       }
+    } catch {
     }
-  } catch {
   }
   addSection("Extensions", extItems);
   if (opts.updateNotice) {