@pi-in-go/pigpen-acp 0.1.0

package/port/oracle/pi-acp/test/unit/session-config-options.test.ts

@@ -0,0 +1,217 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { PiAcpAgent } from '../../src/acp/agent.js'
+import { FakeAgentSideConnection, asAgentConn } from '../helpers/fakes.js'
+
+class FakeSessions {
+  constructor(private readonly session: any) {}
+
+  async create() {
+    return this.session
+  }
+
+  maybeGet(sessionId: string) {
+    if (sessionId !== this.session.sessionId) return undefined
+    return this.session
+  }
+
+  get(sessionId: string) {
+    if (sessionId !== this.session.sessionId) {
+      throw new Error(`Unknown sessionId: ${sessionId}`)
+    }
+    return this.session
+  }
+}
+
+test('PiAcpAgent: newSession returns configOptions for model and thinking selectors', async () => {
+  const realSetTimeout = globalThis.setTimeout
+  ;(globalThis as any).setTimeout = () => 0 as any
+
+  try {
+    const conn = new FakeAgentSideConnection()
+    const session = {
+      sessionId: 's1',
+      cwd: process.cwd(),
+      proc: {
+        async getAvailableThinkingLevels() {
+          return ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']
+        },
+        async getAvailableModels() {
+          return {
+            models: [
+              { provider: 'test', id: 'alpha', name: 'Alpha' },
+              { provider: 'test', id: 'beta', name: 'Beta' }
+            ]
+          }
+        },
+        async getState() {
+          return {
+            thinkingLevel: 'high',
+            model: { provider: 'test', id: 'beta' }
+          }
+        }
+      },
+      setStartupInfo() {},
+      sendStartupInfoIfPending() {}
+    }
+
+    const agent = new PiAcpAgent(asAgentConn(conn), {} as any)
+    ;(agent as any).sessions = new FakeSessions(session) as any
+
+    const result = await agent.newSession({ cwd: process.cwd(), mcpServers: [] } as any)
+
+    assert.equal(result.models?.currentModelId, 'test/beta')
+    assert.equal(result.modes?.currentModeId, 'high')
+    assert.deepEqual(result.configOptions, [
+      {
+        type: 'select',
+        id: 'model',
+        category: 'model',
+        name: 'Model',
+        description: 'Select the model for this session',
+        currentValue: 'test/beta',
+        options: [
+          { value: 'test/alpha', name: 'test/Alpha', description: null },
+          { value: 'test/beta', name: 'test/Beta', description: null }
+        ]
+      },
+      {
+        type: 'select',
+        id: 'thought_level',
+        category: 'thought_level',
+        name: 'Thinking',
+        description: 'Set the reasoning effort for this session',
+        currentValue: 'high',
+        options: [
+          { value: 'off', name: 'Thinking: off', description: null },
+          { value: 'minimal', name: 'Thinking: minimal', description: null },
+          { value: 'low', name: 'Thinking: low', description: null },
+          { value: 'medium', name: 'Thinking: medium', description: null },
+          { value: 'high', name: 'Thinking: high', description: null },
+          { value: 'xhigh', name: 'Thinking: xhigh', description: null },
+          { value: 'max', name: 'Thinking: max', description: null }
+        ]
+      }
+    ])
+  } finally {
+    ;(globalThis as any).setTimeout = realSetTimeout
+  }
+})
+
+test('PiAcpAgent: setSessionConfigOption maps model changes to pi and emits config_option_update', async () => {
+  const conn = new FakeAgentSideConnection()
+  const state = {
+    thinkingLevel: 'medium',
+    model: { provider: 'test', id: 'alpha' }
+  }
+  const setModelCalls: Array<{ provider: string; modelId: string }> = []
+
+  const session = {
+    sessionId: 's1',
+    cwd: process.cwd(),
+    proc: {
+      async getAvailableThinkingLevels() {
+        return ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']
+      },
+      async getAvailableModels() {
+        return {
+          models: [
+            { provider: 'test', id: 'alpha', name: 'Alpha' },
+            { provider: 'test', id: 'beta', name: 'Beta' }
+          ]
+        }
+      },
+      async getState() {
+        return state
+      },
+      async setModel(provider: string, modelId: string) {
+        setModelCalls.push({ provider, modelId })
+        state.model = { provider, id: modelId }
+      }
+    },
+    async publishContextUsage() {
+      // Context usage publishing is covered in test/unit/context-usage.test.ts.
+    }
+  }
+
+  const agent = new PiAcpAgent(asAgentConn(conn), {} as any)
+  ;(agent as any).sessions = new FakeSessions(session) as any
+
+  const result = await agent.setSessionConfigOption({
+    sessionId: 's1',
+    configId: 'model',
+    value: 'test/beta'
+  } as any)
+
+  assert.deepEqual(setModelCalls, [{ provider: 'test', modelId: 'beta' }])
+  assert.equal(result.configOptions.find(option => option.id === 'model')?.currentValue, 'test/beta')
+  assert.deepEqual(conn.updates, [
+    { sessionId: 's1', update: { sessionUpdate: 'current_mode_update', currentModeId: 'medium' } },
+    {
+      sessionId: 's1',
+      update: {
+        sessionUpdate: 'config_option_update',
+        configOptions: result.configOptions
+      }
+    }
+  ])
+})
+
+test('PiAcpAgent: setSessionConfigOption maps thought level changes to pi and emits sync updates', async () => {
+  const conn = new FakeAgentSideConnection()
+  const state = {
+    thinkingLevel: 'medium',
+    model: { provider: 'test', id: 'alpha' }
+  }
+  const thinkingLevels: string[] = []
+
+  const session = {
+    sessionId: 's1',
+    cwd: process.cwd(),
+    proc: {
+      async getAvailableThinkingLevels() {
+        return ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']
+      },
+      async getAvailableModels() {
+        return {
+          models: [{ provider: 'test', id: 'alpha', name: 'Alpha' }]
+        }
+      },
+      async getState() {
+        return state
+      },
+      async setThinkingLevel(level: string) {
+        thinkingLevels.push(level)
+        state.thinkingLevel = level
+      }
+    }
+  }
+
+  const agent = new PiAcpAgent(asAgentConn(conn), {} as any)
+  ;(agent as any).sessions = new FakeSessions(session) as any
+
+  const result = await agent.setSessionConfigOption({
+    sessionId: 's1',
+    configId: 'thought_level',
+    value: 'xhigh'
+  } as any)
+
+  assert.deepEqual(thinkingLevels, ['xhigh'])
+  assert.equal(result.configOptions.find(option => option.id === 'thought_level')?.currentValue, 'xhigh')
+  assert.deepEqual(conn.updates, [
+    {
+      sessionId: 's1',
+      update: {
+        sessionUpdate: 'current_mode_update',
+        currentModeId: 'xhigh'
+      }
+    },
+    {
+      sessionId: 's1',
+      update: {
+        sessionUpdate: 'config_option_update',
+        configOptions: result.configOptions
+      }
+    }
+  ])
+})

