smithers-orchestrator 0.1.13 → 0.1.15

package/bunfig.toml

@@ -1,11 +1,11 @@
 # Bun configuration for Smithers
 # https://bun.sh/docs/runtime/bunfig
 
-jsx = "react-jsx"
-jsxImportSource = "smithers-orchestrator"
+# 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.13",
+  "version": "0.1.15",
   "description": "Build AI agents with Solid.js - Declarative JSX for Claude orchestration",
   "type": "module",
   "main": "./src/index.ts",
@@ -36,6 +36,7 @@
     "skills",
     "templates",
     "bunfig.toml",
+    "preload.ts",
     "plugin.json",
     "README.md"
   ],
@@ -48,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: "universal", // For custom renderers using solid-js/universal
+    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/Git/Commit.test.tsx

@@ -0,0 +1,109 @@
+/**
+ * Unit tests for Git/Commit.tsx - Git commit component interface tests.
+ */
+import { describe, test, expect, mock } from 'bun:test'
+import type { CommitProps, CommitResult } from './Commit'
+
+describe('CommitProps interface', () => {
+  test('message is optional', () => {
+    const props: CommitProps = {}
+    expect(props.message).toBeUndefined()
+  })
+
+  test('message can be set', () => {
+    const props: CommitProps = { message: 'Add new feature' }
+    expect(props.message).toBe('Add new feature')
+  })
+
+  test('autoGenerate is optional boolean', () => {
+    const props: CommitProps = { autoGenerate: true }
+    expect(props.autoGenerate).toBe(true)
+  })
+
+  test('notes is optional object', () => {
+    const props: CommitProps = { notes: { key: 'value', number: 42 } }
+    expect(props.notes?.key).toBe('value')
+  })
+
+  test('files is optional string array', () => {
+    const props: CommitProps = { files: ['file1.ts', 'file2.ts'] }
+    expect(props.files).toHaveLength(2)
+  })
+
+  test('all is optional boolean for -a flag', () => {
+    const props: CommitProps = { all: true }
+    expect(props.all).toBe(true)
+  })
+
+  test('children can be used as message', () => {
+    const props: CommitProps = { children: 'Commit message via children' }
+    expect(props.children).toBe('Commit message via children')
+  })
+
+  test('onFinished callback receives CommitResult', () => {
+    const callback = mock(() => {})
+    const props: CommitProps = { onFinished: callback }
+
+    const result: CommitResult = {
+      commitHash: 'abc123',
+      message: 'Test commit',
+      filesChanged: ['file.ts'],
+      insertions: 10,
+      deletions: 5,
+    }
+
+    props.onFinished?.(result)
+    expect(callback).toHaveBeenCalledWith(result)
+  })
+
+  test('onError callback receives Error', () => {
+    const callback = mock(() => {})
+    const props: CommitProps = { onError: callback }
+
+    const error = new Error('Commit failed')
+    props.onError?.(error)
+    expect(callback).toHaveBeenCalledWith(error)
+  })
+})
+
+describe('CommitResult interface', () => {
+  test('has all required fields', () => {
+    const result: CommitResult = {
+      commitHash: 'abc123def456',
+      message: 'Feature: add new capability',
+      filesChanged: ['src/index.ts', 'src/utils.ts'],
+      insertions: 100,
+      deletions: 50,
+    }
+
+    expect(result.commitHash).toBe('abc123def456')
+    expect(result.message).toBe('Feature: add new capability')
+    expect(result.filesChanged).toHaveLength(2)
+    expect(result.insertions).toBe(100)
+    expect(result.deletions).toBe(50)
+  })
+
+  test('filesChanged can be empty', () => {
+    const result: CommitResult = {
+      commitHash: 'abc123',
+      message: 'Empty commit',
+      filesChanged: [],
+      insertions: 0,
+      deletions: 0,
+    }
+
+    expect(result.filesChanged).toHaveLength(0)
+  })
+})
+
+describe('Commit component', () => {
+  test('exports Commit function', async () => {
+    const { Commit } = await import('./Commit')
+    expect(typeof Commit).toBe('function')
+  })
+
+  test('Commit is a valid Solid component', async () => {
+    const { Commit } = await import('./Commit')
+    expect(Commit.length).toBeLessThanOrEqual(1)
+  })
+})

