@lythos/agent-adapter 0.16.0 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lythos/agent-adapter",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "main": "./src/index.ts",
   "exports": {
     ".": "./src/index.ts",

package/src/adapters/claude-cli.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, test } from 'bun:test'
+import { buildToolPrompt, extractJson, buildClaudeCommand, DEFAULT_ALLOWED_TOOLS, DEFAULT_DISALLOWED_TOOLS } from './claude-cli.js'
+
+// ── buildToolPrompt ─────────────────────────────────────────────
+
+describe('buildToolPrompt', () => {
+  test('includes tool name and description', () => {
+    const result = buildToolPrompt(
+      { name: 'search', description: 'Search the web', input_schema: { type: 'object', properties: {} } },
+      'Do the thing',
+    )
+    expect(result).toContain('Do the thing')
+    expect(result).toContain('## Tool: search')
+    expect(result).toContain('Search the web')
+  })
+
+  test('includes JSON schema in code fence', () => {
+    const result = buildToolPrompt(
+      { name: 'calc', description: 'Calculate', input_schema: { type: 'object', properties: { expr: { type: 'string' } } } },
+      'Compute',
+    )
+    expect(result).toContain('```json')
+    expect(result).toContain('"expr"')
+    expect(result).toContain('```')
+  })
+
+  test('ends with return-only-JSON instruction', () => {
+    const result = buildToolPrompt(
+      { name: 'x', description: 'x', input_schema: {} },
+      'prompt',
+    )
+    expect(result).toContain('Return ONLY the JSON object')
+  })
+})
+
+// ── extractJson ─────────────────────────────────────────────────
+
+describe('extractJson', () => {
+  test('extracts JSON from code fence', () => {
+    const result = extractJson('```json\n{"key":"value"}\n```')
+    expect(result).toEqual({ key: 'value' })
+  })
+
+  test('extracts JSON without code fence', () => {
+    const result = extractJson('{"key":"value"}')
+    expect(result).toEqual({ key: 'value' })
+  })
+
+  test('extracts nested JSON', () => {
+    const result = extractJson('```json\n{"nested":{"deep":true}}\n```')
+    expect(result).toEqual({ nested: { deep: true } })
+  })
+
+  test('handles text before and after code fence', () => {
+    const result = extractJson('Here is the result:\n```json\n{"a":1}\n```\nHope that helps!')
+    expect(result).toEqual({ a: 1 })
+  })
+
+  test('throws on invalid JSON', () => {
+    expect(() => extractJson('not json')).toThrow()
+    expect(() => extractJson('```json\nnot json\n```')).toThrow()
+  })
+})
+
+// ── buildClaudeCommand ──────────────────────────────────────────
+
+describe('buildClaudeCommand', () => {
+  test('uses sh -c with correct claude CLI flags', () => {
+    const cmd = buildClaudeCommand({ brief: 'test', cwd: '/tmp' })
+    expect(cmd.cmd).toBe('sh')
+    expect(cmd.args[0]).toBe('-c')
+    expect(cmd.args[1]).toContain('claude -p')
+    expect(cmd.args[1]).toContain('--output-format json')
+    expect(cmd.args[1]).toContain('--permission-mode bypassPermissions')
+  })
+
+  test('includes allowed and disallowed tools', () => {
+    const cmd = buildClaudeCommand({ brief: 'test', cwd: '/tmp' })
+    expect(cmd.args[1]).toContain(DEFAULT_ALLOWED_TOOLS)
+    expect(cmd.args[1]).toContain(DEFAULT_DISALLOWED_TOOLS)
+  })
+
+  test('custom tool lists override defaults', () => {
+    const cmd = buildClaudeCommand({
+      brief: 'test', cwd: '/tmp',
+      allowedTools: 'Read,Write',
+      disallowedTools: 'Bash(rm *)',
+    })
+    expect(cmd.args[1]).toContain('Read,Write')
+    expect(cmd.args[1]).not.toContain(DEFAULT_ALLOWED_TOOLS)
+  })
+
+  test('modelTier: fast → --model haiku', () => {
+    const cmd = buildClaudeCommand({ brief: 'test', cwd: '/tmp', modelTier: 'fast' })
+    expect(cmd.args[1]).toContain('--model haiku')
+  })
+
+  test('modelTier: deep → --model opus', () => {
+    const cmd = buildClaudeCommand({ brief: 'test', cwd: '/tmp', modelTier: 'deep' })
+    expect(cmd.args[1]).toContain('--model opus')
+  })
+
+  test('modelTier: balanced (default) → no model flag', () => {
+    const cmd = buildClaudeCommand({ brief: 'test', cwd: '/tmp' })
+    expect(cmd.args[1]).not.toContain('--model')
+  })
+
+  test('promptFile is a temp file path', () => {
+    const cmd = buildClaudeCommand({ brief: 'test', cwd: '/tmp' })
+    expect(cmd.promptFile).toContain('claude-prompt-')
+    expect(cmd.promptFile).toContain('.txt')
+  })
+
+  test('stdin contains the brief prompt', () => {
+    const cmd = buildClaudeCommand({ brief: 'do the task', cwd: '/tmp' })
+    expect(cmd.stdin).toBe('do the task')
+  })
+
+  test('shell command redirects from prompt file', () => {
+    const cmd = buildClaudeCommand({ brief: 'test', cwd: '/tmp' })
+    expect(cmd.args[1]).toContain('<')
+    expect(cmd.args[1]).toContain(cmd.promptFile)
+  })
+})

