pi-acp 0.0.9

package/dist/index.js

@@ -0,0 +1,1415 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+
+// src/acp/agent.ts
+import {
+  RequestError as RequestError2
+} from "@agentclientprotocol/sdk";
+
+// src/acp/session.ts
+import { RequestError } from "@agentclientprotocol/sdk";
+import { readFileSync as readFileSync3 } from "fs";
+import { isAbsolute, resolve as resolvePath } from "path";
+
+// src/pi-rpc/process.ts
+import { spawn } from "child_process";
+import * as readline from "readline";
+var PiRpcProcess = class _PiRpcProcess {
+  child;
+  pending = /* @__PURE__ */ new Map();
+  eventHandlers = [];
+  constructor(child) {
+    this.child = child;
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (msg?.type === "response") {
+        const id = typeof msg.id === "string" ? msg.id : void 0;
+        if (id) {
+          const pending = this.pending.get(id);
+          if (pending) {
+            this.pending.delete(id);
+            pending.resolve(msg);
+            return;
+          }
+        }
+      }
+      for (const h of this.eventHandlers) h(msg);
+    });
+    child.on("exit", (code, signal) => {
+      const err = new Error(`pi process exited (code=${code}, signal=${signal})`);
+      for (const [, p] of this.pending) p.reject(err);
+      this.pending.clear();
+    });
+  }
+  static async spawn(params) {
+    const cmd = params.piCommand ?? "pi";
+    const args = ["--mode", "rpc"];
+    if (params.sessionPath) args.push("--session", params.sessionPath);
+    const child = spawn(cmd, args, {
+      cwd: params.cwd,
+      stdio: "pipe",
+      env: process.env
+    });
+    child.stderr.on("data", () => {
+    });
+    const proc = new _PiRpcProcess(child);
+    try {
+      const state = await proc.getState();
+      const sessionFile = typeof state?.sessionFile === "string" ? state.sessionFile : null;
+      if (sessionFile) {
+        const { mkdirSync: mkdirSync2 } = await import("fs");
+        const { dirname: dirname3 } = await import("path");
+        mkdirSync2(dirname3(sessionFile), { recursive: true });
+      }
+    } catch {
+    }
+    return proc;
+  }
+  onEvent(handler) {
+    this.eventHandlers.push(handler);
+    return () => {
+      this.eventHandlers = this.eventHandlers.filter((h) => h !== handler);
+    };
+  }
+  async prompt(message, attachments = []) {
+    const res = await this.request({ type: "prompt", message, attachments });
+    if (!res.success) throw new Error(`pi prompt failed: ${res.error ?? JSON.stringify(res.data)}`);
+  }
+  async abort() {
+    const res = await this.request({ type: "abort" });
+    if (!res.success) throw new Error(`pi abort failed: ${res.error ?? JSON.stringify(res.data)}`);
+  }
+  async getState() {
+    const res = await this.request({ type: "get_state" });
+    if (!res.success) throw new Error(`pi get_state failed: ${res.error ?? JSON.stringify(res.data)}`);
+    return res.data;
+  }
+  async getAvailableModels() {
+    const res = await this.request({ type: "get_available_models" });
+    if (!res.success) throw new Error(`pi get_available_models failed: ${res.error ?? JSON.stringify(res.data)}`);
+    return res.data;
+  }
+  async setModel(provider, modelId) {
+    const res = await this.request({ type: "set_model", provider, modelId });
+    if (!res.success) throw new Error(`pi set_model failed: ${res.error ?? JSON.stringify(res.data)}`);
+    return res.data;
+  }
+  async setThinkingLevel(level) {
+    const res = await this.request({ type: "set_thinking_level", level });
+    if (!res.success) throw new Error(`pi set_thinking_level failed: ${res.error ?? JSON.stringify(res.data)}`);
+  }
+  async setQueueMode(mode) {
+    const res = await this.request({ type: "set_queue_mode", mode });
+    if (!res.success) throw new Error(`pi set_queue_mode failed: ${res.error ?? JSON.stringify(res.data)}`);
+  }
+  async compact(customInstructions) {
+    const res = await this.request({ type: "compact", customInstructions });
+    if (!res.success) throw new Error(`pi compact failed: ${res.error ?? JSON.stringify(res.data)}`);
+    return res.data;
+  }
+  async setAutoCompaction(enabled) {
+    const res = await this.request({ type: "set_auto_compaction", enabled });
+    if (!res.success) throw new Error(`pi set_auto_compaction failed: ${res.error ?? JSON.stringify(res.data)}`);
+  }
+  async getSessionStats() {
+    const res = await this.request({ type: "get_session_stats" });
+    if (!res.success) throw new Error(`pi get_session_stats failed: ${res.error ?? JSON.stringify(res.data)}`);
+    return res.data;
+  }
+  async exportHtml(outputPath) {
+    const res = await this.request({ type: "export_html", outputPath });
+    if (!res.success) throw new Error(`pi export_html failed: ${res.error ?? JSON.stringify(res.data)}`);
+    const data = res.data;
+    return { path: String(data?.path ?? "") };
+  }
+  async switchSession(sessionPath) {
+    const res = await this.request({ type: "switch_session", sessionPath });
+    if (!res.success) throw new Error(`pi switch_session failed: ${res.error ?? JSON.stringify(res.data)}`);
+  }
+  async getMessages() {
+    const res = await this.request({ type: "get_messages" });
+    if (!res.success) throw new Error(`pi get_messages failed: ${res.error ?? JSON.stringify(res.data)}`);
+    return res.data;
+  }
+  request(cmd) {
+    const id = crypto.randomUUID();
+    const withId = { ...cmd, id };
+    const line = JSON.stringify(withId) + "\n";
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id, { resolve: resolve2, reject });
+      this.child.stdin.write(line, (err) => {
+        if (err) {
+          this.pending.delete(id);
+          reject(err);
+        }
+      });
+    });
+  }
+};
+
+// src/acp/session-store.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+
+// src/acp/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function getPiAcpDir() {
+  return join(homedir(), ".pi", "pi-acp");
+}
+function getPiAcpSessionMapPath() {
+  return join(getPiAcpDir(), "session-map.json");
+}
+
+// src/acp/session-store.ts
+function ensureParentDir(path) {
+  mkdirSync(dirname(path), { recursive: true });
+}
+function loadFile(path) {
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || typeof parsed.sessions !== "object" || !parsed.sessions) {
+      return { version: 1, sessions: {} };
+    }
+    return parsed;
+  } catch {
+    return { version: 1, sessions: {} };
+  }
+}
+function saveFile(path, data) {
+  ensureParentDir(path);
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+var SessionStore = class {
+  path;
+  constructor(path = getPiAcpSessionMapPath()) {
+    this.path = path;
+  }
+  get(sessionId) {
+    const db = loadFile(this.path);
+    return db.sessions[sessionId] ?? null;
+  }
+  upsert(entry) {
+    const db = loadFile(this.path);
+    db.sessions[entry.sessionId] = {
+      sessionId: entry.sessionId,
+      cwd: entry.cwd,
+      sessionFile: entry.sessionFile,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    saveFile(this.path, db);
+  }
+};
+
+// src/acp/translate/pi-tools.ts
+function toolResultToText(result) {
+  if (!result) return "";
+  const content = result.content;
+  if (Array.isArray(content)) {
+    const texts = content.map((c) => c?.type === "text" && typeof c.text === "string" ? c.text : "").filter(Boolean);
+    if (texts.length) return texts.join("");
+  }
+  const details = result?.details;
+  const diff = details?.diff;
+  if (typeof diff === "string" && diff.trim()) {
+    return diff;
+  }
+  const stdout = (typeof details?.stdout === "string" ? details.stdout : void 0) ?? (typeof result?.stdout === "string" ? result.stdout : void 0) ?? (typeof details?.output === "string" ? details.output : void 0) ?? (typeof result?.output === "string" ? result.output : void 0);
+  const stderr = (typeof details?.stderr === "string" ? details.stderr : void 0) ?? (typeof result?.stderr === "string" ? result.stderr : void 0);
+  const exitCode = (typeof details?.exitCode === "number" ? details.exitCode : void 0) ?? (typeof result?.exitCode === "number" ? result.exitCode : void 0) ?? (typeof details?.code === "number" ? details.code : void 0) ?? (typeof result?.code === "number" ? result.code : void 0);
+  if (typeof stdout === "string" && stdout.trim() || typeof stderr === "string" && stderr.trim()) {
+    const parts = [];
+    if (typeof stdout === "string" && stdout.trim()) parts.push(stdout);
+    if (typeof stderr === "string" && stderr.trim()) parts.push(`stderr:
+${stderr}`);
+    if (typeof exitCode === "number") parts.push(`exit code: ${exitCode}`);
+    return parts.join("\n\n").trimEnd();
+  }
+  try {
+    return JSON.stringify(result, null, 2);
+  } catch {
+    return String(result);
+  }
+}
+
+// src/acp/slash-commands.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, resolve } from "path";
+function parseFrontmatter(content) {
+  const frontmatter = {};
+  if (!content.startsWith("---")) return { frontmatter, content };
+  const endIndex = content.indexOf("\n---", 3);
+  if (endIndex === -1) return { frontmatter, content };
+  const frontmatterBlock = content.slice(4, endIndex);
+  const remaining = content.slice(endIndex + 4).trim();
+  for (const line of frontmatterBlock.split("\n")) {
+    const match = line.match(/^(\w+):\s*(.*)$/);
+    if (match) frontmatter[match[1]] = match[2].trim();
+  }
+  return { frontmatter, content: remaining };
+}
+function loadCommandsFromDir(dir, source, subdir = "") {
+  const commands = [];
+  if (!existsSync(dir)) return commands;
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        const newSubdir = subdir ? `${subdir}:${entry.name}` : entry.name;
+        commands.push(...loadCommandsFromDir(fullPath, source, newSubdir));
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      try {
+        const rawContent = readFileSync2(fullPath, "utf-8");
+        const { frontmatter, content } = parseFrontmatter(rawContent);
+        const name = entry.name.slice(0, -3);
+        const sourceStr = source === "user" ? subdir ? `(user:${subdir})` : "(user)" : subdir ? `(project:${subdir})` : "(project)";
+        let description = frontmatter.description || "";
+        if (!description) {
+          const firstLine = content.split("\n").find((l) => l.trim());
+          if (firstLine) {
+            description = firstLine.slice(0, 60);
+            if (firstLine.length > 60) description += "...";
+          }
+        }
+        description = description ? `${description} ${sourceStr}` : sourceStr;
+        commands.push({
+          name,
+          description,
+          content,
+          source: sourceStr
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return commands;
+}
+function loadSlashCommands(cwd) {
+  const commands = [];
+  const userDir = join2(homedir2(), ".pi", "agent", "commands");
+  const projectDir = resolve(cwd, ".pi", "commands");
+  commands.push(...loadCommandsFromDir(userDir, "user"));
+  commands.push(...loadCommandsFromDir(projectDir, "project"));
+  return commands;
+}
+function toAvailableCommands(fileCommands) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const c of fileCommands) {
+    if (seen.has(c.name)) continue;
+    seen.add(c.name);
+    out.push({
+      name: c.name,
+      description: c.description
+      // input: omitted for now (pi commands don't specify this)
+    });
+  }
+  return out;
+}
+function parseCommandArgs(argsString) {
+  const args = [];
+  let current = "";
+  let inQuote = null;
+  for (let i = 0; i < argsString.length; i++) {
+    const ch = argsString[i];
+    if (inQuote) {
+      if (ch === inQuote) inQuote = null;
+      else current += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch;
+    } else if (ch === " " || ch === "	") {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) args.push(current);
+  return args;
+}
+function substituteArgs(content, args) {
+  let result = content;
+  result = result.replace(/\$@/g, args.join(" "));
+  result = result.replace(/\$(\d+)/g, (_m, num) => {
+    const idx = Number.parseInt(String(num), 10) - 1;
+    return args[idx] ?? "";
+  });
+  return result;
+}
+function expandSlashCommand(text, fileCommands) {
+  if (!text.startsWith("/")) return text;
+  const spaceIndex = text.indexOf(" ");
+  const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+  const argsString = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1);
+  const cmd = fileCommands.find((c) => c.name === commandName);
+  if (!cmd) return text;
+  const args = parseCommandArgs(argsString);
+  return substituteArgs(cmd.content, args);
+}
+
+// src/acp/session.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  store = new SessionStore();
+  /** Get a registered session if it exists (no throw). */
+  maybeGet(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  async create(params) {
+    const proc = await PiRpcProcess.spawn({
+      cwd: params.cwd
+    });
+    const state = await proc.getState();
+    const sessionId = typeof state?.sessionId === "string" ? state.sessionId : crypto.randomUUID();
+    const sessionFile = typeof state?.sessionFile === "string" ? state.sessionFile : null;
+    if (sessionFile) {
+      this.store.upsert({ sessionId, cwd: params.cwd, sessionFile });
+    }
+    const session = new PiAcpSession({
+      sessionId,
+      cwd: params.cwd,
+      mcpServers: params.mcpServers,
+      proc,
+      conn: params.conn,
+      fileCommands: params.fileCommands ?? []
+    });
+    this.sessions.set(sessionId, session);
+    return session;
+  }
+  get(sessionId) {
+    const s = this.sessions.get(sessionId);
+    if (!s) throw RequestError.invalidParams(`Unknown sessionId: ${sessionId}`);
+    return s;
+  }
+  /**
+   * Used by session/load: create a session object bound to an existing sessionId/proc
+   * if it isn't already registered.
+   */
+  getOrCreate(sessionId, params) {
+    const existing = this.sessions.get(sessionId);
+    if (existing) return existing;
+    const session = new PiAcpSession({
+      sessionId,
+      cwd: params.cwd,
+      mcpServers: params.mcpServers,
+      proc: params.proc,
+      conn: params.conn,
+      fileCommands: params.fileCommands ?? []
+    });
+    this.sessions.set(sessionId, session);
+    return session;
+  }
+};
+var PiAcpSession = class {
+  sessionId;
+  cwd;
+  mcpServers;
+  proc;
+  conn;
+  fileCommands;
+  // Used to map abort semantics to ACP stopReason.
+  // Applies to the currently running turn.
+  cancelRequested = false;
+  // Current in-flight turn (if any). Additional prompts are queued.
+  pendingTurn = null;
+  turnQueue = [];
+  // Track tool call statuses and ensure they are monotonic (pending -> in_progress -> completed).
+  // 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.
+  inAgentLoop = false;
+  // For ACP diff support: capture file contents before edits, then emit ToolCallContent {type:"diff"}.
+  // This is due to pi sending diff as a string as opposed to ACP expected diff format.
+  // Compatible format may need to be implemented in pi in the future.
+  editSnapshots = /* @__PURE__ */ new Map();
+  // Ensure `session/update` notifications are sent in order and can be awaited
+  // before completing a `session/prompt` request.
+  lastEmit = Promise.resolve();
+  constructor(opts) {
+    this.sessionId = opts.sessionId;
+    this.cwd = opts.cwd;
+    this.mcpServers = opts.mcpServers;
+    this.proc = opts.proc;
+    this.conn = opts.conn;
+    this.fileCommands = opts.fileCommands ?? [];
+    this.proc.onEvent((ev) => this.handlePiEvent(ev));
+  }
+  async prompt(message, attachments = []) {
+    const expandedMessage = expandSlashCommand(message, this.fileCommands);
+    const turnPromise = new Promise((resolve2, reject) => {
+      const queued = { message: expandedMessage, attachments, resolve: resolve2, reject };
+      if (this.pendingTurn) {
+        this.turnQueue.push(queued);
+        this.emit({
+          sessionUpdate: "agent_message_chunk",
+          content: {
+            type: "text",
+            text: `Queued message (position ${this.turnQueue.length}).`
+          }
+        });
+        this.emit({
+          sessionUpdate: "session_info_update",
+          _meta: { piAcp: { queueDepth: this.turnQueue.length, running: true } }
+        });
+        return;
+      }
+      this.startTurn(queued);
+    });
+    return turnPromise;
+  }
+  async cancel() {
+    this.cancelRequested = true;
+    if (this.turnQueue.length) {
+      const queued = this.turnQueue.splice(0, this.turnQueue.length);
+      for (const t of queued) t.resolve("cancelled");
+      this.emit({
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: "Cleared queued prompts." }
+      });
+      this.emit({
+        sessionUpdate: "session_info_update",
+        _meta: { piAcp: { queueDepth: 0, running: Boolean(this.pendingTurn) } }
+      });
+    }
+    await this.proc.abort();
+  }
+  wasCancelRequested() {
+    return this.cancelRequested;
+  }
+  emit(update) {
+    this.lastEmit = this.lastEmit.then(
+      () => this.conn.sessionUpdate({
+        sessionId: this.sessionId,
+        update
+      })
+    ).catch(() => {
+    });
+  }
+  async flushEmits() {
+    await this.lastEmit;
+  }
+  startTurn(t) {
+    this.cancelRequested = false;
+    this.inAgentLoop = false;
+    this.pendingTurn = { resolve: t.resolve, reject: t.reject };
+    this.emit({
+      sessionUpdate: "session_info_update",
+      _meta: { piAcp: { queueDepth: this.turnQueue.length, running: true } }
+    });
+    this.proc.prompt(t.message, t.attachments).catch((err) => {
+      void this.flushEmits().finally(() => {
+        const reason = this.cancelRequested ? "cancelled" : "error";
+        this.pendingTurn?.resolve(reason);
+        this.pendingTurn = null;
+        this.inAgentLoop = false;
+        this.emit({
+          sessionUpdate: "session_info_update",
+          _meta: { piAcp: { queueDepth: this.turnQueue.length, running: false } }
+        });
+      });
+      void err;
+    });
+  }
+  handlePiEvent(ev) {
+    const type = String(ev.type ?? "");
+    switch (type) {
+      case "message_update": {
+        const ame = ev.assistantMessageEvent;
+        if (ame?.type === "text_delta" && typeof ame.delta === "string") {
+          this.emit({
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: ame.delta }
+          });
+          break;
+        }
+        if (ame?.type === "toolcall_start" || ame?.type === "toolcall_delta" || ame?.type === "toolcall_end") {
+          const toolCall = (
+            // pi sometimes includes the tool call directly on the event
+            ame?.toolCall ?? // ...and always includes it in the partial assistant message at contentIndex
+            ame?.partial?.content?.[ame?.contentIndex ?? 0]
+          );
+          const toolCallId = String(toolCall?.id ?? "");
+          const toolName = String(toolCall?.name ?? "tool");
+          if (toolCallId) {
+            const rawInput = toolCall?.arguments && typeof toolCall.arguments === "object" ? toolCall.arguments : (() => {
+              const s = String(toolCall?.partialArgs ?? "");
+              if (!s) return void 0;
+              try {
+                return JSON.parse(s);
+              } catch {
+                return { partialArgs: s };
+              }
+            })();
+            const existingStatus = this.currentToolCalls.get(toolCallId);
+            const status = existingStatus ?? "pending";
+            if (!existingStatus) {
+              this.currentToolCalls.set(toolCallId, "pending");
+              this.emit({
+                sessionUpdate: "tool_call",
+                toolCallId,
+                title: toolName,
+                kind: toToolKind(toolName),
+                status,
+                rawInput
+              });
+            } else {
+              this.emit({
+                sessionUpdate: "tool_call_update",
+                toolCallId,
+                status,
+                rawInput
+              });
+            }
+          }
+          break;
+        }
+        break;
+      }
+      case "tool_execution_start": {
+        const toolCallId = String(ev.toolCallId ?? crypto.randomUUID());
+        const toolName = String(ev.toolName ?? "tool");
+        const args = ev.args;
+        if (toolName === "edit") {
+          const p = typeof args?.path === "string" ? args.path : void 0;
+          if (p) {
+            try {
+              const abs = isAbsolute(p) ? p : resolvePath(this.cwd, p);
+              const oldText = readFileSync3(abs, "utf8");
+              this.editSnapshots.set(toolCallId, { path: p, oldText });
+            } catch {
+            }
+          }
+        }
+        if (!this.currentToolCalls.has(toolCallId)) {
+          this.currentToolCalls.set(toolCallId, "in_progress");
+          this.emit({
+            sessionUpdate: "tool_call",
+            toolCallId,
+            title: toolName,
+            kind: toToolKind(toolName),
+            status: "in_progress",
+            rawInput: args
+          });
+        } else {
+          this.currentToolCalls.set(toolCallId, "in_progress");
+          this.emit({
+            sessionUpdate: "tool_call_update",
+            toolCallId,
+            status: "in_progress",
+            rawInput: args
+          });
+        }
+        break;
+      }
+      case "tool_execution_update": {
+        const toolCallId = String(ev.toolCallId ?? "");
+        if (!toolCallId) break;
+        const partial = ev.partialResult;
+        const text = toolResultToText(partial);
+        this.emit({
+          sessionUpdate: "tool_call_update",
+          toolCallId,
+          status: "in_progress",
+          content: text ? [{ type: "content", content: { type: "text", text } }] : void 0,
+          rawOutput: partial
+        });
+        break;
+      }
+      case "tool_execution_end": {
+        const toolCallId = String(ev.toolCallId ?? "");
+        if (!toolCallId) break;
+        const result = ev.result;
+        const isError = Boolean(ev.isError);
+        const text = toolResultToText(result);
+        const snapshot = this.editSnapshots.get(toolCallId);
+        let content;
+        if (!isError && snapshot) {
+          try {
+            const abs = isAbsolute(snapshot.path) ? snapshot.path : resolvePath(this.cwd, snapshot.path);
+            const newText = readFileSync3(abs, "utf8");
+            if (newText !== snapshot.oldText) {
+              content = [
+                {
+                  type: "diff",
+                  path: snapshot.path,
+                  oldText: snapshot.oldText,
+                  newText
+                },
+                ...text ? [{ type: "content", content: { type: "text", text } }] : []
+              ];
+            }
+          } catch {
+          }
+        }
+        if (!content && text) {
+          content = [{ type: "content", content: { type: "text", text } }];
+        }
+        this.emit({
+          sessionUpdate: "tool_call_update",
+          toolCallId,
+          status: isError ? "failed" : "completed",
+          content,
+          rawOutput: result
+        });
+        this.currentToolCalls.delete(toolCallId);
+        this.editSnapshots.delete(toolCallId);
+        break;
+      }
+      case "agent_start": {
+        this.inAgentLoop = true;
+        break;
+      }
+      case "turn_end": {
+        break;
+      }
+      case "agent_end": {
+        void this.flushEmits().finally(() => {
+          const reason = this.cancelRequested ? "cancelled" : "end_turn";
+          this.pendingTurn?.resolve(reason);
+          this.pendingTurn = null;
+          this.inAgentLoop = false;
+          const next = this.turnQueue.shift();
+          if (next) {
+            this.emit({
+              sessionUpdate: "agent_message_chunk",
+              content: { type: "text", text: `Starting queued message. (${this.turnQueue.length} remaining)` }
+            });
+            this.startTurn(next);
+          } else {
+            this.emit({
+              sessionUpdate: "session_info_update",
+              _meta: { piAcp: { queueDepth: 0, running: false } }
+            });
+          }
+        });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+};
+function toToolKind(toolName) {
+  switch (toolName) {
+    case "read":
+      return "read";
+    case "write":
+    case "edit":
+      return "edit";
+    case "bash":
+      return "other";
+    default:
+      return "other";
+  }
+}
+
+// src/acp/translate/pi-messages.ts
+function normalizePiMessageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((c) => c?.type === "text" && typeof c.text === "string" ? c.text : "").filter(Boolean).join("");
+}
+function normalizePiAssistantText(content) {
+  if (!Array.isArray(content)) return "";
+  return content.map((c) => c?.type === "text" && typeof c.text === "string" ? c.text : "").filter(Boolean).join("");
+}
+
+// src/acp/translate/prompt.ts
+function guessFileNameFromMime(mimeType) {
+  const ext = mimeType === "image/png" ? "png" : mimeType === "image/jpeg" ? "jpg" : mimeType === "image/webp" ? "webp" : "bin";
+  return `attachment.${ext}`;
+}
+function promptToPiMessage(blocks) {
+  let message = "";
+  const attachments = [];
+  for (const b of blocks) {
+    switch (b.type) {
+      case "text":
+        message += b.text;
+        break;
+      case "resource_link":
+        message += `
+[Context] ${b.uri}`;
+        break;
+      case "image": {
+        const id = b.uri ?? crypto.randomUUID();
+        const size = Buffer.byteLength(b.data, "base64");
+        attachments.push({
+          id,
+          type: "image",
+          fileName: guessFileNameFromMime(b.mimeType),
+          mimeType: b.mimeType,
+          size,
+          content: b.data
+        });
+        break;
+      }
+      case "resource": {
+        const r = b.resource;
+        const uri = typeof r?.uri === "string" ? r.uri : "(unknown)";
+        if (typeof r?.text === "string") {
+          const mime = typeof r?.mimeType === "string" ? r.mimeType : "text/plain";
+          message += `
+[Embedded Context] ${uri} (${mime})
+${r.text}`;
+        } else if (typeof r?.blob === "string") {
+          const mime = typeof r?.mimeType === "string" ? r.mimeType : "application/octet-stream";
+          const bytes = Buffer.byteLength(r.blob, "base64");
+          message += `
+[Embedded Context] ${uri} (${mime}, ${bytes} bytes)`;
+        } else {
+          message += `
+[Embedded Context] ${uri}`;
+        }
+        break;
+      }
+      case "audio": {
+        const bytes = Buffer.byteLength(b.data, "base64");
+        message += `
+[Audio] (${b.mimeType}, ${bytes} bytes) not supported by pi-acp`;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return { message, attachments };
+}
+
+// src/acp/agent.ts
+import { isAbsolute as isAbsolute2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync4, realpathSync } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+function builtinAvailableCommands() {
+  return [
+    {
+      name: "compact",
+      description: "Manually compact the session context",
+      input: { hint: "optional custom instructions" }
+    },
+    {
+      name: "autocompact",
+      description: "Toggle automatic context compaction",
+      input: { hint: "on|off|toggle" }
+    },
+    {
+      name: "export",
+      description: "Export session to an HTML file in the session cwd"
+    },
+    {
+      name: "session",
+      description: "Show session stats (messages, tokens, cost, session file)"
+    },
+    {
+      name: "queue",
+      description: "Set pi message queue mode (all | one-at-a-time(recommended))",
+      input: { hint: "all | one-at-a-time" }
+    },
+    {
+      name: "changelog",
+      description: "Show pi changelog"
+    }
+  ];
+}
+function mergeCommands(a, b) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const c of [...a, ...b]) {
+    if (seen.has(c.name)) continue;
+    seen.add(c.name);
+    out.push(c);
+  }
+  return out;
+}
+var pkg = readNearestPackageJson(import.meta.url);
+var PiAcpAgent = class {
+  conn;
+  sessions = new SessionManager();
+  store = new SessionStore();
+  constructor(conn) {
+    this.conn = conn;
+  }
+  async initialize(params) {
+    const supportedVersion = 1;
+    const requested = params.protocolVersion;
+    return {
+      protocolVersion: requested === supportedVersion ? requested : supportedVersion,
+      agentInfo: {
+        name: pkg.name ?? "pi-acp",
+        title: "pi ACP adapter",
+        version: pkg.version ?? "0.0.0"
+      },
+      authMethods: [],
+      agentCapabilities: {
+        loadSession: true,
+        mcpCapabilities: { http: false, sse: false },
+        promptCapabilities: {
+          image: true,
+          audio: false,
+          embeddedContext: false
+        },
+        sessionCapabilities: {}
+      }
+    };
+  }
+  async newSession(params) {
+    if (!isAbsolute2(params.cwd)) {
+      throw RequestError2.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+    }
+    const fileCommands = loadSlashCommands(params.cwd);
+    const session = await this.sessions.create({
+      cwd: params.cwd,
+      mcpServers: params.mcpServers,
+      conn: this.conn,
+      fileCommands
+    });
+    const models = await getModelState(session.proc);
+    const thinking = await getThinkingState(session.proc);
+    const response = {
+      sessionId: session.sessionId,
+      models,
+      modes: thinking,
+      _meta: {}
+    };
+    setTimeout(() => {
+      void this.conn.sessionUpdate({
+        sessionId: session.sessionId,
+        update: {
+          sessionUpdate: "available_commands_update",
+          availableCommands: mergeCommands(toAvailableCommands(fileCommands), builtinAvailableCommands())
+        }
+      });
+    }, 0);
+    return response;
+  }
+  async authenticate(_params) {
+    return;
+  }
+  async prompt(params) {
+    const session = this.sessions.get(params.sessionId);
+    const { message, attachments } = promptToPiMessage(params.prompt);
+    if (attachments.length === 0 && message.trimStart().startsWith("/")) {
+      const trimmed = message.trim();
+      const space = trimmed.indexOf(" ");
+      const cmd = space === -1 ? trimmed.slice(1) : trimmed.slice(1, space);
+      const argsString = space === -1 ? "" : trimmed.slice(space + 1);
+      const args = parseCommandArgs(argsString);
+      if (cmd === "compact") {
+        const customInstructions = args.join(" ").trim() || void 0;
+        const res = await session.proc.compact(customInstructions);
+        const r = res && typeof res === "object" ? res : null;
+        const tokensBefore = typeof r?.tokensBefore === "number" ? r.tokensBefore : null;
+        const summary = typeof r?.summary === "string" ? r.summary : null;
+        const headerLines = [
+          `Compaction completed.${customInstructions ? " (custom instructions applied)" : ""}`,
+          tokensBefore !== null ? `Tokens before: ${tokensBefore}` : null
+        ].filter(Boolean);
+        const text = headerLines.join("\n") + (summary ? `
+
+${summary}` : "");
+        await this.conn.sessionUpdate({
+          sessionId: session.sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text }
+          }
+        });
+        return { stopReason: "end_turn" };
+      }
+      if (cmd === "session") {
+        const stats = await session.proc.getSessionStats();
+        const lines = [];
+        if (stats?.sessionId) lines.push(`Session: ${stats.sessionId}`);
+        if (stats?.sessionFile) lines.push(`Session file: ${stats.sessionFile}`);
+        if (typeof stats?.totalMessages === "number") lines.push(`Messages: ${stats.totalMessages}`);
+        if (typeof stats?.cost === "number") lines.push(`Cost: ${stats.cost}`);
+        const t = stats?.tokens;
+        if (t && typeof t === "object") {
+          const parts = [];
+          if (typeof t.input === "number") parts.push(`in ${t.input}`);
+          if (typeof t.output === "number") parts.push(`out ${t.output}`);
+          if (typeof t.cacheRead === "number") parts.push(`cache read ${t.cacheRead}`);
+          if (typeof t.cacheWrite === "number") parts.push(`cache write ${t.cacheWrite}`);
+          if (typeof t.total === "number") parts.push(`total ${t.total}`);
+          if (parts.length) lines.push(`Tokens: ${parts.join(", ")}`);
+        }
+        const text = lines.length ? lines.join("\n") : `Session stats:
+${JSON.stringify(stats, null, 2)}`;
+        await this.conn.sessionUpdate({
+          sessionId: session.sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text }
+          }
+        });
+        return { stopReason: "end_turn" };
+      }
+      if (cmd === "queue") {
+        const modeRaw = String(args[0] ?? "").toLowerCase();
+        const state = await session.proc.getState();
+        const current = String(state?.queueMode ?? "");
+        if (!modeRaw) {
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: {
+                type: "text",
+                text: `Queue mode: ${current || "unknown"}`
+              }
+            }
+          });
+          return { stopReason: "end_turn" };
+        }
+        if (modeRaw !== "all" && modeRaw !== "one-at-a-time") {
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: {
+                type: "text",
+                text: "Usage: /queue all | /queue one-at-a-time"
+              }
+            }
+          });
+          return { stopReason: "end_turn" };
+        }
+        await session.proc.setQueueMode(modeRaw);
+        await this.conn.sessionUpdate({
+          sessionId: session.sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: `Queue mode set to: ${modeRaw}` }
+          }
+        });
+        return { stopReason: "end_turn" };
+      }
+      if (cmd === "changelog") {
+        const findChangelog = () => {
+          try {
+            const whichCmd = process.platform === "win32" ? "where" : "which";
+            const which = spawnSync(whichCmd, ["pi"], { encoding: "utf-8" });
+            const piPath = String(which.stdout ?? "").split(/\r?\n/)[0]?.trim();
+            if (piPath) {
+              const resolved = realpathSync(piPath);
+              const pkgRoot = dirname2(dirname2(resolved));
+              const p = join3(pkgRoot, "CHANGELOG.md");
+              if (existsSync2(p)) return p;
+            }
+          } catch {
+          }
+          try {
+            const npmRoot = spawnSync("npm", ["root", "-g"], { encoding: "utf-8" });
+            const root = String(npmRoot.stdout ?? "").trim();
+            if (root) {
+              const p = join3(root, "@mariozechner", "pi-coding-agent", "CHANGELOG.md");
+              if (existsSync2(p)) return p;
+            }
+          } catch {
+          }
+          return null;
+        };
+        const changelogPath = findChangelog();
+        if (!changelogPath) {
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: { type: "text", text: "Changelog not found (couldn't locate pi installation)." }
+            }
+          });
+          return { stopReason: "end_turn" };
+        }
+        let text = "";
+        try {
+          text = readFileSync4(changelogPath, "utf-8");
+        } catch (e) {
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: { type: "text", text: `Failed to read changelog: ${String(e?.message ?? e)}` }
+            }
+          });
+          return { stopReason: "end_turn" };
+        }
+        const maxChars = 2e4;
+        if (text.length > maxChars) text = text.slice(0, maxChars) + "\n\n...(truncated)...";
+        await this.conn.sessionUpdate({
+          sessionId: session.sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text }
+          }
+        });
+        return { stopReason: "end_turn" };
+      }
+      if (cmd === "export") {
+        const state = await session.proc.getState();
+        const sessionFile = typeof state?.sessionFile === "string" ? state.sessionFile : null;
+        const messageCount = typeof state?.messageCount === "number" ? state.messageCount : 0;
+        if (!sessionFile || messageCount === 0 || !existsSync2(sessionFile)) {
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: {
+                type: "text",
+                text: "Nothing to export yet (no session messages). Send a prompt first."
+              }
+            }
+          });
+          return { stopReason: "end_turn" };
+        }
+        try {
+          const raw = readFileSync4(sessionFile, "utf-8");
+          if (raw.trim().length === 0) {
+            await this.conn.sessionUpdate({
+              sessionId: session.sessionId,
+              update: {
+                sessionUpdate: "agent_message_chunk",
+                content: {
+                  type: "text",
+                  text: "Nothing to export yet (empty session file). Send a prompt first."
+                }
+              }
+            });
+            return { stopReason: "end_turn" };
+          }
+        } catch {
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: {
+                type: "text",
+                text: "Couldn't read session file for export. Try sending a prompt first."
+              }
+            }
+          });
+          return { stopReason: "end_turn" };
+        }
+        const safeSessionId = session.sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+        const outputPath = join3(session.cwd, `pi-session-${safeSessionId}.html`);
+        let resultPath = "";
+        try {
+          const result2 = await session.proc.exportHtml(outputPath);
+          resultPath = result2.path;
+        } catch (e) {
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: {
+                type: "text",
+                text: `Export failed: ${String(e?.message ?? e)}`
+              }
+            }
+          });
+          return { stopReason: "end_turn" };
+        }
+        if (!resultPath) {
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: {
+                type: "text",
+                text: "Export failed: no output path returned by pi."
+              }
+            }
+          });
+          return { stopReason: "end_turn" };
+        }
+        const uri = `file://${resultPath}`;
+        await this.conn.sessionUpdate({
+          sessionId: session.sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: {
+              type: "text",
+              text: "Session exported: "
+            }
+          }
+        });
+        await this.conn.sessionUpdate({
+          sessionId: session.sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: {
+              type: "resource_link",
+              name: `pi-session-${safeSessionId}.html`,
+              uri,
+              mimeType: "text/html",
+              title: "Session exported"
+            }
+          }
+        });
+        return { stopReason: "end_turn" };
+      }
+      if (cmd === "autocompact") {
+        const mode = (args[0] ?? "toggle").toLowerCase();
+        let enabled = null;
+        if (mode === "on" || mode === "true" || mode === "enable" || mode === "enabled") enabled = true;
+        else if (mode === "off" || mode === "false" || mode === "disable" || mode === "disabled") enabled = false;
+        if (enabled === null) {
+          const state = await session.proc.getState();
+          const current = Boolean(state?.autoCompactionEnabled);
+          enabled = !current;
+        }
+        await session.proc.setAutoCompaction(enabled);
+        await this.conn.sessionUpdate({
+          sessionId: session.sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: {
+              type: "text",
+              text: `Auto-compaction ${enabled ? "enabled" : "disabled"}.`
+            }
+          }
+        });
+        return { stopReason: "end_turn" };
+      }
+    }
+    const result = await session.prompt(message, attachments);
+    const stopReason = result === "error" ? session.wasCancelRequested() ? "cancelled" : "end_turn" : result;
+    return { stopReason };
+  }
+  async cancel(params) {
+    const session = this.sessions.get(params.sessionId);
+    await session.cancel();
+  }
+  async loadSession(params) {
+    if (!isAbsolute2(params.cwd)) {
+      throw RequestError2.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+    }
+    const stored = this.store.get(params.sessionId);
+    if (!stored) {
+      throw RequestError2.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+    }
+    const proc = await PiRpcProcess.spawn({
+      cwd: params.cwd,
+      sessionPath: stored.sessionFile
+    });
+    const fileCommands = loadSlashCommands(params.cwd);
+    const session = this.sessions.getOrCreate(params.sessionId, {
+      cwd: params.cwd,
+      mcpServers: params.mcpServers,
+      conn: this.conn,
+      proc,
+      fileCommands
+    });
+    this.store.upsert({
+      sessionId: params.sessionId,
+      cwd: params.cwd,
+      sessionFile: stored.sessionFile
+    });
+    const data = await proc.getMessages();
+    const messages = Array.isArray(data?.messages) ? data.messages : [];
+    for (const m of messages) {
+      const role = String(m?.role ?? "");
+      if (role === "user") {
+        const text = normalizePiMessageText(m?.content);
+        if (text) {
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "user_message_chunk",
+              content: { type: "text", text }
+            }
+          });
+        }
+      }
+      if (role === "assistant") {
+        const text = normalizePiAssistantText(m?.content);
+        if (text) {
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: { type: "text", text }
+            }
+          });
+        }
+      }
+    }
+    const models = await getModelState(proc);
+    const thinking = await getThinkingState(proc);
+    const response = {
+      models,
+      modes: thinking,
+      _meta: {}
+    };
+    setTimeout(() => {
+      void this.conn.sessionUpdate({
+        sessionId: session.sessionId,
+        update: {
+          sessionUpdate: "available_commands_update",
+          availableCommands: mergeCommands(toAvailableCommands(fileCommands), builtinAvailableCommands())
+        }
+      });
+    }, 0);
+    return response;
+  }
+  async unstable_setSessionModel(params) {
+    const session = this.sessions.get(params.sessionId);
+    let provider = null;
+    let modelId = null;
+    if (params.modelId.includes("/")) {
+      const [p, ...rest] = params.modelId.split("/");
+      provider = p;
+      modelId = rest.join("/");
+    } else {
+      modelId = params.modelId;
+    }
+    if (!provider) {
+      const data = await session.proc.getAvailableModels();
+      const models = Array.isArray(data?.models) ? data.models : [];
+      const found = models.find((m) => String(m?.id) === modelId);
+      if (found) {
+        provider = String(found.provider);
+        modelId = String(found.id);
+      }
+    }
+    if (!provider || !modelId) {
+      throw RequestError2.invalidParams(`Unknown modelId: ${params.modelId}`);
+    }
+    await session.proc.setModel(provider, modelId);
+  }
+  async setSessionMode(params) {
+    const session = this.sessions.get(params.sessionId);
+    const mode = String(params.modeId);
+    if (!isThinkingLevel(mode)) {
+      throw RequestError2.invalidParams(`Unknown modeId: ${mode}`);
+    }
+    await session.proc.setThinkingLevel(mode);
+    void this.conn.sessionUpdate({
+      sessionId: session.sessionId,
+      update: {
+        sessionUpdate: "current_mode_update",
+        currentModeId: mode
+      }
+    });
+    return {};
+  }
+};
+function isThinkingLevel(x) {
+  return x === "off" || x === "minimal" || x === "low" || x === "medium" || x === "high" || x === "xhigh";
+}
+async function getThinkingState(proc) {
+  let current = "medium";
+  try {
+    const state = await proc.getState();
+    const tl = typeof state?.thinkingLevel === "string" ? state.thinkingLevel : null;
+    if (tl && isThinkingLevel(tl)) current = tl;
+  } catch {
+  }
+  const available = ["off", "minimal", "low", "medium", "high", "xhigh"];
+  return {
+    currentModeId: current,
+    availableModes: available.map((id) => ({
+      id,
+      name: `Thinking: ${id}`,
+      description: null
+    }))
+  };
+}
+async function getModelState(proc) {
+  let availableModels = [];
+  try {
+    const data = await proc.getAvailableModels();
+    const models = Array.isArray(data?.models) ? data.models : [];
+    availableModels = models.map((m) => {
+      const provider = String(m?.provider ?? "").trim();
+      const id = String(m?.id ?? "").trim();
+      if (!provider || !id) return null;
+      const name = String(m?.name ?? id);
+      return {
+        modelId: `${provider}/${id}`,
+        name: `${provider}/${name}`,
+        description: null
+      };
+    }).filter(Boolean);
+  } catch {
+  }
+  let currentModelId = null;
+  try {
+    const state = await proc.getState();
+    const model = state?.model;
+    if (model && typeof model === "object") {
+      const provider = String(model.provider ?? "").trim();
+      const id = String(model.id ?? "").trim();
+      if (provider && id) currentModelId = `${provider}/${id}`;
+    }
+  } catch {
+  }
+  if (!availableModels.length && !currentModelId) return null;
+  if (!currentModelId) currentModelId = availableModels[0]?.modelId ?? "default";
+  return {
+    availableModels,
+    currentModelId
+  };
+}
+function readNearestPackageJson(metaUrl) {
+  try {
+    let dir = dirname2(fileURLToPath(metaUrl));
+    for (let i = 0; i < 6; i++) {
+      const p = join3(dir, "package.json");
+      if (existsSync2(p)) {
+        const json = JSON.parse(readFileSync4(p, "utf-8"));
+        return { name: json?.name, version: json?.version };
+      }
+      dir = dirname2(dir);
+    }
+  } catch {
+  }
+  return { name: "pi-acp", version: "0.0.0" };
+}
+
+// src/index.ts
+var input = new WritableStream({
+  write(chunk) {
+    return new Promise((resolve2, reject) => {
+      process.stdout.write(chunk, (err) => {
+        if (err) reject(err);
+        else resolve2();
+      });
+    });
+  }
+});
+var output = new ReadableStream({
+  start(controller) {
+    process.stdin.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
+    process.stdin.on("end", () => controller.close());
+    process.stdin.on("error", (err) => controller.error(err));
+  }
+});
+var stream = ndJsonStream(input, output);
+new AgentSideConnection((conn) => new PiAcpAgent(conn), stream);
+process.stdin.resume();
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
+//# sourceMappingURL=index.js.map