bazilion 0.0.0 → 0.1.0

package/apps/cli/test/chat.test.ts

@@ -1,539 +0,0 @@
-import { createServer, type ServerResponse } from 'node:http'
-import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest'
-import { openDb, resolveAgent, resolvePaths } from '../../daemon/src/core/index.ts'
-import { countSessionMessagesForTest, seedSessionForTest } from '../../daemon/src/runtime/index.ts'
-import { extractAgentId } from './helpers.ts'
-import { startTestServer, type TestServer } from './server-fixture.ts'
-
-type MockHandler = unknown | ((res: ServerResponse) => void)
-
-interface MockLlm {
-  url: string
-  push(responses: MockHandler[]): void
-  reset(): void
-  callCount(): number
-  stop(): Promise<void>
-}
-
-interface CannedMessage {
-  role?: string
-  content?: string | null
-  tool_calls?: Array<{
-    id: string
-    type: string
-    function: { name: string; arguments: string }
-  }>
-}
-interface CannedChoice {
-  message: CannedMessage
-  finish_reason?: string
-}
-interface CannedResponse {
-  choices: CannedChoice[]
-  usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number }
-}
-
-/**
- * Translate a canned non-streaming OpenAI-shaped response into OpenAI SSE
- * chunks and write them to `res`. Pi-ai's openai-completions client always
- * runs in `stream: true` mode, so LMStudio-style JSON bodies need to be
- * re-chunked into `data: {...}\n\n` lines terminated by `data: [DONE]`.
- */
-function writeSseFromCanned(res: ServerResponse, canned: CannedResponse): void {
-  res.writeHead(200, {
-    'content-type': 'text/event-stream',
-    'cache-control': 'no-cache',
-    connection: 'keep-alive',
-  })
-  const choice = canned.choices[0]
-  const message = choice?.message ?? {}
-  const finish = choice?.finish_reason ?? 'stop'
-
-  // Role delta (always first in OpenAI's SSE protocol).
-  const roleChunk = {
-    id: 'chatcmpl-mock',
-    object: 'chat.completion.chunk',
-    choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
-  }
-  res.write(`data: ${JSON.stringify(roleChunk)}\n\n`)
-
-  if (typeof message.content === 'string' && message.content.length > 0) {
-    const textChunk = {
-      id: 'chatcmpl-mock',
-      object: 'chat.completion.chunk',
-      choices: [{ index: 0, delta: { content: message.content }, finish_reason: null }],
-    }
-    res.write(`data: ${JSON.stringify(textChunk)}\n\n`)
-  }
-
-  if (message.tool_calls && message.tool_calls.length > 0) {
-    const toolChunk = {
-      id: 'chatcmpl-mock',
-      object: 'chat.completion.chunk',
-      choices: [
-        {
-          index: 0,
-          delta: {
-            tool_calls: message.tool_calls.map((tc, i) => ({
-              index: i,
-              id: tc.id,
-              type: tc.type,
-              function: { name: tc.function.name, arguments: tc.function.arguments },
-            })),
-          },
-          finish_reason: null,
-        },
-      ],
-    }
-    res.write(`data: ${JSON.stringify(toolChunk)}\n\n`)
-  }
-
-  const finalChunk = {
-    id: 'chatcmpl-mock',
-    object: 'chat.completion.chunk',
-    choices: [{ index: 0, delta: {}, finish_reason: finish }],
-    usage: canned.usage,
-  }
-  res.write(`data: ${JSON.stringify(finalChunk)}\n\n`)
-  res.write('data: [DONE]\n\n')
-  res.end()
-}
-
-/**
- * Start a node:http server that serves LMStudio-style /v1/chat/completions
- * responses from an in-memory queue. Push responses before each `agent chat`
- * turn — the server consumes them in order. Queue items may be objects
- * (OpenAI-shaped non-streaming responses, translated to SSE on the wire) or
- * functions `(res) => void` for custom behavior (e.g. a handler that never
- * responds, to exercise client-side cancellation).
- */
-function startLmStudioMock(): Promise<MockLlm> {
-  const queue: MockHandler[] = []
-  let calls = 0
-  const server = createServer((_req, res) => {
-    calls++
-    if (queue.length === 0) {
-      res.writeHead(500, { 'content-type': 'text/plain' })
-      res.end('mock response queue empty')
-      return
-    }
-    const item = queue.shift()
-    if (typeof item === 'function') {
-      ;(item as (res: ServerResponse) => void)(res)
-      return
-    }
-    writeSseFromCanned(res, item as CannedResponse)
-  })
-  return new Promise((resolve) => {
-    server.listen(0, () => {
-      const addr = server.address()
-      if (!addr || typeof addr === 'string') throw new Error('unexpected server address')
-      resolve({
-        url: `http://localhost:${addr.port}/v1`,
-        push(items) {
-          queue.push(...items)
-        },
-        reset() {
-          queue.length = 0
-          calls = 0
-        },
-        callCount: () => calls,
-        stop: () => new Promise((r) => server.close(() => r())),
-      })
-    })
-  })
-}
-
-let mock: MockLlm
-let server: TestServer
-
-beforeAll(async () => {
-  mock = await startLmStudioMock()
-  server = await startTestServer({ LMSTUDIO_URL: mock.url })
-})
-afterAll(async () => {
-  await server.stop()
-  await mock.stop()
-})
-beforeEach(() => {
-  mock.reset()
-  server.reset()
-})
-
-async function spawnLmStudioAgent(): Promise<string> {
-  await server.cli(['profile', 'create', 'p', '--model', 'lmstudio:test-model'])
-  const r = await server.cli(['agent', 'spawn', '--profile', 'p'])
-  return extractAgentId(r.stdout)
-}
-
-test('agent chat --message round-trips with the provider', async () => {
-  const agentId = await spawnLmStudioAgent()
-  mock.push([
-    {
-      choices: [
-        {
-          message: { role: 'assistant', content: 'hello from mock' },
-          finish_reason: 'stop',
-        },
-      ],
-    },
-  ])
-
-  const r = await server.cli(['agent', 'chat', agentId, '--message', 'hi'])
-  expect(r.exitCode).toBe(0)
-  expect(r.stdout).toContain('hello from mock')
-})
-
-test('memory persists across chat invocations', async () => {
-  const agentId = await spawnLmStudioAgent()
-
-  // Session 1: agent saves a memory via tool call
-  mock.push([
-    {
-      choices: [
-        {
-          message: {
-            role: 'assistant',
-            content: null,
-            tool_calls: [
-              {
-                id: 'call_1',
-                type: 'function',
-                function: {
-                  name: 'memory_write',
-                  arguments: '{"key":"prefs.md","content":"User likes hiking on Sundays."}',
-                },
-              },
-            ],
-          },
-          finish_reason: 'tool_calls',
-        },
-      ],
-    },
-    {
-      choices: [
-        {
-          message: { role: 'assistant', content: 'Got it, saved.' },
-          finish_reason: 'stop',
-        },
-      ],
-    },
-  ])
-  let r = await server.cli(['agent', 'chat', agentId, '--message', 'I like hiking on Sundays'])
-  expect(r.exitCode).toBe(0)
-  expect(r.stdout).toContain('memory_write')
-  expect(r.stdout).toContain('Got it')
-
-  // Session 2: new chat invocation, agent searches memory and finds it
-  mock.push([
-    {
-      choices: [
-        {
-          message: {
-            role: 'assistant',
-            content: null,
-            tool_calls: [
-              {
-                id: 'call_2',
-                type: 'function',
-                function: { name: 'memory_search', arguments: '{"query":"hiking"}' },
-              },
-            ],
-          },
-          finish_reason: 'tool_calls',
-        },
-      ],
-    },
-    {
-      choices: [
-        {
-          message: { role: 'assistant', content: 'You like hiking on Sundays.' },
-          finish_reason: 'stop',
-        },
-      ],
-    },
-  ])
-  r = await server.cli(['agent', 'chat', agentId, '--message', 'what do I like to do on weekends?'])
-  expect(r.exitCode).toBe(0)
-  expect(r.stdout).toContain('hiking')
-  expect(r.stdout).toContain('You like hiking on Sundays')
-})
-
-test('BOOTSTRAP.md is removed when bootstrap_done tool is called', async () => {
-  const agentId = await spawnLmStudioAgent()
-  mock.push([
-    {
-      choices: [
-        {
-          message: {
-            role: 'assistant',
-            content: null,
-            tool_calls: [
-              {
-                id: 'call_1',
-                type: 'function',
-                function: { name: 'bootstrap_done', arguments: '{}' },
-              },
-            ],
-          },
-          finish_reason: 'tool_calls',
-        },
-      ],
-    },
-    {
-      choices: [
-        {
-          message: { role: 'assistant', content: 'Welcome aboard.' },
-          finish_reason: 'stop',
-        },
-      ],
-    },
-  ])
-
-  const r = await server.cli(['agent', 'chat', agentId, '--message', 'I am ready'])
-  expect(r.exitCode).toBe(0)
-  expect(r.stdout).toContain('bootstrap_done')
-
-  // Verify BOOTSTRAP.md is gone via agent show (which reads the dir path)
-  const show = await server.cli(['agent', 'show', agentId])
-  expect(show.exitCode).toBe(0)
-  const m = show.stdout.match(/dir:\s+(\S+)/)
-  expect(m?.[1]).toBeDefined()
-  if (m?.[1]) {
-    const { existsSync } = await import('node:fs')
-    const { join } = await import('node:path')
-    expect(existsSync(join(m[1], 'BOOTSTRAP.md'))).toBe(false)
-  }
-})
-
-test('failed turn surfaces an error event and leaves the agent ready for a retry', async () => {
-  // Pi's SessionManager writes entries as they happen (not at turn end), so
-  // a failed turn doesn't "roll back" a user message the way the old
-  // pre-pi worker did. The test's concern here is simpler: a non-retryable
-  // provider error surfaces as an error event, and a fresh follow-up turn
-  // succeeds cleanly.
-  const agentId = await spawnLmStudioAgent()
-
-  mock.push([
-    (res: ServerResponse) => {
-      res.writeHead(400, { 'content-type': 'application/json' })
-      res.end(JSON.stringify({ error: { code: 'invalid_request', message: 'bad model' } }))
-    },
-  ])
-
-  const failR = await server.cli(['agent', 'chat', agentId, '--message', 'go on'])
-  expect(failR.stdout).toMatch(/\[error:/)
-
-  mock.push([
-    {
-      choices: [
-        { message: { role: 'assistant', content: 'recovered reply' }, finish_reason: 'stop' },
-      ],
-    },
-  ])
-  const okR = await server.cli(['agent', 'chat', agentId, '--message', 'go on'])
-  expect(okR.exitCode).toBe(0)
-  expect(okR.stdout).toContain('recovered reply')
-})
-
-test('agent chat can be cancelled mid-flight via `agent cancel`', async () => {
-  const agentId = await spawnLmStudioAgent()
-
-  // The mock's sole handler never responds — the provider's fetch will hang
-  // until its AbortSignal fires, giving us a window to cancel the turn.
-  const callCountBefore = mock.callCount()
-  mock.push([
-    (_res: ServerResponse) => {
-      // intentionally left hanging
-    },
-  ])
-
-  // Kick off the chat in the background. The CLI subprocess will block
-  // inside the NDJSON stream until abort.
-  const chatPromise = server.cli(['agent', 'chat', agentId, '--message', 'hi'])
-
-  // Wait for the worker to actually reach the provider fetch (mock receives a
-  // request). Cancelling earlier races with worker startup — SIGTERM during
-  // Node bootstrap has no handler installed and exits with the signal,
-  // producing "worker killed by SIGTERM" instead of the cancelled-event path.
-  let providerHit = false
-  for (let i = 0; i < 100; i++) {
-    if (mock.callCount() > callCountBefore) {
-      providerHit = true
-      break
-    }
-    await new Promise((r) => setTimeout(r, 100))
-  }
-  if (!providerHit) throw new Error('worker did not reach the provider fetch in time')
-
-  const cancelR = await server.cli(['agent', 'cancel', agentId])
-  expect(cancelR.exitCode).toBe(0)
-
-  // The chat subprocess should terminate promptly. With the mock still
-  // hanging, the fetch must have been aborted — otherwise this would time
-  // out. Pi surfaces aborts as a `cancelled` error or provider-side text
-  // like "Request was aborted." — accept either.
-  const chatR = await chatPromise
-  expect(chatR.stdout + chatR.stderr).toMatch(/cancelled|aborted/i)
-})
-
-// --- chat-reset + chat-trim ---
-
-// Seed a canonical pi session file on disk with `n` synthetic user/assistant
-// messages. The on-disk JSONL is the authoritative source of conversation
-// state after migration 0004 dropped `chat_messages`; hitting tests at this
-// layer keeps them faithful to what a real worker writes. See
-// `seedSessionForTest` in runtime for the underlying pi SessionManager
-// append calls.
-function seedChatHistory(home: string, agentId: string, n: number): void {
-  const paths = resolvePaths(home)
-  const db = openDb(paths.db)
-  try {
-    const resolved = resolveAgent(db, paths, agentId)
-    const messages = Array.from({ length: n }, (_, i) =>
-      i % 2 === 0
-        ? { role: 'user' as const, text: `msg ${i}` }
-        : { role: 'assistant' as const, text: `reply ${i}` },
-    )
-    seedSessionForTest(resolved, paths, messages)
-  } finally {
-    db.close()
-  }
-}
-
-function readChatLen(home: string, agentId: string): number {
-  const paths = resolvePaths(home)
-  const db = openDb(paths.db)
-  try {
-    const resolved = resolveAgent(db, paths, agentId)
-    return countSessionMessagesForTest(resolved, paths)
-  } finally {
-    db.close()
-  }
-}
-
-test('agent chat-reset --force wipes history without prompting', async () => {
-  const agentId = await spawnLmStudioAgent()
-  seedChatHistory(server.home, agentId, 6)
-  expect(readChatLen(server.home, agentId)).toBe(6)
-
-  const r = await server.cli(['agent', 'chat-reset', agentId, '--force'])
-  expect(r.exitCode).toBe(0)
-  expect(r.stdout).toContain('reset')
-  expect(readChatLen(server.home, agentId)).toBe(0)
-})
-
-test('agent chat-trim reports the before/after counts from pi branching', async () => {
-  const agentId = await spawnLmStudioAgent()
-  seedChatHistory(server.home, agentId, 6)
-
-  const r = await server.cli(['agent', 'chat-trim', agentId, '--keep', '3'])
-  expect(r.exitCode).toBe(0)
-  // Pi's `branch()` moves the leaf pointer in-memory; the session file
-  // keeps the original entries on disk (append-only). The next turn
-  // will resume from the branched leaf. CLI output is what we assert.
-  expect(r.stdout).toMatch(/6 → 3/)
-})
-
-test('agent chat-trim rejects non-integer --keep with a clear error', async () => {
-  const agentId = await spawnLmStudioAgent()
-  seedChatHistory(server.home, agentId, 4)
-
-  const r = await server.cli(['agent', 'chat-trim', agentId, '--keep', '2.5'])
-  expect(r.exitCode).not.toBe(0)
-  expect(r.stderr + r.stdout).toMatch(/non-negative integer/)
-  // Session file untouched on invalid input
-  expect(readChatLen(server.home, agentId)).toBe(4)
-})
-
-// --- chat-context + chat-compact ---
-
-test('agent chat-context reports system prompt, tools, skills, history breakdown', async () => {
-  const agentId = await spawnLmStudioAgent()
-  seedChatHistory(server.home, agentId, 6)
-
-  const r = await server.cli(['agent', 'chat-context', agentId])
-  expect(r.exitCode).toBe(0)
-  expect(r.stdout).toMatch(/## system prompt/)
-  expect(r.stdout).toMatch(/## tools/)
-  expect(r.stdout).toMatch(/count:\s+\d+/)
-  // 6 seeded message entries, 0 compactions
-  expect(r.stdout).toMatch(/messages:\s+6/)
-  expect(r.stdout).toMatch(/compactions:\s+0/)
-  expect(r.stdout).toMatch(/TOTAL:/)
-})
-
-test('agent chat-context --json emits the structured ChatContextResponse', async () => {
-  const agentId = await spawnLmStudioAgent()
-  seedChatHistory(server.home, agentId, 4)
-
-  const r = await server.cli(['agent', 'chat-context', agentId, '--json'])
-  expect(r.exitCode).toBe(0)
-  const body = JSON.parse(r.stdout)
-  expect(body.agentId).toBe(agentId)
-  expect(typeof body.model).toBe('string')
-  expect(body.history).toMatchObject({ messageEntries: 4, compactionEntries: 0 })
-  expect(typeof body.history.chars).toBe('number')
-  expect(typeof body.history.bytes).toBe('number')
-  expect(typeof body.history.tokensEstimate).toBe('number')
-  expect(typeof body.tools.count).toBe('number')
-  expect(Array.isArray(body.tools.entries)).toBe(true)
-  expect(typeof body.totals.chars).toBe('number')
-})
-
-test('agent chat-context on an empty history returns zero history entries', async () => {
-  const agentId = await spawnLmStudioAgent()
-  const r = await server.cli(['agent', 'chat-context', agentId, '--json'])
-  expect(r.exitCode).toBe(0)
-  const body = JSON.parse(r.stdout)
-  expect(body.history).toMatchObject({
-    messageEntries: 0,
-    compactionEntries: 0,
-    chars: 0,
-  })
-  // System prompt + tools still contribute to totals even on a fresh agent.
-  expect(body.totals.chars).toBeGreaterThan(0)
-})
-
-test('agent chat-compact summarizes the head via pi session.compact', async () => {
-  const agentId = await spawnLmStudioAgent()
-  seedChatHistory(server.home, agentId, 10)
-
-  // Pi's session.compact() uses the agent's current model to generate the
-  // summary — the mock has to answer one LLM call.
-  mock.push([
-    {
-      choices: [
-        {
-          message: {
-            role: 'assistant',
-            content: 'The user sent several questions; assistant replied each time.',
-          },
-          finish_reason: 'stop',
-        },
-      ],
-    },
-  ])
-
-  const r = await server.cli(['agent', 'chat-compact', agentId, '--force'])
-  // Pi may be stricter than us about when it bothers to compact; allow
-  // either a success summary or a "nothing to compact" refusal. The key
-  // thing is the endpoint runs without throwing.
-  if (r.exitCode === 0) {
-    expect(r.stdout).toMatch(/compacted:/)
-  } else {
-    // Non-zero exit is acceptable when pi declines to compact a small
-    // history. Surface the error reason for diagnostics.
-    expect(r.stderr + r.stdout).toMatch(/(error|nothing)/i)
-  }
-})
-
-test('agent chat-compact errors out on empty history', async () => {
-  const agentId = await spawnLmStudioAgent()
-  const r = await server.cli(['agent', 'chat-compact', agentId, '--force'])
-  // With no session file at all, pi either refuses or succeeds with a
-  // trivial empty compaction. We assert the command completes without a
-  // worker crash — actual exit code depends on pi's behavior for empty
-  // sessions, which can change between pi releases.
-  expect(r.stdout + r.stderr).toBeTruthy()
-})

package/apps/cli/test/columnize.test.ts

@@ -1,29 +0,0 @@
-import { expect, test } from 'vitest'
-import { columnize } from '../src/columnize.ts'
-
-test('pads each column to its widest cell', () => {
-  const out = columnize([
-    ['a', 'short', 'x'],
-    ['ab', 'longer-word', 'y'],
-    ['abc', 'x', 'z'],
-  ])
-  expect(out).toEqual(['a    short        x', 'ab   longer-word  y', 'abc  x            z'])
-})
-
-test("doesn't pad the trailing column (keeps `| wc` friendly)", () => {
-  const out = columnize([
-    ['a', 'b'],
-    ['aa', 'bb'],
-  ])
-  for (const line of out) {
-    expect(line.endsWith(' ')).toBe(false)
-  }
-})
-
-test('empty input returns empty output', () => {
-  expect(columnize([])).toEqual([])
-})
-
-test('single-row tables still align the first columns', () => {
-  expect(columnize([['a', 'b', 'c']])).toEqual(['a  b  c'])
-})

package/apps/cli/test/completion.test.ts

@@ -1,45 +0,0 @@
-import { afterEach, beforeEach, expect, test } from 'vitest'
-import { makeHome, runCli, type TestHome } from './helpers.ts'
-
-let h: TestHome
-beforeEach(() => {
-  h = makeHome()
-})
-afterEach(() => h.cleanup())
-
-test('completion bash prints a sourceable function + complete directive', async () => {
-  const res = await runCli(['completion', 'bash'], h.home)
-  expect(res.exitCode).toBe(0)
-  expect(res.stdout).toContain('_bazilion_completion()')
-  expect(res.stdout).toContain('complete -F _bazilion_completion bazilion')
-  // Top-level subcommands are enumerated
-  expect(res.stdout).toContain('"serve')
-  expect(res.stdout).toContain('agent')
-  expect(res.stdout).toContain('backup')
-  // Nested subcommand case arm exists
-  expect(res.stdout).toContain('"agent")')
-  expect(res.stdout).toContain('"agent chat")')
-  // Flag enumeration (at least one known flag)
-  expect(res.stdout).toContain('--profile')
-})
-
-test('completion zsh wraps bashcompinit around the bash script', async () => {
-  const res = await runCli(['completion', 'zsh'], h.home)
-  expect(res.exitCode).toBe(0)
-  expect(res.stdout).toContain('bashcompinit')
-  expect(res.stdout).toContain('_bazilion_completion()')
-})
-
-test('completion fish emits subcommand + guard rules', async () => {
-  const res = await runCli(['completion', 'fish'], h.home)
-  expect(res.exitCode).toBe(0)
-  expect(res.stdout).toContain('complete -c bazilion')
-  expect(res.stdout).toContain('__fish_use_subcommand')
-  expect(res.stdout).toContain('__fish_seen_subcommand_from agent')
-})
-
-test('completion rejects an unknown shell', async () => {
-  const res = await runCli(['completion', 'tcsh'], h.home)
-  expect(res.exitCode).not.toBe(0)
-  expect(res.stderr + res.stdout).toMatch(/unsupported shell: tcsh/)
-})