smithers-orchestrator 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smithers-orchestrator",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Build AI agents with React - Declarative JSX for Claude orchestration",
   "type": "module",
   "main": "./src/index.ts",
@@ -38,6 +38,9 @@
   },
   "files": [
     "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/.smithers",
     "bin",
     "skills",
     "templates",

package/src/components/agents/claude-cli/arg-builder.ts

@@ -5,11 +5,12 @@ import type { CLIExecutionOptions, ClaudePermissionMode, ClaudeOutputFormat } fr
 
 /**
  * Model name mapping from shorthand to full model ID
+ * Uses latest dated versions for API compatibility
  */
 export const modelMap: Record<string, string> = {
-  opus: 'claude-opus-4',
-  sonnet: 'claude-sonnet-4',
-  haiku: 'claude-haiku-3',
+  opus: 'claude-opus-4-20250514',
+  sonnet: 'claude-sonnet-4-20250514',
+  haiku: 'claude-haiku-3-20250514',
 }
 
 /**

package/src/reconciler/jsx-runtime.ts

@@ -9,7 +9,15 @@ import {
   jsx as reactJsx,
   jsxs as reactJsxs,
 } from 'react/jsx-runtime'
-import { jsxDEV as reactJsxDEV } from 'react/jsx-dev-runtime'
+
+// In production mode, jsxDEV is undefined - fallback to jsx
+let reactJsxDEV: typeof import('react/jsx-dev-runtime').jsxDEV | undefined
+try {
+  const devRuntime = await import('react/jsx-dev-runtime')
+  reactJsxDEV = devRuntime.jsxDEV
+} catch {
+  // Fallback handled below
+}
 
 type Props = Record<string, unknown> | null
 
@@ -44,6 +52,10 @@ export function jsxDEV(
   source: { fileName: string; lineNumber: number; columnNumber: number } | undefined,
   self: unknown
 ) {
+  // Fallback to jsx in production mode where jsxDEV is undefined
+  if (!reactJsxDEV) {
+    return reactJsx(type as React.ElementType, withSmithersKey(props, key), key)
+  }
   return reactJsxDEV(type as React.ElementType, withSmithersKey(props, key), key, isStaticChildren, source, self)
 }
 

package/templates/main.tsx.template

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+/** @jsxImportSource smithers-orchestrator */
 import { createSmithersRoot } from 'smithers-orchestrator'
 import { createSmithersDB } from 'smithers-orchestrator/db'
 import {

package/src/commands/cli-utils.test.ts

@@ -1,178 +0,0 @@
-/**
- * Tests for cli-utils
- * 
- * Covers: Path resolution, file permissions, database paths, package root detection
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
-import * as fs from 'fs'
-import * as path from 'path'
-import {
-  DEFAULT_MAIN_FILE,
-  DEFAULT_DB_DIR,
-  DB_FILE_NAME,
-  resolveEntrypoint,
-  ensureExecutable,
-  findPreloadPath,
-  findPackageRoot,
-  resolveDbPaths,
-} from './cli-utils'
-import { cleanupTempDir, createTempDir } from './test-utils'
-
-describe('constants', () => {
-  test('DEFAULT_MAIN_FILE is .smithers/main.tsx', () => {
-    expect(DEFAULT_MAIN_FILE).toBe('.smithers/main.tsx')
-  })
-
-  test('DEFAULT_DB_DIR is .smithers/data', () => {
-    expect(DEFAULT_DB_DIR).toBe('.smithers/data')
-  })
-
-  test('DB_FILE_NAME is smithers.db', () => {
-    expect(DB_FILE_NAME).toBe('smithers.db')
-  })
-})
-
-describe('resolveEntrypoint', () => {
-  test('returns fileArg when provided', () => {
-    const result = resolveEntrypoint('/path/to/file.tsx')
-    expect(result).toBe('/path/to/file.tsx')
-  })
-
-  test('returns optionFile when fileArg not provided', () => {
-    const result = resolveEntrypoint(undefined, '/option/file.tsx')
-    expect(result).toBe('/option/file.tsx')
-  })
-
-  test('returns defaultFile when neither provided', () => {
-    const result = resolveEntrypoint(undefined, undefined, '/default/file.tsx')
-    expect(result).toBe('/default/file.tsx')
-  })
-
-  test('uses DEFAULT_MAIN_FILE as ultimate fallback', () => {
-    const result = resolveEntrypoint()
-    expect(result).toBe(path.resolve(DEFAULT_MAIN_FILE))
-  })
-
-  test('resolves relative paths to absolute', () => {
-    const result = resolveEntrypoint('relative/path.tsx')
-    expect(path.isAbsolute(result)).toBe(true)
-  })
-
-  test('fileArg takes precedence over optionFile', () => {
-    const result = resolveEntrypoint('/fileArg.tsx', '/optionFile.tsx')
-    expect(result).toBe('/fileArg.tsx')
-  })
-
-  test('optionFile takes precedence over defaultFile', () => {
-    const result = resolveEntrypoint(undefined, '/optionFile.tsx', '/defaultFile.tsx')
-    expect(result).toBe('/optionFile.tsx')
-  })
-})
-
-describe('ensureExecutable', () => {
-  let tempDir: string
-
-  beforeEach(() => {
-    tempDir = createTempDir(import.meta.dir, '.test-executable')
-  })
-
-  afterEach(() => {
-    cleanupTempDir(tempDir)
-  })
-
-  test('makes non-executable file executable', () => {
-    const testFile = path.join(tempDir, 'test.tsx')
-    fs.writeFileSync(testFile, '#!/usr/bin/env bun\n')
-    fs.chmodSync(testFile, '644')
-
-    ensureExecutable(testFile)
-
-    const stats = fs.statSync(testFile)
-    expect((stats.mode & 0o100) !== 0).toBe(true)
-  })
-
-  test('leaves already executable file unchanged', () => {
-    const testFile = path.join(tempDir, 'exec.tsx')
-    fs.writeFileSync(testFile, '#!/usr/bin/env bun\n')
-    fs.chmodSync(testFile, '755')
-
-    ensureExecutable(testFile)
-
-    const stats = fs.statSync(testFile)
-    expect((stats.mode & 0o755) !== 0).toBe(true)
-  })
-
-  test('sets mode 755', () => {
-    const testFile = path.join(tempDir, 'mode.tsx')
-    fs.writeFileSync(testFile, '#!/usr/bin/env bun\n')
-    fs.chmodSync(testFile, '600')
-
-    ensureExecutable(testFile)
-
-    const stats = fs.statSync(testFile)
-    expect((stats.mode & 0o100) !== 0).toBe(true)
-  })
-})
-
-describe('findPreloadPath', () => {
-  test('throws error when preload.ts not found', () => {
-    const fakeUrl = 'file:///nonexistent/path/module.ts'
-    expect(() => findPreloadPath(fakeUrl)).toThrow('preload.ts')
-    expect(() => findPreloadPath(fakeUrl)).toThrow('smithers-orchestrator')
-  })
-
-  test('error message is descriptive', () => {
-    try {
-      findPreloadPath('file:///fake/path/module.ts')
-    } catch (e) {
-      expect(e instanceof Error).toBe(true)
-      expect((e as Error).message).toContain('incorrectly installed')
-    }
-  })
-})
-
-describe('findPackageRoot', () => {
-  test('finds package.json from this module location', () => {
-    const result = findPackageRoot(import.meta.url)
-    const packageJsonPath = path.join(result, 'package.json')
-    expect(fs.existsSync(packageJsonPath)).toBe(true)
-  })
-
-  test('returns startDir when package.json not found', () => {
-    const fakeUrl = 'file:///nonexistent/deep/path/module.ts'
-    const result = findPackageRoot(fakeUrl)
-    expect(result).toBe('/nonexistent/deep/path')
-  })
-})
-
-describe('resolveDbPaths', () => {
-  test('uses default path when input not provided', () => {
-    const result = resolveDbPaths()
-    expect(result.requestedPath).toBe(DEFAULT_DB_DIR)
-    expect(result.dbFile).toBe(path.join(DEFAULT_DB_DIR, DB_FILE_NAME))
-  })
-
-  test('uses provided input path', () => {
-    const result = resolveDbPaths('/custom/path')
-    expect(result.requestedPath).toBe('/custom/path')
-    expect(result.dbFile).toBe('/custom/path/smithers.db')
-  })
-
-  test('handles input path ending with .db', () => {
-    const result = resolveDbPaths('/custom/mydb.db')
-    expect(result.requestedPath).toBe('/custom/mydb.db')
-    expect(result.dbFile).toBe('/custom/mydb.db')
-  })
-
-  test('appends DB_FILE_NAME to directory paths', () => {
-    const result = resolveDbPaths('/some/directory')
-    expect(result.dbFile).toBe('/some/directory/smithers.db')
-  })
-
-  test('uses custom default path when provided', () => {
-    const result = resolveDbPaths(undefined, '/my/default')
-    expect(result.requestedPath).toBe('/my/default')
-    expect(result.dbFile).toBe('/my/default/smithers.db')
-  })
-})

package/src/commands/db/current-view.test.ts

@@ -1,379 +0,0 @@
-/**
- * Tests for current-view
- * 
- * Covers: Current execution details, phase, agent, tool calls, state
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
-import { showCurrent } from './current-view'
-
-describe('showCurrent', () => {
-  let consoleOutput: string[]
-  let originalConsoleLog: typeof console.log
-
-  beforeEach(() => {
-    consoleOutput = []
-    originalConsoleLog = console.log
-    console.log = (...args: unknown[]) => {
-      consoleOutput.push(args.map(String).join(' '))
-    }
-  })
-
-  afterEach(() => {
-    console.log = originalConsoleLog
-  })
-
-  interface Execution {
-    id: string
-    name?: string
-    status: string
-    file_path: string
-  }
-
-  interface Phase {
-    name: string
-    iteration: number
-    status: string
-  }
-
-  interface Agent {
-    id: string
-    model: string
-    status: string
-    prompt: string
-  }
-
-  interface ToolCall {
-    tool_name: string
-    status: string
-  }
-
-  interface MockDbOptions {
-    execution?: Execution | null
-    phase?: Phase | null
-    agent?: Agent | null
-    tools?: ToolCall[]
-    state?: Record<string, unknown>
-  }
-
-  function createMockDb(options: MockDbOptions = {}) {
-    return {
-      execution: {
-        current: async () => options.execution ?? null
-      },
-      phases: {
-        current: async () => options.phase ?? null
-      },
-      agents: {
-        current: async () => options.agent ?? null
-      },
-      tools: {
-        list: async () => options.tools ?? []
-      },
-      state: {
-        getAll: async () => options.state ?? {}
-      }
-    }
-  }
-
-  describe('no active execution', () => {
-    test('prints "(no active execution)" when null', async () => {
-      const db = createMockDb({ execution: null })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('(no active execution)'))).toBe(true)
-    })
-
-    test('returns early when no execution', async () => {
-      const db = createMockDb({ execution: null })
-      await showCurrent(db)
-      
-      // Should not try to show phase/agent details
-      expect(consoleOutput.some(line => line.includes('Current Phase'))).toBe(false)
-    })
-  })
-
-  describe('execution display', () => {
-    test('shows execution name or "Unnamed"', async () => {
-      const db = createMockDb({
-        execution: { id: '1', name: 'Test Execution', status: 'running', file_path: '/test.tsx' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Name: Test Execution'))).toBe(true)
-    })
-
-    test('shows "Unnamed" when name is missing', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Unnamed'))).toBe(true)
-    })
-
-    test('shows execution ID', async () => {
-      const db = createMockDb({
-        execution: { id: 'exec-abc123', status: 'running', file_path: '/test.tsx' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('ID: exec-abc123'))).toBe(true)
-    })
-
-    test('shows uppercase status', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Status: RUNNING'))).toBe(true)
-    })
-
-    test('shows file path', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/path/to/main.tsx' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('File: /path/to/main.tsx'))).toBe(true)
-    })
-  })
-
-  describe('phase display', () => {
-    test('shows current phase name', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        phase: { name: 'Implementation', iteration: 1, status: 'running' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Current Phase: Implementation'))).toBe(true)
-    })
-
-    test('shows phase iteration number', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        phase: { name: 'Review', iteration: 3, status: 'running' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('iteration 3'))).toBe(true)
-    })
-
-    test('shows uppercase phase status', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        phase: { name: 'Test', iteration: 1, status: 'pending' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Phase Status: PENDING'))).toBe(true)
-    })
-
-    test('handles null phase gracefully', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        phase: null
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Current Phase'))).toBe(false)
-    })
-  })
-
-  describe('agent display', () => {
-    test('shows current agent model', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: { id: 'a1', model: 'claude-sonnet', status: 'running', prompt: 'Test prompt' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Current Agent: claude-sonnet'))).toBe(true)
-    })
-
-    test('shows uppercase agent status', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: { id: 'a1', model: 'claude-haiku', status: 'waiting', prompt: 'Test' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Agent Status: WAITING'))).toBe(true)
-    })
-
-    test('shows truncated prompt (100 chars with ...)', async () => {
-      const longPrompt = 'A'.repeat(150)
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: { id: 'a1', model: 'claude', status: 'running', prompt: longPrompt }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('...'))).toBe(true)
-      expect(consoleOutput.some(line => line.includes('A'.repeat(100)))).toBe(true)
-    })
-
-    test('handles null agent gracefully', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: null
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Current Agent'))).toBe(false)
-    })
-  })
-
-  describe('tool calls display', () => {
-    test('shows recent tool calls count', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: { id: 'a1', model: 'claude', status: 'running', prompt: 'Test' },
-        tools: [
-          { tool_name: 'Read', status: 'complete' },
-          { tool_name: 'Write', status: 'complete' },
-          { tool_name: 'Bash', status: 'running' }
-        ]
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Recent Tool Calls (3)'))).toBe(true)
-    })
-
-    test('shows last 5 tool calls', async () => {
-      const tools = Array.from({ length: 10 }, (_, i) => ({
-        tool_name: `Tool${i}`,
-        status: 'complete'
-      }))
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: { id: 'a1', model: 'claude', status: 'running', prompt: 'Test' },
-        tools
-      })
-      await showCurrent(db)
-      
-      // Should show the last 5 tools (Tool5-Tool9)
-      expect(consoleOutput.some(line => line.includes('Tool9'))).toBe(true)
-      expect(consoleOutput.some(line => line.includes('Tool5'))).toBe(true)
-    })
-
-    test('shows tool name and status', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: { id: 'a1', model: 'claude', status: 'running', prompt: 'Test' },
-        tools: [{ tool_name: 'Grep', status: 'complete' }]
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Grep') && line.includes('complete'))).toBe(true)
-    })
-
-    test('handles empty tool calls list', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: { id: 'a1', model: 'claude', status: 'running', prompt: 'Test' },
-        tools: []
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Recent Tool Calls'))).toBe(false)
-    })
-
-    test('only shows tools when agent exists', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: null,
-        tools: [{ tool_name: 'Read', status: 'complete' }]
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Recent Tool Calls'))).toBe(false)
-    })
-  })
-
-  describe('state display', () => {
-    test('shows all state key-value pairs', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        state: { phase: 'implementation', step: 1 }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('phase:'))).toBe(true)
-      expect(consoleOutput.some(line => line.includes('step:'))).toBe(true)
-    })
-
-    test('serializes values as JSON', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        state: { config: { nested: true } }
-      })
-      await showCurrent(db)
-      
-      const output = consoleOutput.join('\n')
-      expect(output).toContain('config')
-    })
-
-    test('handles empty state', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        state: {}
-      })
-      await showCurrent(db)
-      
-      // State section should still be printed
-      expect(consoleOutput.some(line => line.includes('State:'))).toBe(true)
-    })
-  })
-
-  describe('header formatting', () => {
-    test('prints correct header separator', async () => {
-      const db = createMockDb({})
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('═══════════════════════════════════════════════════════════'))).toBe(true)
-    })
-
-    test('prints "CURRENT EXECUTION" title', async () => {
-      const db = createMockDb({})
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('CURRENT EXECUTION'))).toBe(true)
-    })
-  })
-
-  describe('edge cases', () => {
-    test('handles null execution name', async () => {
-      const db = createMockDb({
-        execution: { id: '1', name: undefined, status: 'running', file_path: '/test.tsx' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Unnamed'))).toBe(true)
-    })
-
-    test('handles exactly 100 char prompt', async () => {
-      const exactPrompt = 'B'.repeat(100)
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: { id: 'a1', model: 'claude', status: 'running', prompt: exactPrompt }
-      })
-      await showCurrent(db)
-      
-      // Should show exactly 100 chars plus ...
-      expect(consoleOutput.some(line => line.includes('B'.repeat(100)))).toBe(true)
-    })
-
-    test('handles empty prompt string', async () => {
-      const db = createMockDb({
-        execution: { id: '1', status: 'running', file_path: '/test.tsx' },
-        agent: { id: 'a1', model: 'claude', status: 'running', prompt: '' }
-      })
-      await showCurrent(db)
-      
-      expect(consoleOutput.some(line => line.includes('Prompt:'))).toBe(true)
-    })
-  })
-})