package/src/adapters/kimi.test.ts

@@ -12,18 +12,30 @@ describe('detectKimiBinary', () => {
 
 describe('buildKimiCommand', () => {
   it('builds kimi CLI args without shell wrapper', () => {
-    const cmd = buildKimiCommand()
-    expect(cmd[0]).toBeOneOf(['kimi-cli', 'kimi'])
+    const cmd = buildKimiCommand(undefined, 'kimi-cli')
+    expect(cmd[0]).toBe('kimi-cli')
+    expect(cmd).toContain('--print')
+    expect(cmd).toContain('--output-format')
+    expect(cmd).toContain('stream-json')
+  })
+
+  it('builds kimi CLI args for kimi binary', () => {
+    const cmd = buildKimiCommand(undefined, 'kimi')
+    expect(cmd[0]).toBe('kimi')
     expect(cmd).toContain('--print')
     expect(cmd).toContain('--output-format')
     expect(cmd).toContain('stream-json')
   })
 
   it('does not use shell or redirect (injection-safe)', () => {
-    const cmd = buildKimiCommand()
+    const cmd = buildKimiCommand(undefined, 'kimi-cli')
     expect(cmd).not.toContain('sh')
     expect(cmd).not.toContain('-c')
   })
+
+  it('throws when no binary is available', () => {
+    expect(() => buildKimiCommand(undefined, '')).toThrow('No kimi binary found in PATH')
+  })
 })
 
 describe('parseKimiStreamJson', () => {

package/src/adapters/kimi.ts

@@ -21,8 +21,10 @@ export function detectKimiBinary(): string {
 }
 
 /** Build kimi CLI command args (no shell wrapper — safe from injection). */
-export function buildKimiCommand(_modelTier?: 'fast' | 'balanced' | 'deep'): string[] {
-  const binary = detectKimiBinary()
+export function buildKimiCommand(
+  _modelTier?: 'fast' | 'balanced' | 'deep',
+  binary = detectKimiBinary(),
+): string[] {
   if (!binary) {
     throw new Error('No kimi binary found in PATH. Install: https://github.com/MoonshotAI/kimi-cli')
   }

package/src/index.test.ts

@@ -1,30 +1,30 @@
-import { describe, test, expect } from 'bun:test'
+import { describe, it, expect } from 'bun:test'
 import { useAgent, registerAgent, listAgents, type AgentAdapter } from './index'
 
 describe('@lythos/agent-adapter', () => {
-  test('built-in adapters are auto-registered on import', () => {
+  it('built-in adapters are auto-registered on import', () => {
     const agents = listAgents()
     expect(agents).toContain('kimi')
     expect(agents).toContain('claude')
     expect(agents).toContain('claude-cli')
   })
 
-  test('useAgent returns kimi adapter', () => {
+  it('useAgent returns kimi adapter', () => {
     const adapter = useAgent('kimi')
     expect(adapter.name).toBe('kimi')
     expect(typeof adapter.spawn).toBe('function')
   })
 
-  test('useAgent returns claude-cli adapter', () => {
+  it('useAgent returns claude-cli adapter', () => {
     const adapter = useAgent('claude-cli')
     expect(adapter.name).toBe('claude')
   })
 
-  test('useAgent throws for unknown agent', () => {
+  it('useAgent throws for unknown agent', () => {
     expect(() => useAgent('gpt-5')).toThrow('Unknown agent: "gpt-5"')
   })
 
-  test('registerAgent adds custom adapter', () => {
+  it('registerAgent adds custom adapter', () => {
     const mockAdapter: AgentAdapter = {
       name: 'mock',
       async spawn(opts) {
@@ -36,7 +36,7 @@ describe('@lythos/agent-adapter', () => {
     expect(useAgent('mock').name).toBe('mock')
   })
 
-  test('spawn throws clear error when binary is missing', async () => {
+  it('spawn throws clear error when binary is missing', async () => {
     const adapter = useAgent('kimi')
     const hasKimi = !!Bun.which('kimi')
     if (!hasKimi) {