smithers-orchestrator 0.1.12 → 0.1.14

package/bunfig.toml

@@ -1,12 +1,11 @@
 # Bun configuration for Smithers
 # https://bun.sh/docs/runtime/bunfig
-# Usage: bun -c node_modules/smithers-orchestrator/bunfig.toml your-file.tsx
 
-jsx = "react-jsx"
-jsxImportSource = "solid-js/h"
+# Use bun-plugin-solid for Solid JSX transform
+preload = ["./preload.ts"]
 
 [install]
 auto = "fallback"
 
 [test]
-preload = ["./test/preload.ts"]
+preload = ["./preload.ts", "./test/preload.ts"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smithers-orchestrator",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Build AI agents with Solid.js - Declarative JSX for Claude orchestration",
   "type": "module",
   "main": "./src/index.ts",
@@ -9,6 +9,8 @@
   },
   "exports": {
     ".": "./src/index.ts",
+    "./jsx-runtime": "./src/jsx-runtime.ts",
+    "./jsx-dev-runtime": "./src/jsx-runtime.ts",
     "./core": "./src/core/index.ts",
     "./solid": "./src/solid/index.ts",
     "./components": "./src/components/index.ts",
@@ -34,6 +36,7 @@
     "skills",
     "templates",
     "bunfig.toml",
+    "preload.ts",
     "plugin.json",
     "README.md"
   ],
@@ -46,7 +49,11 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.1.76",
     "@anthropic-ai/sdk": "^0.71.2",
+    "@babel/core": "^7.28.6",
+    "@babel/preset-typescript": "^7.28.5",
+    "@dschz/bun-plugin-solid": "^1.0.4",
     "@electric-sql/pglite": "^0.3.15",
+    "babel-preset-solid": "^1.9.10",
     "commander": "^12.0.0",
     "solid-js": "^1.9.10",
     "zod": "^4.3.5"

package/preload.ts

@@ -0,0 +1,9 @@
+import { SolidPlugin } from "@dschz/bun-plugin-solid";
+
+await Bun.plugin(
+  SolidPlugin({
+    generate: "ssr", // SSR mode doesn't require DOM globals
+    hydratable: false,
+    debug: false,
+  }),
+);

package/src/components/Claude.test.tsx

@@ -0,0 +1,97 @@
+/**
+ * Unit tests for Claude.tsx - Claude component interface tests.
+ * Tests the component's props and interface, not execution behavior.
+ */
+import { describe, test, expect, mock } from 'bun:test'
+import type { ClaudeProps } from './Claude'
+
+describe('ClaudeProps interface', () => {
+  test('model is optional string', () => {
+    const props: ClaudeProps = {}
+    expect(props.model).toBeUndefined()
+  })
+
+  test('model can be set', () => {
+    const props: ClaudeProps = { model: 'claude-opus-4' }
+    expect(props.model).toBe('claude-opus-4')
+  })
+
+  test('maxTurns is optional number', () => {
+    const props: ClaudeProps = { maxTurns: 5 }
+    expect(props.maxTurns).toBe(5)
+  })
+
+  test('tools is optional string array', () => {
+    const props: ClaudeProps = { tools: ['Read', 'Edit', 'Bash'] }
+    expect(props.tools).toHaveLength(3)
+  })
+
+  test('systemPrompt is optional string', () => {
+    const props: ClaudeProps = { systemPrompt: 'You are a helpful assistant' }
+    expect(props.systemPrompt).toBe('You are a helpful assistant')
+  })
+
+  test('onFinished is optional callback', () => {
+    const callback = mock(() => {})
+    const props: ClaudeProps = { onFinished: callback }
+
+    props.onFinished?.('result')
+    expect(callback).toHaveBeenCalledWith('result')
+  })
+
+  test('onError is optional callback', () => {
+    const callback = mock(() => {})
+    const props: ClaudeProps = { onError: callback }
+
+    const error = new Error('test')
+    props.onError?.(error)
+    expect(callback).toHaveBeenCalledWith(error)
+  })
+
+  test('validate is optional async function', async () => {
+    const validate = mock(async () => true)
+    const props: ClaudeProps = { validate }
+
+    const result = await props.validate?.('test')
+    expect(result).toBe(true)
+    expect(validate).toHaveBeenCalledWith('test')
+  })
+
+  test('validate can return false', async () => {
+    const validate = mock(async () => false)
+    const props: ClaudeProps = { validate }
+
+    const result = await props.validate?.('invalid')
+    expect(result).toBe(false)
+  })
+
+  test('allows arbitrary additional props', () => {
+    const props: ClaudeProps = {
+      customProp: 'value',
+      numberProp: 42,
+      boolProp: true,
+      objectProp: { key: 'value' },
+    }
+
+    expect(props.customProp).toBe('value')
+    expect(props.numberProp).toBe(42)
+  })
+
+  test('children is optional', () => {
+    const props: ClaudeProps = {}
+    expect(props.children).toBeUndefined()
+  })
+})
+
+describe('Claude component behavior', () => {
+  test('exports Claude function', async () => {
+    const { Claude } = await import('./Claude')
+    expect(typeof Claude).toBe('function')
+  })
+
+  test('Claude is a valid Solid component', async () => {
+    const { Claude } = await import('./Claude')
+    // A component should accept props
+    expect(Claude.length).toBeLessThanOrEqual(1)
+  })
+})