package/port/oracle/pi-acp/test/unit/session-delete.test.ts

@@ -0,0 +1,170 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { PiAcpAgent } from '../../src/acp/agent.js'
+import { FakeAgentSideConnection, asAgentConn } from '../helpers/fakes.js'
+
+test('PiAcpAgent: deleteSession removes stored session and session file', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-delete-test-'))
+  const sessionsDir = join(root, 'sessions', '--tmp--delete-project--')
+  const sessionFile = join(sessionsDir, '0000_delete_me.jsonl')
+  mkdirSync(sessionsDir, { recursive: true })
+  writeFileSync(
+    sessionFile,
+    '{"type":"session","version":3,"id":"sess-del-store","timestamp":"2026-06-16T00:00:00.000Z","cwd":"/tmp/delete-project"}\n',
+    'utf-8'
+  )
+
+  const oldEnv = process.env.PI_CODING_AGENT_DIR
+  process.env.PI_CODING_AGENT_DIR = root
+
+  const conn = new FakeAgentSideConnection()
+  const agent = new PiAcpAgent(asAgentConn(conn))
+
+  const storedSessionId = 'stored-session'
+  const storeDeletes: string[] = []
+
+  // Inject a SessionStore that tracks calls.
+  ;(agent as any).store = {
+    get(sessionId: string) {
+      if (sessionId !== storedSessionId) return null
+      return { sessionId, cwd: '/tmp/delete-project', sessionFile, updatedAt: new Date().toISOString() }
+    },
+    delete(sessionId: string) {
+      storeDeletes.push(sessionId)
+    },
+    upsert() {}
+  }
+
+  try {
+    const response = await agent.deleteSession({ sessionId: storedSessionId } as any)
+    assert.deepEqual(response, {})
+    assert.deepEqual(storeDeletes, [storedSessionId])
+    assert.equal(existsSync(sessionFile), false)
+  } finally {
+    if (oldEnv === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = oldEnv
+  }
+})
+
+test('PiAcpAgent: deleteSession finds session via pi discovery when SessionStore misses', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-delete-discovery-'))
+  const sessionsDir = join(root, 'sessions', '--tmp--delete-discovery--')
+  const sessionFile = join(sessionsDir, '0000_pi_discovery.jsonl')
+  mkdirSync(sessionsDir, { recursive: true })
+  writeFileSync(
+    sessionFile,
+    JSON.stringify({
+      type: 'session',
+      version: 3,
+      id: 'pi-discovered-session',
+      timestamp: '2026-06-16T00:00:00.000Z',
+      cwd: '/tmp/delete-discovery'
+    }) + '\n',
+    'utf-8'
+  )
+
+  const oldEnv = process.env.PI_CODING_AGENT_DIR
+  process.env.PI_CODING_AGENT_DIR = root
+
+  const conn = new FakeAgentSideConnection()
+  const agent = new PiAcpAgent(asAgentConn(conn))
+
+  const storeDeletes: string[] = []
+
+  ;(agent as any).store = {
+    get() {
+      return null
+    },
+    delete(sessionId: string) {
+      storeDeletes.push(sessionId)
+    },
+    upsert() {}
+  }
+
+  try {
+    const response = await agent.deleteSession({ sessionId: 'pi-discovered-session' } as any)
+    assert.deepEqual(response, {})
+    assert.deepEqual(storeDeletes, ['pi-discovered-session'])
+    assert.equal(existsSync(sessionFile), false)
+  } finally {
+    if (oldEnv === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = oldEnv
+  }
+})
+
+test('PiAcpAgent: deleteSession succeeds idempotently for unknown sessionId', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-delete-unknown-'))
+  const sessionsDir = join(root, 'sessions', '--tmp--delete-unknown--')
+  mkdirSync(sessionsDir, { recursive: true })
+
+  const oldEnv = process.env.PI_CODING_AGENT_DIR
+  process.env.PI_CODING_AGENT_DIR = root
+
+  const conn = new FakeAgentSideConnection()
+  const agent = new PiAcpAgent(asAgentConn(conn))
+
+  // Per ACP session/delete semantics, deleting a non-existent session
+  // should succeed idempotently (return {} without error).
+  const storeDeletes: string[] = []
+  ;(agent as any).store = {
+    get() {
+      return null
+    },
+    delete(sessionId: string) {
+      storeDeletes.push(sessionId)
+    },
+    upsert() {}
+  }
+
+  try {
+    const response = await agent.deleteSession({ sessionId: 'non-existent-session' } as any)
+    assert.deepEqual(response, {})
+    assert.deepEqual(storeDeletes, [])
+  } finally {
+    if (oldEnv === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = oldEnv
+  }
+})
+
+test('PiAcpAgent: deleteSession survives missing session file', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-delete-missingfile-'))
+  const sessionsDir = join(root, 'sessions', '--tmp--delete-missingfile--')
+  mkdirSync(sessionsDir, { recursive: true })
+  const nonExistentFile = join(sessionsDir, '0000_non_existent.jsonl')
+
+  const oldEnv = process.env.PI_CODING_AGENT_DIR
+  process.env.PI_CODING_AGENT_DIR = root
+
+  const conn = new FakeAgentSideConnection()
+  const agent = new PiAcpAgent(asAgentConn(conn))
+
+  const storeDeletes: string[] = []
+
+  ;(agent as any).store = {
+    get(sessionId: string) {
+      if (sessionId !== 'missing-file-session') return null
+      return {
+        sessionId,
+        cwd: '/tmp/delete-missingfile',
+        sessionFile: nonExistentFile,
+        updatedAt: new Date().toISOString()
+      }
+    },
+    delete(sessionId: string) {
+      storeDeletes.push(sessionId)
+    },
+    upsert() {}
+  }
+
+  try {
+    const response = await agent.deleteSession({ sessionId: 'missing-file-session' } as any)
+    assert.deepEqual(response, {})
+    assert.deepEqual(storeDeletes, ['missing-file-session'])
+  } finally {
+    if (oldEnv === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = oldEnv
+  }
+})