package/src/components/Git/Notes.test.tsx

@@ -0,0 +1,92 @@
+/**
+ * Unit tests for Git/Notes.tsx - Git notes component interface tests.
+ */
+import { describe, test, expect, mock } from 'bun:test'
+import type { NotesProps, NotesResult } from './Notes'
+
+describe('NotesProps interface', () => {
+  test('commitRef is optional, defaults to HEAD', () => {
+    const props: NotesProps = { data: { key: 'value' } }
+    expect(props.commitRef).toBeUndefined()
+  })
+
+  test('commitRef can be set', () => {
+    const props: NotesProps = { commitRef: 'abc123', data: {} }
+    expect(props.commitRef).toBe('abc123')
+  })
+
+  test('data is required object', () => {
+    const props: NotesProps = { data: { smithers: true, version: '1.0' } }
+    expect(props.data.smithers).toBe(true)
+    expect(props.data.version).toBe('1.0')
+  })
+
+  test('append is optional boolean', () => {
+    const props: NotesProps = { data: {}, append: true }
+    expect(props.append).toBe(true)
+  })
+
+  test('append defaults to false (replace)', () => {
+    const props: NotesProps = { data: {} }
+    expect(props.append).toBeUndefined() // Will default to false in component
+  })
+
+  test('onFinished callback receives NotesResult', () => {
+    const callback = mock(() => {})
+    const props: NotesProps = { data: {}, onFinished: callback }
+
+    const result: NotesResult = {
+      commitRef: 'HEAD',
+      data: { smithers: true },
+      previousNotes: null,
+    }
+
+    props.onFinished?.(result)
+    expect(callback).toHaveBeenCalledWith(result)
+  })
+
+  test('onError callback receives Error', () => {
+    const callback = mock(() => {})
+    const props: NotesProps = { data: {}, onError: callback }
+
+    const error = new Error('Notes failed')
+    props.onError?.(error)
+    expect(callback).toHaveBeenCalledWith(error)
+  })
+})
+
+describe('NotesResult interface', () => {
+  test('has all required fields', () => {
+    const result: NotesResult = {
+      commitRef: 'abc123',
+      data: { smithers: true, executionId: 'exec-1' },
+      previousNotes: null,
+    }
+
+    expect(result.commitRef).toBe('abc123')
+    expect(result.data.smithers).toBe(true)
+    expect(result.previousNotes).toBeNull()
+  })
+
+  test('previousNotes can contain prior notes when appending', () => {
+    const result: NotesResult = {
+      commitRef: 'HEAD',
+      data: { newData: true },
+      previousNotes: '{"oldData": true}',
+    }
+
+    expect(result.previousNotes).toBe('{"oldData": true}')
+  })
+})
+
+describe('Notes component', () => {
+  test('exports Notes function', async () => {
+    const { Notes } = await import('./Notes')
+    expect(typeof Notes).toBe('function')
+  })
+
+  test('Notes is a valid Solid component', async () => {
+    const { Notes } = await import('./Notes')
+    expect(Notes.length).toBeLessThanOrEqual(1)
+  })
+})

package/src/components/Hooks/OnCIFailure.test.tsx

