@pi-in-go/pigpen-acp 0.1.0

package/port/oracle/pi-acp/src/acp/slash-commands.ts

@@ -0,0 +1,197 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+import type { AvailableCommand } from '@agentclientprotocol/sdk'
+
+/**
+ * File-based slash command (mirrors pi-coding-agent semantics).
+ */
+export type FileSlashCommand = {
+  name: string
+  description: string
+  content: string
+  source: string // e.g. "(user)", "(project)", "(project:frontend)"
+}
+
+function parseFrontmatter(content: string): {
+  frontmatter: Record<string, string>
+  content: string
+} {
+  const frontmatter: Record<string, string> = {}
+
+  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: string, source: 'user' | 'project', subdir = ''): FileSlashCommand[] {
+  const commands: FileSlashCommand[] = []
+  if (!existsSync(dir)) return commands
+
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const fullPath = join(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 = readFileSync(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 {
+        // Silently skip unreadable files.
+      }
+    }
+  } catch {
+    // Silently skip unreadable dirs.
+  }
+
+  return commands
+}
+
+/**
+ * Load prompt templates from pi's prompt directories (formerly "commands").
+ *  - user:    ~/.pi/agent/prompts/**\/*.md
+ *  - project: <cwd>/.pi/prompts/**\/*.md
+ */
+export function loadSlashCommands(cwd: string): FileSlashCommand[] {
+  const commands: FileSlashCommand[] = []
+
+  const userDir = join(homedir(), '.pi', 'agent', 'prompts')
+  const projectDir = resolve(cwd, '.pi', 'prompts')
+
+  // Match pi ordering: user first, then project.
+  commands.push(...loadCommandsFromDir(userDir, 'user'))
+  commands.push(...loadCommandsFromDir(projectDir, 'project'))
+
+  return commands
+}
+
+/**
+ * Convert file-based commands to ACP AvailableCommand objects.
+ * De-dupes by name (first wins).
+ */
+export function toAvailableCommands(fileCommands: FileSlashCommand[]): AvailableCommand[] {
+  const seen = new Set<string>()
+  const out: AvailableCommand[] = []
+
+  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
+}
+
+/**
+ * Parse command args (bash-style quotes).
+ */
+export function parseCommandArgs(argsString: string): string[] {
+  const args: string[] = []
+  let current = ''
+  let inQuote: string | null = 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 === '\t') {
+      if (current) {
+        args.push(current)
+        current = ''
+      }
+    } else {
+      current += ch
+    }
+  }
+
+  if (current) args.push(current)
+  return args
+}
+
+/**
+ * Substitute $1, $2, ... and $@.
+ */
+export function substituteArgs(content: string, args: string[]): string {
+  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
+}
+
+/**
+ * Expand a leading /command using the loaded file commands.
+ * Returns original text if it's not a known slash command.
+ */
+export function expandSlashCommand(text: string, fileCommands: FileSlashCommand[]): string {
+  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)
+}

package/port/oracle/pi-acp/src/acp/translate/bash.ts

@@ -0,0 +1,100 @@
+import type { ToolCallContent } from '@agentclientprotocol/sdk'
+
+type BashCommandRecord = {
+  command?: unknown
+  cmd?: unknown
+  args?: BashCommandRecord
+  input?: BashCommandRecord
+  rawInput?: BashCommandRecord
+  toolInput?: BashCommandRecord
+  details?: BashCommandRecord
+}
+
+type BashResultRecord = {
+  content?: unknown
+  details?: unknown
+  stdout?: unknown
+  stderr?: unknown
+  output?: unknown
+  exitCode?: unknown
+  code?: unknown
+}
+
+export function isBashTool(toolName: string): boolean {
+  return toolName.toLowerCase() === 'bash'
+}
+
+export function bashCommand(value: unknown): string | undefined {
+  const record = value as BashCommandRecord | null | undefined
+  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 : undefined
+}
+
+export function bashResultText(result: unknown): string {
+  const record = result as BashResultRecord | null | undefined
+  const content = record?.content
+  if (Array.isArray(content)) {
+    const texts = content
+      .map(c => {
+        const block = c as { type?: unknown; text?: unknown }
+        return block.type === 'text' && typeof block.text === 'string' ? block.text : ''
+      })
+      .filter(Boolean)
+    if (texts.length) return texts.join('')
+  }
+
+  const details = record?.details as BashResultRecord | null | undefined
+  const stdout =
+    (typeof details?.stdout === 'string' ? details.stdout : undefined) ??
+    (typeof record?.stdout === 'string' ? record.stdout : undefined) ??
+    (typeof details?.output === 'string' ? details.output : undefined) ??
+    (typeof record?.output === 'string' ? record.output : undefined)
+  const stderr =
+    (typeof details?.stderr === 'string' ? details.stderr : undefined) ??
+    (typeof record?.stderr === 'string' ? record.stderr : undefined)
+
+  return [stdout, stderr].filter((part): part is string => typeof part === 'string' && part.length > 0).join('\n')
+}
+
+export function bashExitCode(result: unknown, isError: boolean): number {
+  const record = result as BashResultRecord | null | undefined
+  const details = record?.details as BashResultRecord | null | undefined
+  const exitCode = details?.exitCode ?? record?.exitCode ?? details?.code ?? record?.code
+  return typeof exitCode === 'number' ? exitCode : isError ? 1 : 0
+}
+
+export function bashOutputDelta(previous: string, next: string): string {
+  return next.startsWith(previous) ? next.slice(previous.length) : next
+}
+
+export function bashTerminalContent(toolCallId: string): ToolCallContent[] {
+  return [{ type: 'terminal', terminalId: toolCallId }] satisfies ToolCallContent[]
+}
+
+export function bashTerminalInfoMeta(toolCallId: string, cwd: string) {
+  // Zed renders ACP `execute` tools as display-only terminals when paired with
+  // terminal content plus terminal metadata. See ACP execute tool schema:
+  // https://agentclientprotocol.com/protocol/schema#param-execute
+  return { terminal_info: { terminal_id: toolCallId, cwd } }
+}
+
+export function bashTerminalOutputMeta(toolCallId: string, data: string) {
+  return { terminal_output: { terminal_id: toolCallId, data } }
+}
+
+export function bashTerminalExitMeta(toolCallId: string, exitCode: number) {
+  return { terminal_exit: { terminal_id: toolCallId, exit_code: exitCode, signal: null } }
+}

