@otto-assistant/bridge 0.4.92

package/src/logger.ts

@@ -0,0 +1,208 @@
+// Prefixed logging utility using @clack/prompts for consistent visual style.
+// All log methods use clack's log.message() with appropriate symbols to prevent
+// output interleaving from concurrent async operations.
+
+import { log as clackLog } from '@clack/prompts'
+import fs from 'node:fs'
+import path from 'node:path'
+import util from 'node:util'
+import pc from 'picocolors'
+import { sanitizeSensitiveText, sanitizeUnknownValue } from './privacy-sanitizer.js'
+
+// All known log prefixes - add new ones here to keep alignment consistent
+export const LogPrefix = {
+  ABORT: 'ABORT',
+  ADD_PROJECT: 'ADD_PROJ',
+  AGENT: 'AGENT',
+  ASK_QUESTION: 'QUESTION',
+  CHANNEL: 'CHANNEL',
+  CLI: 'CLI',
+  COMPACT: 'COMPACT',
+  CREATE_PROJECT: 'NEW_PROJ',
+  DB: 'DB',
+  DIFF: 'DIFF',
+  FILE_UPLOAD: 'FILEUP',
+  DISCORD: 'DISCORD',
+  FORK: 'FORK',
+  FORMATTING: 'FORMAT',
+  GENAI: 'GENAI',
+  HEAP: 'HEAP',
+  GENAI_WORKER: 'GENAI_W',
+  INTERACTION: 'INTERACT',
+  IPC: 'IPC',
+  LOGIN: 'LOGIN',
+  MARKDOWN: 'MARKDOWN',
+  MCP: 'MCP',
+  MODEL: 'MODEL',
+  OPENAI: 'OPENAI',
+  OPENCODE: 'OPENCODE',
+  PERMISSIONS: 'PERMS',
+  QUEUE: 'QUEUE',
+  REMOVE_PROJECT: 'RM_PROJ',
+  RESUME: 'RESUME',
+  SESSION: 'SESSION',
+  SHARE: 'SHARE',
+  TASK: 'TASK',
+  TOOLS: 'TOOLS',
+  UNDO_REDO: 'UNDO',
+  USER_CMD: 'USER_CMD',
+  VERBOSITY: 'VERBOSE',
+  VOICE: 'VOICE',
+  WORKER: 'WORKER',
+  THINKING: 'THINK',
+  WORKTREE: 'WORKTREE',
+  XML: 'XML',
+} as const
+
+export type LogPrefixType = (typeof LogPrefix)[keyof typeof LogPrefix]
+
+// compute max length from all known prefixes for alignment
+const MAX_PREFIX_LENGTH = Math.max(
+  ...Object.values(LogPrefix).map((p) => p.length),
+)
+
+// Log file path is set by initLogFile() after the data directory is known.
+// Before initLogFile() is called, file logging is skipped.
+let logFilePath: string | null = null
+
+/**
+ * Initialize file logging. Call this after setDataDir() so the log file
+ * is written to `<dataDir>/kimaki.log`. The log file is truncated on
+ * every bot startup so it contains only the current run's logs.
+ */
+export function initLogFile(dataDir: string): void {
+  logFilePath = path.join(dataDir, 'kimaki.log')
+  const logDir = path.dirname(logFilePath)
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true })
+  }
+  fs.writeFileSync(
+    logFilePath,
+    `--- kimaki log started at ${new Date().toISOString()} ---\n`,
+  )
+}
+
+/**
+ * Set the log file path without truncating. Use this in child processes
+ * (like the opencode plugin) that should append to the same log file
+ * the bot process already created with initLogFile().
+ */
+export function setLogFilePath(dataDir: string): void {
+  logFilePath = path.join(dataDir, 'kimaki.log')
+}
+
+export function getLogFilePath(): string | null {
+  return logFilePath
+}
+
+function formatArg(arg: unknown): string {
+  if (typeof arg === 'string') {
+    return sanitizeSensitiveText(arg, { redactPaths: false })
+  }
+  const safeArg = sanitizeUnknownValue(arg, { redactPaths: false })
+  return util.inspect(safeArg, { colors: true, depth: 4 })
+}
+
+export function formatErrorWithStack(error: unknown): string {
+  if (error instanceof Error) {
+    return sanitizeSensitiveText(
+      error.stack ?? `${error.name}: ${error.message}`,
+      { redactPaths: false },
+    )
+  }
+  if (typeof error === 'string') {
+    return sanitizeSensitiveText(error, { redactPaths: false })
+  }
+
+  // Keep this stable and safe for unknown values (handles circular structures).
+  const safeError = sanitizeUnknownValue(error, { redactPaths: false })
+  return sanitizeSensitiveText(util.inspect(safeError, { colors: false, depth: 4 }), {
+    redactPaths: false,
+  })
+}
+
+function writeToFile(level: string, prefix: string, args: unknown[]) {
+  const timestamp = new Date().toISOString()
+  const message = `[${timestamp}] [${level}] [${prefix}] ${args.map(formatArg).join(' ')}\n`
+  if (!logFilePath) {
+    return
+  }
+  fs.appendFileSync(logFilePath, message)
+}
+
+function getTimestamp(): string {
+  const now = new Date()
+  return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`
+}
+
+function padPrefix(prefix: string): string {
+  return prefix.padEnd(MAX_PREFIX_LENGTH)
+}
+
+function formatMessage(
+  timestamp: string,
+  prefix: string,
+  args: unknown[],
+): string {
+  return [pc.dim(timestamp), prefix, ...args.map(formatArg)].join(' ')
+}
+
+const noSpacing = { spacing: 0 }
+
+// Suppress clack terminal output during vitest runs to avoid flooding
+// test output with hundreds of log lines. File logging still works.
+// Set KIMAKI_TEST_LOGS=1 when rerunning a failing test to see all
+// kimaki logger output in the terminal for debugging.
+const isVitest = !!process.env['KIMAKI_VITEST']
+const showTestLogs = isVitest && !!process.env['KIMAKI_TEST_LOGS']
+
+export function createLogger(prefix: LogPrefixType | string) {
+  const paddedPrefix = padPrefix(prefix)
+  const suppressConsole = isVitest && !showTestLogs
+  const log = (...args: unknown[]) => {
+    writeToFile('LOG', prefix, args)
+    if (suppressConsole) {
+      return
+    }
+    clackLog.message(
+      formatMessage(getTimestamp(), pc.cyan(paddedPrefix), args),
+      {
+        ...noSpacing,
+      },
+    )
+  }
+  return {
+    log,
+    error: (...args: unknown[]) => {
+      writeToFile('ERROR', prefix, args)
+      if (suppressConsole) {
+        return
+      }
+      clackLog.error(
+        formatMessage(getTimestamp(), pc.red(paddedPrefix), args),
+        noSpacing,
+      )
+    },
+    warn: (...args: unknown[]) => {
+      writeToFile('WARN', prefix, args)
+      if (suppressConsole) {
+        return
+      }
+      clackLog.warn(
+        formatMessage(getTimestamp(), pc.yellow(paddedPrefix), args),
+        noSpacing,
+      )
+    },
+    info: (...args: unknown[]) => {
+      writeToFile('INFO', prefix, args)
+      if (suppressConsole) {
+        return
+      }
+      clackLog.info(
+        formatMessage(getTimestamp(), pc.blue(paddedPrefix), args),
+        noSpacing,
+      )
+    },
+    debug: log,
+  }
+}

package/src/markdown.test.ts

@@ -0,0 +1,308 @@
+// Deterministic markdown export tests.
+// Uses the shared opencode server manager with the deterministic provider,
+// creates sessions with known content, and validates markdown output.
+// No dependency on machine-local session state.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import url from 'node:url'
+import { test, expect, beforeAll, afterAll } from 'vitest'
+import type { OpencodeClient } from '@opencode-ai/sdk/v2'
+import * as errore from 'errore'
+import {
+  buildDeterministicOpencodeConfig,
+  type DeterministicMatcher,
+} from 'opencode-deterministic-provider'
+import { ShareMarkdown, getCompactSessionContext } from './markdown.js'
+import { setDataDir } from './config.js'
+import { initializeOpencodeForDirectory, getOpencodeClient, stopOpencodeServer } from './opencode.js'
+import { cleanupTestSessions, initTestGitRepo } from './test-utils.js'
+
+const ROOT = path.resolve(process.cwd(), 'tmp', 'markdown-test')
+
+function createRunDirectories() {
+  fs.mkdirSync(ROOT, { recursive: true })
+  const dataDir = fs.mkdtempSync(path.join(ROOT, 'data-'))
+  const projectDirectory = path.join(ROOT, 'project')
+  fs.mkdirSync(projectDirectory, { recursive: true })
+  initTestGitRepo(projectDirectory)
+  return { dataDir, projectDirectory }
+}
+
+function createMatchers(): DeterministicMatcher[] {
+  const helloMatcher: DeterministicMatcher = {
+    id: 'hello-reply',
+    priority: 100,
+    when: { latestUserTextIncludes: 'hello markdown test' },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'hello-text' },
+        { type: 'text-delta', id: 'hello-text', delta: 'Hello! This is a deterministic markdown test response.' },
+        { type: 'text-end', id: 'hello-text' },
+        { type: 'finish', finishReason: 'stop', usage: { inputTokens: 10, outputTokens: 8, totalTokens: 18 } },
+      ],
+    },
+  }
+
+  const defaultMatcher: DeterministicMatcher = {
+    id: 'default-reply',
+    priority: 1,
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'default-text' },
+        { type: 'text-delta', id: 'default-text', delta: 'ok' },
+        { type: 'text-end', id: 'default-text' },
+        { type: 'finish', finishReason: 'stop', usage: { inputTokens: 5, outputTokens: 1, totalTokens: 6 } },
+      ],
+    },
+  }
+
+  return [helloMatcher, defaultMatcher]
+}
+
+let client: OpencodeClient
+let directories: ReturnType<typeof createRunDirectories>
+let testStartTime: number
+let sessionID: string
+
+beforeAll(async () => {
+  testStartTime = Date.now()
+  directories = createRunDirectories()
+  setDataDir(directories.dataDir)
+
+  const providerNpm = url
+    .pathToFileURL(
+      path.resolve(
+        process.cwd(),
+        '..',
+        'opencode-deterministic-provider',
+        'src',
+        'index.ts',
+      ),
+    )
+    .toString()
+
+  const opencodeConfig = buildDeterministicOpencodeConfig({
+    providerName: 'deterministic-provider',
+    providerNpm,
+    model: 'deterministic-v2',
+    smallModel: 'deterministic-v2',
+    settings: {
+      strict: false,
+      matchers: createMatchers(),
+    },
+  })
+  fs.writeFileSync(
+    path.join(directories.projectDirectory, 'opencode.json'),
+    JSON.stringify(opencodeConfig, null, 2),
+  )
+
+  // Start the shared opencode server via kimaki's server manager
+  const getClient = await initializeOpencodeForDirectory(
+    directories.projectDirectory,
+  )
+  if (getClient instanceof Error) {
+    throw getClient
+  }
+  client = getClient()
+
+  // Create a session and send a known prompt
+  const createResult = await client.session.create({
+    directory: directories.projectDirectory,
+    title: 'Markdown Test Session',
+  })
+  sessionID = createResult.data!.id
+
+  // Send prompt and wait for completion (promptAsync returns immediately)
+  await client.session.promptAsync({
+    sessionID,
+    directory: directories.projectDirectory,
+    parts: [{ type: 'text', text: 'hello markdown test' }],
+  })
+
+  // Wait for assistant text parts to be fully written (not just message existence).
+  // The deterministic provider responds instantly but opencode writes parts
+  // asynchronously, so we must poll until non-empty text content appears.
+  // Under parallel test load the server is slower, so use generous timeouts.
+  const maxWait = 15_000
+  const pollStart = Date.now()
+  while (Date.now() - pollStart < maxWait) {
+    const msgs = await client.session.messages({ sessionID })
+    const assistantMsg = msgs.data?.find((m) => m.info.role === 'assistant')
+    const hasTextParts = assistantMsg?.parts?.some((p) => {
+      return p.type === 'text' && p.text && !p.synthetic
+    })
+    if (hasTextParts) {
+      // Extra wait for step-start and other parts to be flushed
+      await new Promise((resolve) => {
+        setTimeout(resolve, 500)
+      })
+      break
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 200)
+    })
+  }
+}, 60_000)
+
+afterAll(async () => {
+  if (directories) {
+    await cleanupTestSessions({
+      projectDirectory: directories.projectDirectory,
+      testStartTime,
+    })
+  }
+  await stopOpencodeServer()
+  if (directories) {
+    fs.rmSync(directories.dataDir, { recursive: true, force: true })
+  }
+}, 10_000)
+
+// Strip dynamic parts (timestamps, durations, branch names) for stable assertions
+function normalizeMarkdown(md: string): string {
+  return md
+    // Normalize "Completed in Xs" to a fixed string
+    .replace(/\*Completed in [\d.]+[ms]+\*/g, '*Completed in Xs*')
+    // Normalize "Duration: Xs" tool timing
+    .replace(/\*Duration: [\d.]+[ms]+\*/g, '*Duration: Xs*')
+    // Normalize ISO dates in session info
+    .replace(/\*\*Created\*\*: .+/g, '**Created**: <date>')
+    .replace(/\*\*Updated\*\*: .+/g, '**Updated**: <date>')
+    // Normalize opencode version
+    .replace(/\*\*OpenCode Version\*\*: v[\d.]+.*/g, '**OpenCode Version**: v<version>')
+    // Strip git branch context injected by opencode into user messages
+    .replace(/\[Current branch: [^\]]+\]\n?\n?/g, '')
+    .replace(/\[current git branch is [^\]]+\]\n?\n?/g, '')
+    .replace(/\[warning: repository is in detached HEAD[^\]]*\]\n?\n?/g, '')
+}
+
+test('generate markdown with system info', async () => {
+  const exporter = new ShareMarkdown(client)
+
+  const markdownResult = await exporter.generate({
+    sessionID,
+    includeSystemInfo: true,
+  })
+
+  expect(errore.isOk(markdownResult)).toBe(true)
+  const markdown = errore.unwrap(markdownResult)
+
+  expect(markdown).toContain('# Markdown Test Session')
+  expect(markdown).toContain('## Session Information')
+  expect(markdown).toContain('## Conversation')
+  expect(markdown).toContain('### 👤 User')
+  expect(markdown).toContain('hello markdown test')
+  expect(markdown).toContain('### 🤖 Assistant')
+  expect(markdown).toContain('Hello! This is a deterministic markdown test response.')
+  expect(markdown).toContain('**Started using deterministic-provider/deterministic-v2**')
+
+  const normalized = normalizeMarkdown(markdown)
+  expect(normalized).toMatchInlineSnapshot(`
+    "# Markdown Test Session
+
+    ## Session Information
+
+    - **Created**: <date>
+    - **Updated**: <date>
+    - **OpenCode Version**: v<version>
+
+    ## Conversation
+
+    ### 👤 User
+
+    hello markdown test
+
+
+    ### 🤖 Assistant (deterministic-v2)
+
+    **Started using deterministic-provider/deterministic-v2**
+
+    Hello! This is a deterministic markdown test response.
+
+    "
+  `)
+})
+
+test('generate markdown without system info', async () => {
+  const exporter = new ShareMarkdown(client)
+
+  const markdown = await exporter.generate({
+    sessionID,
+    includeSystemInfo: false,
+  })
+
+  expect(errore.isOk(markdown)).toBe(true)
+  const md = errore.unwrap(markdown as string)
+  expect(md).toContain('# Markdown Test Session')
+  expect(md).not.toContain('## Session Information')
+  expect(md).toContain('## Conversation')
+
+  const normalized = normalizeMarkdown(md)
+  expect(normalized).toMatchInlineSnapshot(`
+    "# Markdown Test Session
+
+    ## Conversation
+
+    ### 👤 User
+
+    hello markdown test
+
+
+    ### 🤖 Assistant (deterministic-v2)
+
+    **Started using deterministic-provider/deterministic-v2**
+
+    Hello! This is a deterministic markdown test response.
+
+    "
+  `)
+})
+
+test('error handling for non-existent session', async () => {
+  const exporter = new ShareMarkdown(client)
+  const badSessionID = 'ses_nonexistent_' + Date.now()
+
+  const result = await exporter.generate({ sessionID: badSessionID })
+  expect(result).toBeInstanceOf(Error)
+  expect((result as Error).message).toContain(`Session ${badSessionID} not found`)
+})
+
+test('getCompactSessionContext generates compact format', async () => {
+  const contextResult = await getCompactSessionContext({
+    client,
+    sessionId: sessionID,
+    includeSystemPrompt: false,
+    maxMessages: 10,
+  })
+
+  expect(errore.isOk(contextResult)).toBe(true)
+  const context = errore.unwrap(contextResult)
+
+  expect(context).toBeTruthy()
+  // User text may be prefixed with branch context injected by opencode
+  expect(context).toContain('hello markdown test')
+  expect(context).toContain('[User]:')
+  expect(context).toContain('[Assistant]:')
+  expect(context).toContain('Hello! This is a deterministic markdown test response.')
+  expect(context).not.toContain('[System Prompt]')
+})
+
+test('generate markdown with lastAssistantOnly', async () => {
+  const exporter = new ShareMarkdown(client)
+
+  const markdownResult = await exporter.generate({
+    sessionID,
+    lastAssistantOnly: true,
+  })
+
+  expect(errore.isOk(markdownResult)).toBe(true)
+  const markdown = errore.unwrap(markdownResult)
+
+  // lastAssistantOnly should NOT include title header or conversation section header
+  expect(markdown).not.toContain('# Markdown Test Session')
+  expect(markdown).not.toContain('## Conversation')
+  // Should contain the assistant response
+  expect(markdown).toContain('Hello! This is a deterministic markdown test response.')
+})