package/port/oracle/pi-acp/test/unit/session-restore.test.ts

@@ -0,0 +1,239 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { PiAcpAgent } from '../../src/acp/agent.js'
+import { PiRpcProcess } from '../../src/pi-rpc/process.js'
+import { FakeAgentSideConnection, asAgentConn } from '../helpers/fakes.js'
+
+class FakeSessions {
+  restoredSession: any = null
+
+  constructor(private readonly buildSession: (sessionId: string, params: any) => any) {}
+
+  maybeGet(sessionId: string) {
+    return this.restoredSession?.sessionId === sessionId ? this.restoredSession : undefined
+  }
+
+  getOrCreate(sessionId: string, params: any) {
+    if (!this.restoredSession) {
+      this.restoredSession = this.buildSession(sessionId, params)
+    }
+    return this.restoredSession
+  }
+}
+
+test('PiAcpAgent: prompt auto-restores a missing session from SessionStore', async () => {
+  const conn = new FakeAgentSideConnection()
+  const promptCalls: Array<{ message: string; images: unknown[] }> = []
+  const spawnCalls: any[] = []
+  const storeUpserts: any[] = []
+
+  const sessions = new FakeSessions((sessionId, params) => ({
+    sessionId,
+    cwd: params.cwd,
+    proc: params.proc,
+    async prompt(message: string, images: unknown[]) {
+      promptCalls.push({ message, images })
+      return 'end_turn'
+    },
+    async cancel() {},
+    wasCancelRequested() {
+      return false
+    }
+  }))
+
+  const originalSpawn = PiRpcProcess.spawn
+  ;(PiRpcProcess as any).spawn = async (params: any) => {
+    spawnCalls.push(params)
+    return {
+      onEvent: () => () => {}
+    } as any
+  }
+
+  try {
+    const agent = new PiAcpAgent(asAgentConn(conn), {} as any)
+    ;(agent as any).sessions = sessions as any
+    ;(agent as any).store = {
+      get(sessionId: string) {
+        if (sessionId !== 'stored-session') return null
+        return {
+          sessionId,
+          cwd: '/tmp/store-project',
+          sessionFile: '/tmp/store-project/session.jsonl',
+          updatedAt: new Date().toISOString()
+        }
+      },
+      upsert(entry: any) {
+        storeUpserts.push(entry)
+      }
+    }
+
+    const result = await agent.prompt({
+      sessionId: 'stored-session',
+      prompt: [{ type: 'text', text: 'hello again' }]
+    } as any)
+
+    assert.equal(result.stopReason, 'end_turn')
+    assert.deepEqual(spawnCalls, [
+      {
+        cwd: '/tmp/store-project',
+        sessionPath: '/tmp/store-project/session.jsonl',
+        piCommand: process.env.PI_ACP_PI_COMMAND
+      }
+    ])
+    assert.deepEqual(promptCalls, [{ message: 'hello again', images: [] }])
+    assert.deepEqual(storeUpserts, [
+      {
+        sessionId: 'stored-session',
+        cwd: '/tmp/store-project',
+        sessionFile: '/tmp/store-project/session.jsonl'
+      }
+    ])
+  } finally {
+    PiRpcProcess.spawn = originalSpawn
+  }
+})
+
+test('PiAcpAgent: setSessionConfigOption auto-restores via pi session discovery when SessionStore misses', async () => {
+  const conn = new FakeAgentSideConnection()
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-restore-fallback-'))
+  const sessionsDir = join(root, 'sessions', '--tmp--fallback-project--')
+  const sessionFile = join(sessionsDir, '0000_restore_fallback.jsonl')
+  const prevAgentDir = process.env.PI_CODING_AGENT_DIR
+
+  mkdirSync(sessionsDir, { recursive: true })
+  writeFileSync(
+    sessionFile,
+    JSON.stringify({
+      type: 'session',
+      version: 3,
+      id: 'fallback-session',
+      timestamp: '2026-06-16T00:00:00.000Z',
+      cwd: '/tmp/fallback-project'
+    }) + '\n',
+    'utf-8'
+  )
+
+  process.env.PI_CODING_AGENT_DIR = root
+
+  const storeUpserts: any[] = []
+  const setModelCalls: Array<{ provider: string; modelId: string }> = []
+  const spawnCalls: any[] = []
+  const state = {
+    thinkingLevel: 'medium',
+    model: { provider: 'test', id: 'alpha' }
+  }
+
+  const sessions = new FakeSessions((sessionId, params) => ({
+    sessionId,
+    cwd: params.cwd,
+    proc: params.proc,
+    async publishContextUsage() {
+      // Context usage publishing is covered in test/unit/context-usage.test.ts.
+    }
+  }))
+
+  const originalSpawn = PiRpcProcess.spawn
+  ;(PiRpcProcess as any).spawn = async (params: any) => {
+    spawnCalls.push(params)
+    return {
+      onEvent: () => () => {},
+      getAvailableThinkingLevels: async () => ['medium'],
+      getAvailableModels: async () => ({
+        models: [
+          { provider: 'test', id: 'alpha', name: 'Alpha' },
+          { provider: 'test', id: 'beta', name: 'Beta' }
+        ]
+      }),
+      getState: async () => state,
+      async setModel(provider: string, modelId: string) {
+        setModelCalls.push({ provider, modelId })
+        state.model = { provider, id: modelId }
+      }
+    } as any
+  }
+
+  try {
+    const agent = new PiAcpAgent(asAgentConn(conn), {} as any)
+    ;(agent as any).sessions = sessions as any
+    ;(agent as any).store = {
+      get() {
+        return null
+      },
+      upsert(entry: any) {
+        storeUpserts.push(entry)
+      }
+    }
+
+    const result = await agent.setSessionConfigOption({
+      sessionId: 'fallback-session',
+      configId: 'model',
+      value: 'test/beta'
+    } as any)
+
+    assert.deepEqual(spawnCalls, [
+      {
+        cwd: '/tmp/fallback-project',
+        sessionPath: sessionFile,
+        piCommand: process.env.PI_ACP_PI_COMMAND
+      }
+    ])
+    assert.deepEqual(setModelCalls, [{ provider: 'test', modelId: 'beta' }])
+    assert.equal(result.configOptions.find(option => option.id === 'model')?.currentValue, 'test/beta')
+    assert.deepEqual(storeUpserts, [
+      {
+        sessionId: 'fallback-session',
+        cwd: '/tmp/fallback-project',
+        sessionFile
+      },
+      {
+        sessionId: 'fallback-session',
+        cwd: '/tmp/fallback-project',
+        sessionFile
+      }
+    ])
+    assert.deepEqual(conn.updates, [
+      { sessionId: 'fallback-session', update: { sessionUpdate: 'current_mode_update', currentModeId: 'medium' } },
+      {
+        sessionId: 'fallback-session',
+        update: {
+          sessionUpdate: 'config_option_update',
+          configOptions: result.configOptions
+        }
+      }
+    ])
+  } finally {
+    PiRpcProcess.spawn = originalSpawn
+    if (prevAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR
+    else process.env.PI_CODING_AGENT_DIR = prevAgentDir
+  }
+})
+
+test('PiAcpAgent: cancel ignores stale session IDs without spawning a restore process', async () => {
+  const conn = new FakeAgentSideConnection()
+  const spawnCalls: any[] = []
+
+  const originalSpawn = PiRpcProcess.spawn
+  ;(PiRpcProcess as any).spawn = async (params: any) => {
+    spawnCalls.push(params)
+    return {
+      onEvent: () => () => {}
+    } as any
+  }
+
+  try {
+    const agent = new PiAcpAgent(asAgentConn(conn), {} as any)
+    ;(agent as any).sessions = new FakeSessions(() => {
+      throw new Error('cancel should not restore a missing session')
+    }) as any
+
+    await agent.cancel({ sessionId: 'stale-session' } as any)
+
+    assert.deepEqual(spawnCalls, [])
+    assert.deepEqual(conn.updates, [])
+  } finally {
+    PiRpcProcess.spawn = originalSpawn
+  }
+})

package/port/oracle/pi-acp/test/unit/slash-commands.test.ts

@@ -0,0 +1,36 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  expandSlashCommand,
+  parseCommandArgs,
+  substituteArgs,
+  toAvailableCommands
+} from '../../src/acp/slash-commands.js'
+
+test('parseCommandArgs: handles quotes', () => {
+  assert.deepEqual(parseCommandArgs('a b'), ['a', 'b'])
+  assert.deepEqual(parseCommandArgs("'a b' c"), ['a b', 'c'])
+  assert.deepEqual(parseCommandArgs('"a b" c'), ['a b', 'c'])
+})
+
+test('substituteArgs: replaces $1.. and $@', () => {
+  assert.equal(substituteArgs('x=$1 y=$2 all=$@', ['one', 'two']).trim(), 'x=one y=two all=one two')
+  assert.equal(substituteArgs('$3', ['one']).trim(), '')
+})
+
+test('expandSlashCommand: expands known command', () => {
+  const cmds = [{ name: 'hello', description: '(user)', content: 'Say hi to $1', source: '(user)' }]
+
+  assert.equal(expandSlashCommand('/hello world', cmds as any), 'Say hi to world')
+  assert.equal(expandSlashCommand('/unknown world', cmds as any), '/unknown world')
+  assert.equal(expandSlashCommand('not a command', cmds as any), 'not a command')
+})
+
+test('toAvailableCommands: de-dupes by name (first wins)', () => {
+  const cmds = [
+    { name: 'x', description: 'first', content: '1', source: '(user)' },
+    { name: 'x', description: 'second', content: '2', source: '(project)' }
+  ]
+
+  assert.deepEqual(toAvailableCommands(cmds as any), [{ name: 'x', description: 'first' }])
+})