package/port/oracle/pi-acp/src/acp/translate/pi-messages.ts

@@ -0,0 +1,17 @@
+export function normalizePiMessageText(content: unknown): string {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content
+    .map((c: any) => (c?.type === 'text' && typeof c.text === 'string' ? c.text : ''))
+    .filter(Boolean)
+    .join('')
+}
+
+export function normalizePiAssistantText(content: unknown): string {
+  // Assistant content is typically an array of blocks; only replay text blocks for MVP.
+  if (!Array.isArray(content)) return ''
+  return content
+    .map((c: any) => (c?.type === 'text' && typeof c.text === 'string' ? c.text : ''))
+    .filter(Boolean)
+    .join('')
+}

package/port/oracle/pi-acp/src/acp/translate/pi-tools.ts

@@ -0,0 +1,51 @@
+export function toolResultToText(result: unknown): string {
+  if (!result) return ''
+
+  const details = (result as any)?.details
+
+  // pi's edit tool returns a terse success message in content and the full unified diff in details.diff.
+  const diff = details?.diff
+  if (typeof diff === 'string' && diff.trim()) {
+    return diff
+  }
+
+  // pi tool results generally look like: { content: [{type:"text", text:"..."}], details: {...} }
+  const content = (result as any).content
+  if (Array.isArray(content)) {
+    const texts = content
+      .map((c: any) => (c?.type === 'text' && typeof c.text === 'string' ? c.text : ''))
+      .filter(Boolean)
+    if (texts.length) return texts.join('')
+  }
+
+  // The bash tool frequently returns stdout/stderr in `details` rather than content blocks.
+  const stdout =
+    (typeof details?.stdout === 'string' ? details.stdout : undefined) ??
+    (typeof (result as any)?.stdout === 'string' ? (result as any).stdout : undefined) ??
+    (typeof details?.output === 'string' ? details.output : undefined) ??
+    (typeof (result as any)?.output === 'string' ? (result as any).output : undefined)
+
+  const stderr =
+    (typeof details?.stderr === 'string' ? details.stderr : undefined) ??
+    (typeof (result as any)?.stderr === 'string' ? (result as any).stderr : undefined)
+
+  const exitCode =
+    (typeof details?.exitCode === 'number' ? details.exitCode : undefined) ??
+    (typeof (result as any)?.exitCode === 'number' ? (result as any).exitCode : undefined) ??
+    (typeof details?.code === 'number' ? details.code : undefined) ??
+    (typeof (result as any)?.code === 'number' ? (result as any).code : undefined)
+
+  if ((typeof stdout === 'string' && stdout.trim()) || (typeof stderr === 'string' && stderr.trim())) {
+    const parts: string[] = []
+    if (typeof stdout === 'string' && stdout.trim()) parts.push(stdout)
+    if (typeof stderr === 'string' && stderr.trim()) parts.push(`stderr:\n${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)
+  }
+}

package/port/oracle/pi-acp/src/acp/translate/prompt.ts

@@ -0,0 +1,71 @@
+import type { ContentBlock } from '@agentclientprotocol/sdk'
+
+export type PiImage = {
+  type: 'image'
+  mimeType: string
+  data: string
+}
+
+export function promptToPiMessage(blocks: ContentBlock[]): {
+  message: string
+  images: PiImage[]
+} {
+  let message = ''
+  const images: PiImage[] = []
+
+  for (const b of blocks) {
+    switch (b.type) {
+      case 'text':
+        message += b.text
+        break
+
+      case 'resource_link':
+        // A lightweight, human-readable hint for the LLM.
+        message += `\n[Context] ${b.uri}`
+        break
+
+      case 'image': {
+        // pi expects base64 image bytes in `data` without a data-url prefix.
+        images.push({
+          type: 'image',
+          mimeType: b.mimeType,
+          data: b.data
+        })
+        break
+      }
+
+      case 'resource': {
+        // Clients should not send this if embeddedContext=false, but be resilient.
+        const r: any = (b as any).resource
+        const uri = typeof r?.uri === 'string' ? r.uri : '(unknown)'
+
+        if (typeof r?.text === 'string') {
+          // TextResourceContents
+          const mime = typeof r?.mimeType === 'string' ? r.mimeType : 'text/plain'
+          message += `\n[Embedded Context] ${uri} (${mime})\n${r.text}`
+        } else if (typeof r?.blob === 'string') {
+          // BlobResourceContents
+          const mime = typeof r?.mimeType === 'string' ? r.mimeType : 'application/octet-stream'
+          const bytes = Buffer.byteLength(r.blob, 'base64')
+          message += `\n[Embedded Context] ${uri} (${mime}, ${bytes} bytes)`
+        } else {
+          message += `\n[Embedded Context] ${uri}`
+        }
+        break
+      }
+
+      case 'audio': {
+        // Not supported by pi. Provide a marker so we don't silently drop context.
+        const bytes = Buffer.byteLength(b.data, 'base64')
+        message += `\n[Audio] (${b.mimeType}, ${bytes} bytes) not supported by pi-acp`
+        break
+      }
+
+      default:
+        // Ignore unknown block types for now.
+        break
+    }
+  }
+
+  return { message, images }
+}

package/port/oracle/pi-acp/src/index.ts

@@ -0,0 +1,82 @@
+import { AgentSideConnection, ndJsonStream } from '@agentclientprotocol/sdk'
+import { PiAcpAgent } from './acp/agent.js'
+import { getPiCommand, shouldUseShellForPiCommand } from './pi-rpc/command.js'
+// Terminal Auth entrypoint. The ACP client launches the agent with `--terminal-login`.
+if (process.argv.includes('--terminal-login')) {
+  const { spawnSync } = await import('node:child_process')
+  const cmd = getPiCommand(process.env.PI_ACP_PI_COMMAND)
+  const res = spawnSync(cmd, [], {
+    stdio: 'inherit',
+    env: process.env,
+    shell: shouldUseShellForPiCommand(cmd)
+  })
+
+  if ((res as any).error && (res as any).error.code === 'ENOENT') {
+    process.stderr.write(
+      `pi-acp: could not start pi (command not found: ${cmd}). Install it via \`npm install -g @earendil-works/pi-coding-agent\` or ensure \`pi\` is on your PATH.\n`
+    )
+    process.exit(1)
+  }
+
+  process.exit(typeof res.status === 'number' ? res.status : 1)
+}
+
+const input = new WritableStream<Uint8Array>({
+  write(chunk) {
+    return new Promise<void>(resolve => {
+      if ((process.stdout as any).destroyed || !process.stdout.writable) return resolve()
+
+      try {
+        process.stdout.write(chunk, err => {
+          void err
+          resolve()
+        })
+      } catch {
+        // Common: ERR_STREAM_DESTROYED ("Cannot call write after a stream was destroyed").
+        resolve()
+      }
+    })
+  }
+})
+
+const output = new ReadableStream<Uint8Array>({
+  start(controller) {
+    process.stdin.on('data', (chunk: Buffer) => controller.enqueue(new Uint8Array(chunk)))
+    process.stdin.on('end', () => controller.close())
+    process.stdin.on('error', err => controller.error(err))
+  }
+})
+
+const stream = ndJsonStream(input, output)
+
+const agent = new AgentSideConnection(conn => new PiAcpAgent(conn), stream)
+
+function shutdown() {
+  try {
+    // Best-effort: dispose session subprocesses when the client disconnects.
+    ;(agent as any)?.agent?.dispose?.()
+  } catch {
+    // ignore
+  }
+  try {
+    process.exit(0)
+  } catch {
+    // ignore
+  }
+}
+
+process.stdin.on('end', shutdown)
+process.stdin.on('close', shutdown)
+
+process.stdin.resume()
+process.on('SIGINT', shutdown)
+process.on('SIGTERM', shutdown)
+
+// Avoid crashing if the client closes stdout early.
+process.stdout.on('error', () => {
+  try {
+    process.exit(0)
+  } catch {
+    // ignore
+  }
+})

package/port/oracle/pi-acp/src/pi-rpc/command.ts

@@ -0,0 +1,16 @@
+import { platform } from 'node:os'
+
+export function defaultPiCommand(): string {
+  return platform() === 'win32' ? 'pi.cmd' : 'pi'
+}
+
+export function getPiCommand(override?: string): string {
+  return override ?? defaultPiCommand()
+}
+
+export function shouldUseShellForPiCommand(cmd: string): boolean {
+  if (platform() !== 'win32') return false
+
+  const normalized = cmd.trim().toLowerCase()
+  return normalized.endsWith('.cmd') || normalized.endsWith('.bat')
+}