@otto-assistant/otto 0.1.1 → 0.7.15

package/src/limit-heading-depth.test.ts

@@ -0,0 +1,116 @@
+import { expect, test } from 'vitest'
+import { limitHeadingDepth } from './limit-heading-depth.js'
+
+test('converts h4 to h3', () => {
+  const input = '#### Fourth level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "### Fourth level heading
+    "
+  `)
+})
+
+test('converts h5 to h3', () => {
+  const input = '##### Fifth level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "### Fifth level heading
+    "
+  `)
+})
+
+test('converts h6 to h3', () => {
+  const input = '###### Sixth level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "### Sixth level heading
+    "
+  `)
+})
+
+test('preserves h3 unchanged', () => {
+  const input = '### Third level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`"### Third level heading"`)
+})
+
+test('preserves h2 unchanged', () => {
+  const input = '## Second level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`"## Second level heading"`)
+})
+
+test('preserves h1 unchanged', () => {
+  const input = '# First level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`"# First level heading"`)
+})
+
+test('handles multiple headings in document', () => {
+  const input = `# Title
+
+Some text
+
+## Section
+
+### Subsection
+
+#### Too deep
+
+##### Even deeper
+
+Regular paragraph
+
+### Back to normal
+`
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "# Title
+
+    Some text
+
+    ## Section
+
+    ### Subsection
+
+    ### Too deep
+    ### Even deeper
+    Regular paragraph
+
+    ### Back to normal
+    "
+  `)
+})
+
+test('preserves heading with inline formatting', () => {
+  const input = '#### Heading with **bold** and `code`'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "### Heading with **bold** and \`code\`
+    "
+  `)
+})
+
+test('handles empty markdown', () => {
+  const result = limitHeadingDepth('')
+  expect(result).toMatchInlineSnapshot(`""`)
+})
+
+test('handles markdown with no headings', () => {
+  const input = 'Just some text\n\nAnd more text'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "Just some text
+
+    And more text"
+  `)
+})
+
+test('allows custom maxDepth', () => {
+  const input = '### Third level'
+  const result = limitHeadingDepth(input, 2)
+  expect(result).toMatchInlineSnapshot(`
+    "## Third level
+    "
+  `)
+})

package/src/limit-heading-depth.ts

@@ -0,0 +1,26 @@
+// Limit heading depth for Discord.
+// Discord only supports headings up to ### (h3), so this converts
+// ####, #####, etc. to ### to maintain consistent rendering.
+
+import { Lexer, type Tokens } from 'marked'
+
+export function limitHeadingDepth(markdown: string, maxDepth = 3): string {
+  const lexer = new Lexer()
+  const tokens = lexer.lex(markdown)
+
+  let result = ''
+  for (const token of tokens) {
+    if (token.type === 'heading') {
+      const heading = token as Tokens.Heading
+      if (heading.depth > maxDepth) {
+        const hashes = '#'.repeat(maxDepth)
+        result += hashes + ' ' + heading.text + '\n'
+      } else {
+        result += token.raw
+      }
+    } else {
+      result += token.raw
+    }
+  }
+  return result
+}

package/src/logger.ts

@@ -0,0 +1,215 @@
+// 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>/otto.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, 'otto.log')
+  const logDir = path.dirname(logFilePath)
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true })
+  }
+  fs.writeFileSync(
+    logFilePath,
+    `--- otto 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, 'otto.log')
+}
+
+export function getLogFilePath(): string | null {
+  return logFilePath
+}
+
+const MAX_LOG_ARG_LENGTH = 1000
+
+function truncate(str: string, max: number): string {
+  if (str.length <= max) return str
+  return str.slice(0, max) + `… [truncated ${str.length - max} chars]`
+}
+
+function formatArg(arg: unknown): string {
+  if (typeof arg === 'string') {
+    return truncate(sanitizeSensitiveText(arg, { redactPaths: false }), MAX_LOG_ARG_LENGTH)
+  }
+  const safeArg = sanitizeUnknownValue(arg, { redactPaths: false })
+  return truncate(util.inspect(safeArg, { colors: true, depth: 4 }), MAX_LOG_ARG_LENGTH)
+}
+
+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 OTTO_TEST_LOGS=1 (or OTTO_TEST_LOGS=1) when rerunning a failing
+// test to see all otto logger output in the terminal for debugging.
+const isVitest = !!(process.env['OTTO_VITEST'] || process.env['OTTO_VITEST'])
+const showTestLogs = isVitest && !!(process.env['OTTO_TEST_LOGS'] || process.env['OTTO_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,315 @@
+// 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 otto'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,
+      directory: directories.projectDirectory,
+    })
+    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)
+    })
+  }
+}, 20_000)
+
+afterAll(async () => {
+  if (directories) {
+    await cleanupTestSessions({
+      projectDirectory: directories.projectDirectory,
+      testStartTime,
+    })
+  }
+  await stopOpencodeServer()
+  if (directories) {
+    fs.rmSync(directories.dataDir, { recursive: true, force: true })
+  }
+}, 5_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.
+
+
+    *Completed in Xs*
+    "
+  `)
+})
+
+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.
+
+
+    *Completed in Xs*
+    "
+  `)
+})
+
+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.')
+})