@@ -0,0 +1,110 @@
+/**
+ * Unit tests for Hooks/OnCIFailure.tsx - CI failure hook component interface tests.
+ */
+import { describe, test, expect, mock } from 'bun:test'
+import type { OnCIFailureProps, CIFailure } from './OnCIFailure'
+
+describe('OnCIFailureProps interface', () => {
+  test('provider is required', () => {
+    const props: OnCIFailureProps = {
+      provider: 'github-actions',
+      children: null as any,
+    }
+    expect(props.provider).toBe('github-actions')
+  })
+
+  test('pollInterval is optional', () => {
+    const props: OnCIFailureProps = {
+      provider: 'github-actions',
+      children: null as any,
+    }
+    expect(props.pollInterval).toBeUndefined()
+  })
+
+  test('pollInterval can be set', () => {
+    const props: OnCIFailureProps = {
+      provider: 'github-actions',
+      pollInterval: 60000,
+      children: null as any,
+    }
+    expect(props.pollInterval).toBe(60000)
+  })
+
+  test('onFailure is optional callback', () => {
+    const callback = mock(() => {})
+    const props: OnCIFailureProps = {
+      provider: 'github-actions',
+      onFailure: callback,
+      children: null as any,
+    }
+
+    const failure: CIFailure = {
+      failed: true,
+      runId: '12345',
+      workflowName: 'CI',
+      failedJobs: ['test', 'lint'],
+      logs: 'Error: test failed',
+    }
+
+    props.onFailure?.(failure)
+    expect(callback).toHaveBeenCalledWith(failure)
+  })
+
+  test('children is required', () => {
+    const props: OnCIFailureProps = {
+      provider: 'github-actions',
+      children: null as any,
+    }
+    expect(props.children).toBeNull()
+  })
+})
+
+describe('CIFailure interface', () => {
+  test('minimal failure', () => {
+    const failure: CIFailure = {
+      failed: true,
+    }
+
+    expect(failure.failed).toBe(true)
+    expect(failure.runId).toBeUndefined()
+    expect(failure.workflowName).toBeUndefined()
+  })
+
+  test('full failure with all fields', () => {
+    const failure: CIFailure = {
+      failed: true,
+      runId: '123456789',
+      workflowName: 'Build and Test',
+      failedJobs: ['unit-tests', 'integration-tests'],
+      logs: 'Test failed at line 42',
+    }
+
+    expect(failure.failed).toBe(true)
+    expect(failure.runId).toBe('123456789')
+    expect(failure.workflowName).toBe('Build and Test')
+    expect(failure.failedJobs).toHaveLength(2)
+    expect(failure.logs).toContain('line 42')
+  })
+
+  test('failure with empty failedJobs', () => {
+    const failure: CIFailure = {
+      failed: true,
+      runId: '123',
+      failedJobs: [],
+    }
+
+    expect(failure.failedJobs).toHaveLength(0)
+  })
+})
+
+describe('OnCIFailure component', () => {
+  test('exports OnCIFailure function', async () => {
+    const { OnCIFailure } = await import('./OnCIFailure')
+    expect(typeof OnCIFailure).toBe('function')
+  })
+
+  test('OnCIFailure is a valid Solid component', async () => {
+    const { OnCIFailure } = await import('./OnCIFailure')
+    expect(OnCIFailure.length).toBeLessThanOrEqual(1)
+  })
+})

package/src/components/Hooks/PostCommit.test.tsx

@@ -0,0 +1,75 @@
+/**
+ * Unit tests for Hooks/PostCommit.tsx - Post commit hook component interface tests.
+ */
+import { describe, test, expect, mock } from 'bun:test'
+import type { PostCommitProps } from './PostCommit'
+
+describe('PostCommitProps interface', () => {
+  test('children is required', () => {
+    const props: PostCommitProps = {
+      children: null as any,
+    }
+    expect(props.children).toBeNull()
+  })
+
+  test('runOn is optional', () => {
+    const props: PostCommitProps = {
+      children: null as any,
+    }
+    expect(props.runOn).toBeUndefined()
+  })
+
+  test('runOn can be all', () => {
+    const props: PostCommitProps = {
+      children: null as any,
+      runOn: 'all',
+    }
+    expect(props.runOn).toBe('all')
+  })
+
+  test('runOn can be smithers-only', () => {
+    const props: PostCommitProps = {
+      children: null as any,
+      runOn: 'smithers-only',
+    }
+    expect(props.runOn).toBe('smithers-only')
+  })
+
+  test('async is optional boolean', () => {
+    const props: PostCommitProps = {
+      children: null as any,
+    }
+    expect(props.async).toBeUndefined()
+  })
+
+  test('async can be true', () => {
+    const props: PostCommitProps = {
+      children: null as any,
+      async: true,
+    }
+    expect(props.async).toBe(true)
+  })
+
+  test('all props together', () => {
+    const props: PostCommitProps = {
+      children: null as any,
+      runOn: 'smithers-only',
+      async: true,
+    }
+
+    expect(props.runOn).toBe('smithers-only')
+    expect(props.async).toBe(true)
+  })
+})
+
+describe('PostCommit component', () => {
+  test('exports PostCommit function', async () => {
+    const { PostCommit } = await import('./PostCommit')
+    expect(typeof PostCommit).toBe('function')
+  })
+
+  test('PostCommit is a valid Solid component', async () => {
+    const { PostCommit } = await import('./PostCommit')
+    expect(PostCommit.length).toBeLessThanOrEqual(1)
+  })
+})