package/src/components/Phase.tsx

@@ -11,9 +11,10 @@ export interface PhaseProps {
  * Provides semantic structure to agent workflows.
  */
 export function Phase(props: PhaseProps): JSX.Element {
+  const { children, ...rest } = props
   return (
-    <phase name={props.name}>
-      {props.children}
+    <phase {...rest}>
+      {children}
     </phase>
   )
 }

package/src/components/Ralph.test.tsx

@@ -0,0 +1,111 @@
+/**
+ * Unit tests for Ralph.tsx - Ralph orchestration component.
+ */
+import { describe, test, expect, mock } from 'bun:test'
+import {
+  RalphContext,
+  createOrchestrationPromise,
+  signalOrchestrationComplete,
+  signalOrchestrationError,
+} from './Ralph'
+
+describe('RalphContext', () => {
+  test('RalphContext is exported', () => {
+    expect(RalphContext).toBeDefined()
+  })
+})
+
+describe('Orchestration promise functions', () => {
+  test('createOrchestrationPromise returns a promise', () => {
+    const promise = createOrchestrationPromise()
+
+    expect(promise).toBeInstanceOf(Promise)
+  })
+
+  test('signalOrchestrationComplete resolves the promise', async () => {
+    const promise = createOrchestrationPromise()
+
+    // Signal completion in next tick
+    setTimeout(() => signalOrchestrationComplete(), 0)
+
+    await promise
+    // If we get here, the promise resolved
+    expect(true).toBe(true)
+  })
+
+  test('signalOrchestrationError rejects the promise', async () => {
+    const promise = createOrchestrationPromise()
+    const error = new Error('Test error')
+
+    // Signal error in next tick
+    setTimeout(() => signalOrchestrationError(error), 0)
+
+    try {
+      await promise
+      expect(true).toBe(false) // Should not reach here
+    } catch (e) {
+      expect(e).toBe(error)
+    }
+  })
+
+  test('signalOrchestrationComplete is safe to call without promise', () => {
+    // Should not throw even if no promise exists
+    signalOrchestrationComplete()
+    expect(true).toBe(true)
+  })
+
+  test('signalOrchestrationError is safe to call without promise', () => {
+    // Should not throw even if no promise exists
+    signalOrchestrationError(new Error('Test'))
+    expect(true).toBe(true)
+  })
+
+  test('calling complete twice is safe', async () => {
+    const promise = createOrchestrationPromise()
+
+    setTimeout(() => {
+      signalOrchestrationComplete()
+      signalOrchestrationComplete() // Second call should be no-op
+    }, 0)
+
+    await promise
+    expect(true).toBe(true)
+  })
+
+  test('calling error after complete is no-op', async () => {
+    const promise = createOrchestrationPromise()
+
+    setTimeout(() => {
+      signalOrchestrationComplete()
+      signalOrchestrationError(new Error('Should not reject')) // Should be no-op
+    }, 0)
+
+    await promise
+    expect(true).toBe(true)
+  })
+})
+
+describe('RalphContextType interface', () => {
+  test('context value has registerTask and completeTask', () => {
+    // Create a mock context value
+    const contextValue = {
+      registerTask: mock(() => {}),
+      completeTask: mock(() => {}),
+    }
+
+    expect(contextValue.registerTask).toBeDefined()
+    expect(contextValue.completeTask).toBeDefined()
+  })
+
+  test('registerTask can be called', () => {
+    const registerTask = mock(() => {})
+    registerTask()
+    expect(registerTask).toHaveBeenCalled()
+  })
+
+  test('completeTask can be called', () => {
+    const completeTask = mock(() => {})
+    completeTask()
+    expect(completeTask).toHaveBeenCalled()
+  })
+})

package/src/components/Review.test.tsx

@@ -0,0 +1,231 @@
+/**
+ * Unit tests for Review.tsx - Code review component interface tests.
+ */
+import { describe, test, expect, mock } from 'bun:test'
+import type { ReviewTarget, ReviewResult, ReviewIssue, ReviewProps } from './Review'
+
+describe('ReviewTarget interface', () => {
+  test('commit target with optional ref', () => {
+    const target: ReviewTarget = { type: 'commit' }
+    expect(target.type).toBe('commit')
+    expect(target.ref).toBeUndefined()
+  })
+
+  test('commit target with ref', () => {
+    const target: ReviewTarget = { type: 'commit', ref: 'abc123' }
+    expect(target.type).toBe('commit')
+    expect(target.ref).toBe('abc123')
+  })
+
+  test('diff target without ref', () => {
+    const target: ReviewTarget = { type: 'diff' }
+    expect(target.type).toBe('diff')
+  })
+
+  test('diff target with ref', () => {
+    const target: ReviewTarget = { type: 'diff', ref: 'feature-branch' }
+    expect(target.type).toBe('diff')
+    expect(target.ref).toBe('feature-branch')
+  })
+
+  test('pr target requires ref', () => {
+    const target: ReviewTarget = { type: 'pr', ref: '123' }
+    expect(target.type).toBe('pr')
+    expect(target.ref).toBe('123')
+  })
+
+  test('files target with files array', () => {
+    const target: ReviewTarget = {
+      type: 'files',
+      files: ['src/index.ts', 'src/utils.ts'],
+    }
+    expect(target.type).toBe('files')
+    expect(target.files).toHaveLength(2)
+  })
+})
+
+describe('ReviewResult interface', () => {
+  test('approved result structure', () => {
+    const result: ReviewResult = {
+      approved: true,
+      summary: 'Looks good!',
+      issues: [],
+    }
+
+    expect(result.approved).toBe(true)
+    expect(result.summary).toBe('Looks good!')
+    expect(result.issues).toHaveLength(0)
+  })
+
+  test('rejected result with issues', () => {
+    const result: ReviewResult = {
+      approved: false,
+      summary: 'Found issues',
+      issues: [
+        {
+          severity: 'critical',
+          message: 'Security vulnerability',
+          file: 'auth.ts',
+          line: 42,
+          suggestion: 'Use parameterized queries',
+        },
+      ],
+    }
+
+    expect(result.approved).toBe(false)
+    expect(result.issues).toHaveLength(1)
+    expect(result.issues[0].severity).toBe('critical')
+  })
+
+  test('result with multiple issues', () => {
+    const result: ReviewResult = {
+      approved: false,
+      summary: 'Multiple issues found',
+      issues: [
+        { severity: 'critical', message: 'Issue 1' },
+        { severity: 'major', message: 'Issue 2' },
+        { severity: 'minor', message: 'Issue 3' },
+      ],
+    }
+
+    expect(result.issues).toHaveLength(3)
+  })
+})
+
+describe('ReviewIssue interface', () => {
+  test('minimal issue', () => {
+    const issue: ReviewIssue = {
+      severity: 'minor',
+      message: 'Consider adding a comment',
+    }
+
+    expect(issue.severity).toBe('minor')
+    expect(issue.message).toBe('Consider adding a comment')
+    expect(issue.file).toBeUndefined()
+    expect(issue.line).toBeUndefined()
+    expect(issue.suggestion).toBeUndefined()
+  })
+
+  test('full issue with all fields', () => {
+    const issue: ReviewIssue = {
+      severity: 'major',
+      file: 'component.tsx',
+      line: 100,
+      message: 'Missing error handling',
+      suggestion: 'Add try-catch block',
+    }
+
+    expect(issue.severity).toBe('major')
+    expect(issue.file).toBe('component.tsx')
+    expect(issue.line).toBe(100)
+    expect(issue.suggestion).toBe('Add try-catch block')
+  })
+
+  test('critical severity', () => {
+    const issue: ReviewIssue = { severity: 'critical', message: 'Critical' }
+    expect(issue.severity).toBe('critical')
+  })
+
+  test('major severity', () => {
+    const issue: ReviewIssue = { severity: 'major', message: 'Major' }
+    expect(issue.severity).toBe('major')
+  })
+
+  test('minor severity', () => {
+    const issue: ReviewIssue = { severity: 'minor', message: 'Minor' }
+    expect(issue.severity).toBe('minor')
+  })
+})
+
+describe('ReviewProps interface', () => {
+  test('minimal props with target', () => {
+    const props: ReviewProps = {
+      target: { type: 'commit' },
+    }
+    expect(props.target.type).toBe('commit')
+  })
+
+  test('props with agent', () => {
+    const props: ReviewProps = {
+      target: { type: 'commit' },
+      agent: 'claude',
+    }
+    expect(props.agent).toBe('claude')
+  })
+
+  test('props with model', () => {
+    const props: ReviewProps = {
+      target: { type: 'commit' },
+      model: 'claude-opus-4',
+    }
+    expect(props.model).toBe('claude-opus-4')
+  })
+
+  test('props with blocking', () => {
+    const props: ReviewProps = {
+      target: { type: 'commit' },
+      blocking: true,
+    }
+    expect(props.blocking).toBe(true)
+  })
+
+  test('props with criteria', () => {
+    const props: ReviewProps = {
+      target: { type: 'commit' },
+      criteria: ['Check security', 'Check performance'],
+    }
+    expect(props.criteria).toHaveLength(2)
+  })
+
+  test('props with postToGitHub', () => {
+    const props: ReviewProps = {
+      target: { type: 'pr', ref: '123' },
+      postToGitHub: true,
+    }
+    expect(props.postToGitHub).toBe(true)
+  })
+
+  test('props with postToGitNotes', () => {
+    const props: ReviewProps = {
+      target: { type: 'commit' },
+      postToGitNotes: true,
+    }
+    expect(props.postToGitNotes).toBe(true)
+  })
+
+  test('onFinished callback', () => {
+    const callback = mock(() => {})
+    const props: ReviewProps = {
+      target: { type: 'commit' },
+      onFinished: callback,
+    }
+
+    const result: ReviewResult = { approved: true, summary: 'Good', issues: [] }
+    props.onFinished?.(result)
+    expect(callback).toHaveBeenCalledWith(result)
+  })
+
+  test('onError callback', () => {
+    const callback = mock(() => {})
+    const props: ReviewProps = {
+      target: { type: 'commit' },
+      onError: callback,
+    }
+
+    const error = new Error('test')
+    props.onError?.(error)
+    expect(callback).toHaveBeenCalledWith(error)
+  })
+})
+
+describe('Review component', () => {
+  test('exports Review function', async () => {
+    const { Review } = await import('./Review')
+    expect(typeof Review).toBe('function')
+  })
+
+  test('Review is a valid Solid component', async () => {
+    const { Review } = await import('./Review')
+    expect(Review.length).toBeLessThanOrEqual(1)
+  })
+})

package/src/components/components.test.tsx

@@ -0,0 +1,158 @@
+/**
+ * Unit tests for components - Claude, Phase, Step, Ralph, etc.
+ */
+import { describe, test, expect } from 'bun:test'
+import { serialize } from '../core/serialize'
+import { jsx } from '../jsx-runtime'
+import { Claude } from './Claude'
+import { Phase } from './Phase'
+import { Step } from './Step'
+import { Stop } from './Stop'
+import { Persona } from './Persona'
+import { Constraints } from './Constraints'
+import { Task } from './Task'
+import { Human } from './Human'
+import { Subagent } from './Subagent'
+import { ClaudeApi } from './ClaudeApi'
+
+describe('Phase component', () => {
+  test('creates phase element with name prop', () => {
+    const node = jsx(Phase, { name: 'research' })
+    expect(node.type).toBe('phase')
+    expect(node.props.name).toBe('research')
+  })
+
+  test('spreads additional props', () => {
+    const node = jsx(Phase, { name: 'test', count: 42, enabled: true })
+    expect(node.props.name).toBe('test')
+    expect(node.props.count).toBe(42)
+    expect(node.props.enabled).toBe(true)
+  })
+
+  test('renders children', () => {
+    const child = jsx('step', { children: 'Step content' })
+    const node = jsx(Phase, { name: 'test', children: child })
+    expect(node.children).toHaveLength(1)
+  })
+})
+
+describe('Step component', () => {
+  test('creates step element', () => {
+    const node = jsx(Step, { children: 'Do something' })
+    expect(node.type).toBe('step')
+  })
+
+  test('renders text children', () => {
+    const node = jsx(Step, { children: 'Read the docs' })
+    expect(node.children).toHaveLength(1)
+    expect(node.children[0].type).toBe('TEXT')
+  })
+})
+
+describe('Stop component', () => {
+  test('creates smithers-stop element', () => {
+    const node = jsx(Stop, { reason: 'All done' })
+    expect(node.type).toBe('smithers-stop')
+    expect(node.props.reason).toBe('All done')
+  })
+
+  test('works without reason', () => {
+    const node = jsx(Stop, {})
+    expect(node.type).toBe('smithers-stop')
+  })
+})
+
+describe('Persona component', () => {
+  test('creates persona element with role', () => {
+    const node = jsx(Persona, { role: 'security expert' })
+    expect(node.type).toBe('persona')
+    expect(node.props.role).toBe('security expert')
+  })
+
+  test('renders description children', () => {
+    const node = jsx(Persona, { role: 'expert', children: 'You specialize in security.' })
+    expect(node.children).toHaveLength(1)
+  })
+})
+
+describe('Constraints component', () => {
+  test('creates constraints element', () => {
+    const node = jsx(Constraints, { children: '- Be concise' })
+    expect(node.type).toBe('constraints')
+  })
+})
+
+describe('Task component', () => {
+  test('creates task element with done prop', () => {
+    const node = jsx(Task, { done: false, children: 'Pending task' })
+    expect(node.type).toBe('task')
+    expect(node.props.done).toBe(false)
+  })
+
+  test('done prop can be true', () => {
+    const node = jsx(Task, { done: true, children: 'Completed task' })
+    expect(node.props.done).toBe(true)
+  })
+})
+
+describe('Human component', () => {
+  test('creates human element with message', () => {
+    const node = jsx(Human, { message: 'Approve?' })
+    expect(node.type).toBe('human')
+    expect(node.props.message).toBe('Approve?')
+  })
+})
+
+describe('Subagent component', () => {
+  test('creates subagent element with name', () => {
+    const node = jsx(Subagent, { name: 'researcher' })
+    expect(node.type).toBe('subagent')
+    expect(node.props.name).toBe('researcher')
+  })
+
+  test('parallel prop is set', () => {
+    const node = jsx(Subagent, { name: 'parallel-agent', parallel: true })
+    expect(node.props.parallel).toBe(true)
+  })
+
+  test('renders child components', () => {
+    const child = jsx(Phase, { name: 'inner' })
+    const node = jsx(Subagent, { name: 'outer', children: child })
+    expect(node.children).toHaveLength(1)
+  })
+})
+
+describe('ClaudeApi component', () => {
+  test('creates claude-api element', () => {
+    const node = jsx(ClaudeApi, { children: 'Prompt text' })
+    expect(node.type).toBe('claude-api')
+  })
+
+  test('accepts model prop', () => {
+    const node = jsx(ClaudeApi, { model: 'claude-opus-4' })
+    expect(node.props.model).toBe('claude-opus-4')
+  })
+})
+
+describe('Component composition', () => {
+  test('nested components create proper tree structure', () => {
+    const stepNode = jsx(Step, { children: 'Step 1' })
+    const phaseNode = jsx(Phase, { name: 'test', children: stepNode })
+
+    expect(phaseNode.type).toBe('phase')
+    expect(phaseNode.children).toHaveLength(1)
+    expect(phaseNode.children[0].type).toBe('step')
+  })
+
+  test('serializes nested structure correctly', () => {
+    const stepNode = jsx(Step, { children: 'Do work' })
+    const phaseNode = jsx(Phase, { name: 'main', children: stepNode })
+
+    const xml = serialize(phaseNode)
+
+    expect(xml).toContain('<phase name="main">')
+    expect(xml).toContain('<step>')
+    expect(xml).toContain('Do work')
+    expect(xml).toContain('</phase>')
+  })
+})