kimaki 0.31.0 → 1.1.0

package/src/opencode-command-detection.test.ts

@@ -1,307 +0,0 @@
-import { describe, test, expect } from 'vitest'
-import { extractLeadingOpencodeCommand } from './opencode-command-detection.js'
-import type { RegisteredUserCommand } from './store.js'
-
-const fixtures: RegisteredUserCommand[] = [
-  {
-    name: 'build',
-    discordCommandName: 'build-cmd',
-    description: 'build the project',
-    source: 'command',
-  },
-  {
-    name: 'namespace:foo',
-    discordCommandName: 'namespace-foo-cmd',
-    description: 'namespaced',
-    source: 'command',
-  },
-  {
-    name: 'review',
-    discordCommandName: 'review-skill',
-    description: 'review skill',
-    source: 'skill',
-  },
-  {
-    name: 'plan',
-    discordCommandName: 'plan-mcp-prompt',
-    description: 'plan via mcp',
-    source: 'mcp',
-  },
-]
-
-describe('extractLeadingOpencodeCommand', () => {
-  test('plain /build with args', () => {
-    expect(
-      extractLeadingOpencodeCommand('/build foo bar', fixtures),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "foo bar",
-          "name": "build",
-        },
-      }
-    `)
-  })
-
-  test('plain /build no args', () => {
-    expect(extractLeadingOpencodeCommand('/build', fixtures))
-      .toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "",
-          "name": "build",
-        },
-      }
-    `)
-  })
-
-  test('/build-cmd suffix resolves to build', () => {
-    expect(
-      extractLeadingOpencodeCommand('/build-cmd hello world', fixtures),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "hello world",
-          "name": "build",
-        },
-      }
-    `)
-  })
-
-  test('-skill suffix', () => {
-    expect(
-      extractLeadingOpencodeCommand('/review-skill a b', fixtures),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "a b",
-          "name": "review",
-        },
-      }
-    `)
-  })
-
-  test('-mcp-prompt suffix', () => {
-    expect(
-      extractLeadingOpencodeCommand('/plan-mcp-prompt go', fixtures),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "go",
-          "name": "plan",
-        },
-      }
-    `)
-  })
-
-  test('original namespaced name with colon', () => {
-    expect(
-      extractLeadingOpencodeCommand('/namespace:foo arg', fixtures),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "arg",
-          "name": "namespace:foo",
-        },
-      }
-    `)
-  })
-
-  test('discord-sanitized namespaced name', () => {
-    expect(
-      extractLeadingOpencodeCommand('/namespace-foo-cmd arg', fixtures),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "arg",
-          "name": "namespace:foo",
-        },
-      }
-    `)
-  })
-
-  test('kimaki-cli prefix on its own line', () => {
-    expect(
-      extractLeadingOpencodeCommand(
-        '» **kimaki-cli:**\n/build foo bar',
-        fixtures,
-      ),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "foo bar",
-          "name": "build",
-        },
-      }
-    `)
-  })
-
-  test('queue-style user prefix on its own line', () => {
-    expect(
-      extractLeadingOpencodeCommand('» **Tommy:**\n/build hey', fixtures),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "hey",
-          "name": "build",
-        },
-      }
-    `)
-  })
-
-  test('username containing asterisk on its own line', () => {
-    expect(
-      extractLeadingOpencodeCommand('» **A*B:**\n/build hi', fixtures),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "hi",
-          "name": "build",
-        },
-      }
-    `)
-  })
-
-  test('Context from thread wrapping still detects command', () => {
-    const wrapped =
-      'Context from thread:\nsome starter text\n\nUser request:\n/build foo'
-    expect(extractLeadingOpencodeCommand(wrapped, fixtures))
-      .toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "foo",
-          "name": "build",
-        },
-      }
-    `)
-  })
-
-  test('unknown command returns null', () => {
-    expect(
-      extractLeadingOpencodeCommand('/nothing here', fixtures),
-    ).toMatchInlineSnapshot(`null`)
-  })
-
-  test('no leading slash on any line returns null', () => {
-    expect(
-      extractLeadingOpencodeCommand('hello /build\nmore text', fixtures),
-    ).toMatchInlineSnapshot(`null`)
-  })
-
-  test('just slash returns null', () => {
-    expect(extractLeadingOpencodeCommand('/', fixtures)).toMatchInlineSnapshot(
-      `null`,
-    )
-  })
-
-  test('empty string returns null', () => {
-    expect(extractLeadingOpencodeCommand('', fixtures)).toMatchInlineSnapshot(
-      `null`,
-    )
-  })
-
-  test('empty registry returns null for tokens without Discord suffix', () => {
-    expect(extractLeadingOpencodeCommand('/build foo', [])).toMatchInlineSnapshot(
-      `null`,
-    )
-  })
-
-  test('empty registry fallback: -cmd suffix strips and returns base name', () => {
-    expect(
-      extractLeadingOpencodeCommand('/hello-test-cmd', []),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "",
-          "name": "hello-test",
-        },
-      }
-    `)
-  })
-
-  test('empty registry fallback: -skill suffix with args', () => {
-    expect(
-      extractLeadingOpencodeCommand('/review-skill check auth', []),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "check auth",
-          "name": "review",
-        },
-      }
-    `)
-  })
-
-  test('empty registry fallback skips non-suffixed, matches suffixed on next line', () => {
-    expect(
-      extractLeadingOpencodeCommand('/unknown\n/deploy-cmd now', []),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "now",
-          "name": "deploy",
-        },
-      }
-    `)
-  })
-
-  test('leading whitespace before slash still matches', () => {
-    expect(
-      extractLeadingOpencodeCommand('   /build foo', fixtures),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "foo",
-          "name": "build",
-        },
-      }
-    `)
-  })
-
-  test('first matching line wins', () => {
-    const prompt = 'noise line\n/build first args\n/review second args'
-    expect(extractLeadingOpencodeCommand(prompt, fixtures))
-      .toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "first args",
-          "name": "build",
-        },
-      }
-    `)
-  })
-
-  test('unknown command on one line, known on next', () => {
-    const prompt = '/unknown foo\n/build bar'
-    expect(extractLeadingOpencodeCommand(prompt, fixtures))
-      .toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "bar",
-          "name": "build",
-        },
-      }
-    `)
-  })
-
-  test('suffix strip does not clobber a command whose name happens to end in -cmd', () => {
-    const custom: RegisteredUserCommand[] = [
-      {
-        name: 'deploy-cmd',
-        discordCommandName: 'deploy-cmd-cmd',
-        description: '',
-        source: 'command',
-      },
-    ]
-    expect(
-      extractLeadingOpencodeCommand('/deploy-cmd now', custom),
-    ).toMatchInlineSnapshot(`
-      {
-        "command": {
-          "arguments": "now",
-          "name": "deploy-cmd",
-        },
-      }
-    `)
-  })
-})

package/src/opencode-command-detection.ts

@@ -1,76 +0,0 @@
-// Detect a /commandname token on its own line in a user prompt and resolve it
-// to a registered opencode command. Mirrors the Discord slash command flow
-// (commands/user-command.ts) so users can type `/build foo` or `/build-cmd foo`
-// in chat, via `/new-session`, through `kimaki send --prompt`, or scheduled
-// tasks and have it routed to opencode's session.command API instead of going
-// to the model as plain text.
-//
-// Detection is line-based: we scan each line and return the first one whose
-// first non-whitespace token is `/<registered-command>`. This keeps the
-// detector oblivious to prefix lines (`» **kimaki-cli:**`, `Context from
-// thread:`, etc). Producers that add such prefixes must put them on their
-// own line so the user's content starts on a fresh line.
-
-import type { RegisteredUserCommand } from './store.js'
-import { store } from './store.js'
-
-const DISCORD_SUFFIXES = ['-mcp-prompt', '-skill', '-cmd'] as const
-
-function stripDiscordSuffix(token: string): string {
-  for (const suffix of DISCORD_SUFFIXES) {
-    if (token.endsWith(suffix)) {
-      return token.slice(0, -suffix.length)
-    }
-  }
-  return token
-}
-
-// Resolve a /token against registeredUserCommands. When the list is empty
-// (gateway startup race), falls back to suffix-stripping so tokens like
-// /build-cmd still route to session.command('build'). Tokens without a
-// recognizable suffix return undefined to avoid false positives.
-function resolveCommandName({
-  token,
-  registered,
-}: {
-  token: string
-  registered: RegisteredUserCommand[]
-}): string | undefined {
-  const exact = registered.find((c) => {
-    return c.name === token || c.discordCommandName === token
-  })
-  if (exact) return exact.name
-
-  const base = stripDiscordSuffix(token)
-  if (base === token) return undefined
-
-  const stripped = registered.find((c) => {
-    return c.name === base || c.discordCommandName === base
-  })
-  if (stripped) return stripped.name
-
-  // Empty registry fallback: suffix was stripped, trust it
-  if (registered.length === 0) return base
-
-  return undefined
-}
-
-export function extractLeadingOpencodeCommand(
-  prompt: string,
-  registered: RegisteredUserCommand[] = store.getState().registeredUserCommands,
-): { command: { name: string; arguments: string } } | null {
-  if (!prompt) return null
-
-  for (const line of prompt.split('\n')) {
-    const trimmed = line.trimStart()
-    if (!trimmed.startsWith('/')) continue
-    const match = trimmed.match(/^\/([^\s]+)(?:\s+(.*))?$/)
-    if (!match) continue
-    const [, token, rest] = match
-    if (!token) continue
-    const name = resolveCommandName({ token, registered })
-    if (!name) continue
-    return { command: { name, arguments: (rest ?? '').trim() } }
-  }
-  return null
-}