package/src/components/JJ/Commit.test.tsx

@@ -0,0 +1,56 @@
+/**
+ * Unit tests for JJ/Commit.tsx - JJ commit component interface tests.
+ */
+import { describe, test, expect, mock } from 'bun:test'
+import type { CommitProps } from './Commit'
+
+describe('CommitProps interface', () => {
+  test('message is optional string', () => {
+    const props: CommitProps = {}
+    expect(props.message).toBeUndefined()
+  })
+
+  test('message can be set', () => {
+    const props: CommitProps = { message: 'Add new feature' }
+    expect(props.message).toBe('Add new feature')
+  })
+
+  test('autoDescribe is optional boolean', () => {
+    const props: CommitProps = { autoDescribe: true }
+    expect(props.autoDescribe).toBe(true)
+  })
+
+  test('notes is optional string', () => {
+    const props: CommitProps = { notes: 'Additional metadata' }
+    expect(props.notes).toBe('Additional metadata')
+  })
+
+  test('children is optional', () => {
+    const props: CommitProps = {}
+    expect(props.children).toBeUndefined()
+  })
+
+  test('all props together', () => {
+    const props: CommitProps = {
+      message: 'Feature commit',
+      autoDescribe: false,
+      notes: '{"key": "value"}',
+    }
+
+    expect(props.message).toBe('Feature commit')
+    expect(props.autoDescribe).toBe(false)
+    expect(props.notes).toBe('{"key": "value"}')
+  })
+})
+
+describe('Commit component', () => {
+  test('exports Commit function', async () => {
+    const { Commit } = await import('./Commit')
+    expect(typeof Commit).toBe('function')
+  })
+
+  test('Commit is a valid Solid component', async () => {
+    const { Commit } = await import('./Commit')
+    expect(Commit.length).toBeLessThanOrEqual(1)
+  })
+})

package/src/components/JJ/Describe.test.tsx

@@ -0,0 +1,49 @@
+/**
+ * Unit tests for JJ/Describe.tsx - JJ describe component interface tests.
+ */
+import { describe, test, expect, mock } from 'bun:test'
+import type { DescribeProps } from './Describe'
+
+describe('DescribeProps interface', () => {
+  test('useAgent is optional', () => {
+    const props: DescribeProps = {}
+    expect(props.useAgent).toBeUndefined()
+  })
+
+  test('useAgent can be claude', () => {
+    const props: DescribeProps = { useAgent: 'claude' }
+    expect(props.useAgent).toBe('claude')
+  })
+
+  test('template is optional string', () => {
+    const props: DescribeProps = { template: 'feat: {summary}' }
+    expect(props.template).toBe('feat: {summary}')
+  })
+
+  test('children is optional', () => {
+    const props: DescribeProps = {}
+    expect(props.children).toBeUndefined()
+  })
+
+  test('all props together', () => {
+    const props: DescribeProps = {
+      useAgent: 'claude',
+      template: 'conventional-commits',
+    }
+
+    expect(props.useAgent).toBe('claude')
+    expect(props.template).toBe('conventional-commits')
+  })
+})
+
+describe('Describe component', () => {
+  test('exports Describe function', async () => {
+    const { Describe } = await import('./Describe')
+    expect(typeof Describe).toBe('function')
+  })
+
+  test('Describe is a valid Solid component', async () => {
+    const { Describe } = await import('./Describe')
+    expect(Describe.length).toBeLessThanOrEqual(1)
+  })
+})