package/src/opencode-command.test.ts

@@ -1,290 +0,0 @@
-// Regression tests for Windows OpenCode command resolution and spawn args.
-
-import fs from 'node:fs'
-import { createRequire } from 'node:module'
-import os from 'node:os'
-import path from 'node:path'
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
-import {
-  ensureKimakiCommandShim,
-  getIncompatibleOpencodeVersionError,
-  getSpawnCommandAndArgs,
-  INCOMPATIBLE_OPENCODE_MAJOR_VERSION,
-  isIncompatibleOpencodeMajor,
-  parseOpencodeVersion,
-  sanitizeShimExecArgv,
-  selectResolvedCommand,
-  splitCommandLookupOutput,
-} from './opencode-command.js'
-import { OpencodeIncompatibleVersionError } from './errors.js'
-
-describe('parseOpencodeVersion', () => {
-  test('extracts major.minor.patch from opencode --version output', () => {
-    expect(parseOpencodeVersion('1.2.3')).toEqual({
-      major: 1,
-      minor: 2,
-      patch: 3,
-      raw: '1.2.3',
-    })
-    expect(parseOpencodeVersion('opencode 2.0.0\n')).toEqual({
-      major: 2,
-      minor: 0,
-      patch: 0,
-      raw: '2.0.0',
-    })
-    expect(parseOpencodeVersion('v2.1.0-beta.1')).toEqual({
-      major: 2,
-      minor: 1,
-      patch: 0,
-      raw: '2.1.0',
-    })
-  })
-
-  test('returns null when output has no three-part version', () => {
-    expect(parseOpencodeVersion('')).toBeNull()
-    expect(parseOpencodeVersion('opencode')).toBeNull()
-    expect(parseOpencodeVersion('2.0')).toBeNull()
-  })
-})
-
-describe('isIncompatibleOpencodeMajor', () => {
-  test('rejects the incompatible major and allows every other major', () => {
-    expect(INCOMPATIBLE_OPENCODE_MAJOR_VERSION).toBe(2)
-    expect(isIncompatibleOpencodeMajor({ major: 2 })).toBe(true)
-    expect(isIncompatibleOpencodeMajor({ major: 1 })).toBe(false)
-    expect(isIncompatibleOpencodeMajor({ major: 0 })).toBe(false)
-    expect(isIncompatibleOpencodeMajor({ major: 3 })).toBe(false)
-  })
-})
-
-describe('getIncompatibleOpencodeVersionError', () => {
-  test('returns a tagged error for OpenCode 2.x', () => {
-    const error = getIncompatibleOpencodeVersionError('2.0.0')
-    expect(error).toBeInstanceOf(OpencodeIncompatibleVersionError)
-    expect(error?.message).toMatchInlineSnapshot(
-      `"Kimaki is not compatible with OpenCode version 2.0.0. Install an OpenCode 1.x release."`,
-    )
-  })
-
-  test('allows 1.x and unparseable output', () => {
-    expect(getIncompatibleOpencodeVersionError('1.4.0')).toBeNull()
-    expect(getIncompatibleOpencodeVersionError('opencode')).toBeNull()
-  })
-})
-
-describe('splitCommandLookupOutput', () => {
-  test('splits windows command lookup output into trimmed lines', () => {
-    expect(
-      splitCommandLookupOutput(
-        'C:\\Program Files\\nodejs\\opencode\r\nC:\\Program Files\\nodejs\\opencode.cmd\r\n',
-      ),
-    ).toEqual([
-      'C:\\Program Files\\nodejs\\opencode',
-      'C:\\Program Files\\nodejs\\opencode.cmd',
-    ])
-  })
-})
-
-describe('selectResolvedCommand', () => {
-  test('prefers npm cmd shims on windows', () => {
-    expect(
-      selectResolvedCommand({
-        output: 'C:\\Program Files\\nodejs\\opencode\r\nC:\\Program Files\\nodejs\\opencode.cmd\r\n',
-        isWindows: true,
-      }),
-    ).toBe('C:\\Program Files\\nodejs\\opencode.cmd')
-  })
-
-  test('keeps first result on non-windows platforms', () => {
-    expect(
-      selectResolvedCommand({
-        output: '/usr/local/bin/opencode\n/opt/homebrew/bin/opencode\n',
-        isWindows: false,
-      }),
-    ).toBe('/usr/local/bin/opencode')
-  })
-})
-
-describe('buildOpencodeServeArgs', () => {
-  test('always passes --hostname so opencode.json cannot bind 0.0.0.0', async () => {
-    const { buildOpencodeServeArgs } = await import('./opencode.js')
-    expect(buildOpencodeServeArgs({ port: 4096 })).toEqual([
-      'serve',
-      '--port',
-      '4096',
-      '--hostname',
-      '127.0.0.1',
-      '--print-logs',
-      '--log-level',
-      'WARN',
-    ])
-  })
-
-  test('passes --hostname when set', async () => {
-    const { buildOpencodeServeArgs } = await import('./opencode.js')
-    expect(
-      buildOpencodeServeArgs({ port: 4096, hostname: '0.0.0.0' }),
-    ).toEqual([
-      'serve',
-      '--port',
-      '4096',
-      '--hostname',
-      '0.0.0.0',
-      '--print-logs',
-      '--log-level',
-      'WARN',
-    ])
-  })
-})
-
-describe('published runtime artifacts', () => {
-  test('lists @subrouter/opencode as a runtime dependency', () => {
-    const pkg = JSON.parse(
-      fs.readFileSync(path.join(import.meta.dirname, '../package.json'), 'utf8'),
-    ) as { dependencies?: Record<string, string> }
-    expect(pkg.dependencies?.['@subrouter/opencode']).toMatch(/^(workspace:\^|\^)/)
-  })
-})
-
-describe('resolveSubrouterPluginSpec', () => {
-  test('uses npm package identity in production for OpenCode deduplication', async () => {
-    const { resolveSubrouterPluginSpec } = await import('./opencode.js')
-    const require = createRequire(import.meta.url)
-    const packageJsonPath = require.resolve('@subrouter/opencode/package.json')
-    const version = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version
-    expect(resolveSubrouterPluginSpec({ isDev: false })).toBe(
-      `@subrouter/opencode@${version}`,
-    )
-  })
-
-  test('loads workspace source directly in development', async () => {
-    const { resolveSubrouterPluginSpec } = await import('./opencode.js')
-    expect(resolveSubrouterPluginSpec({ isDev: true })).toMatch(
-      /^file:.*\/subrouter\/opencode\/dist\/index\.js$/,
-    )
-  })
-})
-
-describe('publicOpencodeBindRequiresPassword', () => {
-  test('allows loopback without a password', async () => {
-    const { publicOpencodeBindRequiresPassword } = await import('./opencode.js')
-    expect(publicOpencodeBindRequiresPassword({ hostname: null })).toBe(false)
-    expect(publicOpencodeBindRequiresPassword({ hostname: '127.0.0.1' })).toBe(
-      false,
-    )
-    expect(publicOpencodeBindRequiresPassword({ hostname: 'localhost' })).toBe(
-      false,
-    )
-  })
-
-  test('requires a password for 0.0.0.0', async () => {
-    const { publicOpencodeBindRequiresPassword } = await import('./opencode.js')
-    expect(publicOpencodeBindRequiresPassword({ hostname: '0.0.0.0' })).toBe(
-      true,
-    )
-  })
-})
-
-describe('getSpawnCommandAndArgs', () => {
-  test('wraps windows cmd shims through cmd.exe without double-quoting by node', () => {
-    expect(
-      getSpawnCommandAndArgs({
-        resolvedCommand: 'C:\\Program Files\\nodejs\\opencode.cmd',
-        baseArgs: ['serve', '--port', '4096'],
-        platform: 'win32',
-      }),
-    ).toEqual({
-      command: 'cmd.exe',
-      args: ['/d', '/s', '/c', '"C:\\Program Files\\nodejs\\opencode.cmd"', 'serve', '--port', '4096'],
-      windowsVerbatimArguments: true,
-    })
-  })
-
-  test('leaves direct executables unchanged on windows', () => {
-    expect(
-      getSpawnCommandAndArgs({
-        resolvedCommand: 'C:\\tools\\opencode.exe',
-        baseArgs: ['serve', '--port', '4096'],
-        platform: 'win32',
-      }),
-    ).toEqual({
-      command: 'C:\\tools\\opencode.exe',
-      args: ['serve', '--port', '4096'],
-    })
-  })
-})
-
-describe('sanitizeShimExecArgv', () => {
-  test('strips --env-file=value single-arg form', () => {
-    expect(
-      sanitizeShimExecArgv([
-        '--require',
-        '/abs/tsx/preflight.cjs',
-        '--env-file=.env',
-        '--import',
-        'file:///abs/tsx/loader.mjs',
-      ]),
-    ).toEqual([
-      '--require',
-      '/abs/tsx/preflight.cjs',
-      '--import',
-      'file:///abs/tsx/loader.mjs',
-    ])
-  })
-
-  test('strips --env-file value two-arg form and its value', () => {
-    expect(
-      sanitizeShimExecArgv(['--env-file', '.env', '--require', '/abs/preflight.cjs']),
-    ).toEqual(['--require', '/abs/preflight.cjs'])
-  })
-
-  test('strips --env-file-if-exists in both forms', () => {
-    expect(
-      sanitizeShimExecArgv([
-        '--env-file-if-exists=.env',
-        '--env-file-if-exists',
-        '/abs/.env',
-        '--enable-source-maps',
-      ]),
-    ).toEqual(['--enable-source-maps'])
-  })
-
-  test('leaves unrelated flags untouched', () => {
-    expect(
-      sanitizeShimExecArgv(['--enable-source-maps', '--max-old-space-size=4096']),
-    ).toEqual(['--enable-source-maps', '--max-old-space-size=4096'])
-  })
-})
-
-describe('ensureKimakiCommandShim', () => {
-  let tempDir: string
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kimaki-shim-test-'))
-  })
-
-  afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true })
-  })
-
-  test('generated posix shim does not contain a relative --env-file flag', () => {
-    const result = ensureKimakiCommandShim({
-      dataDir: tempDir,
-      execPath: '/usr/bin/node',
-      execArgv: [
-        '--require',
-        '/abs/tsx/preflight.cjs',
-        '--env-file=.env',
-        '--import',
-        'file:///abs/tsx/loader.mjs',
-      ],
-      entryScript: '/abs/cli/src/cli',
-      platform: 'linux',
-    })
-    expect(result).not.toBeInstanceOf(Error)
-    const shimContent = fs.readFileSync(path.join(tempDir, 'bin', 'kimaki'), 'utf8')
-    expect(shimContent).not.toContain('--env-file')
-    expect(shimContent).toContain('/abs/tsx/preflight.cjs')
-    expect(shimContent).toContain('/abs/cli/src/cli')
-  })
-})