smithers-orchestrator 0.1.12 → 0.1.13

package/bunfig.toml

@@ -1,9 +1,8 @@
 # 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"
+jsxImportSource = "smithers-orchestrator"
 
 [install]
 auto = "fallback"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smithers-orchestrator",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "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",

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/core/execute.test.ts

@@ -0,0 +1,84 @@
+/**
+ * Unit tests for execute.ts - Ralph Wiggum loop execution engine.
+ */
+import { describe, test, expect } from 'bun:test'
+import { executePlan } from './execute'
+import type { SmithersNode } from './types'
+
+describe('executePlan', () => {
+  test('returns immediately when tree has no pending nodes', async () => {
+    const tree: SmithersNode = {
+      type: 'ROOT',
+      props: {},
+      children: [],
+      parent: null,
+    }
+
+    const result = await executePlan(tree)
+
+    expect(result.frames).toBe(1)
+    expect(result.output).toBeNull()
+    expect(result.totalDuration).toBeGreaterThanOrEqual(0)
+  })
+
+  test('respects maxFrames option', async () => {
+    const tree: SmithersNode = {
+      type: 'ROOT',
+      props: {},
+      children: [],
+      parent: null,
+    }
+
+    const result = await executePlan(tree, { maxFrames: 5 })
+
+    expect(result.frames).toBeLessThanOrEqual(5)
+  })
+
+  test('times out when timeout exceeded', async () => {
+    // Create a tree that would run forever (if findPendingExecutables returned nodes)
+    const tree: SmithersNode = {
+      type: 'ROOT',
+      props: {},
+      children: [],
+      parent: null,
+    }
+
+    // With current implementation (no pending nodes), this completes immediately
+    const result = await executePlan(tree, { timeout: 100 })
+    expect(result.frames).toBe(1)
+  })
+
+  test('handles nested tree structure', async () => {
+    const child: SmithersNode = {
+      type: 'phase',
+      props: { name: 'test' },
+      children: [],
+      parent: null,
+    }
+    const tree: SmithersNode = {
+      type: 'ROOT',
+      props: {},
+      children: [child],
+      parent: null,
+    }
+    child.parent = tree
+
+    const result = await executePlan(tree)
+
+    expect(result).toBeDefined()
+    expect(result.frames).toBe(1)
+  })
+
+  test('verbose option does not throw', async () => {
+    const tree: SmithersNode = {
+      type: 'ROOT',
+      props: {},
+      children: [],
+      parent: null,
+    }
+
+    // Should not throw with verbose mode
+    const result = await executePlan(tree, { verbose: true })
+    expect(result).toBeDefined()
+  })
+})

package/src/solid/h.test.ts

@@ -0,0 +1,163 @@
+/**
+ * Unit tests for h.ts - Hyperscript function for JSX compilation.
+ */
+import { describe, test, expect } from 'bun:test'
+import { h, Fragment } from './h'
+import type { SmithersNode } from '../core/types'
+
+describe('h() hyperscript function', () => {
+  test('creates basic element node', () => {
+    const node = h('div', null)
+
+    expect(node.type).toBe('div')
+    expect(node.props).toEqual({})
+    expect(node.children).toEqual([])
+    expect(node.parent).toBeNull()
+  })
+
+  test('creates element with props', () => {
+    const node = h('phase', { name: 'test', count: 42 })
+
+    expect(node.type).toBe('phase')
+    expect(node.props.name).toBe('test')
+    expect(node.props.count).toBe(42)
+  })
+
+  test('handles null props', () => {
+    const node = h('step', null)
+
+    expect(node.props).toEqual({})
+  })
+
+  test('creates text node from string child', () => {
+    const node = h('phase', null, 'Hello world')
+
+    expect(node.children).toHaveLength(1)
+    expect(node.children[0].type).toBe('TEXT')
+    expect(node.children[0].props.value).toBe('Hello world')
+    expect(node.children[0].parent).toBe(node)
+  })
+
+  test('creates text node from number child', () => {
+    const node = h('phase', null, 42)
+
+    expect(node.children).toHaveLength(1)
+    expect(node.children[0].type).toBe('TEXT')
+    expect(node.children[0].props.value).toBe('42')
+  })
+
+  test('sets parent reference for child nodes', () => {
+    const child = h('step', null)
+    const parent = h('phase', null, child)
+
+    expect(parent.children).toHaveLength(1)
+    expect(parent.children[0]).toBe(child)
+    expect(child.parent).toBe(parent)
+  })
+
+  test('handles multiple children', () => {
+    const child1 = h('step', null)
+    const child2 = h('step', null)
+    const parent = h('phase', null, child1, child2)
+
+    expect(parent.children).toHaveLength(2)
+    expect(child1.parent).toBe(parent)
+    expect(child2.parent).toBe(parent)
+  })
+
+  test('flattens nested arrays', () => {
+    const child1 = h('step', null)
+    const child2 = h('step', null)
+    const parent = h('phase', null, [child1, [child2]])
+
+    expect(parent.children).toHaveLength(2)
+  })
+
+  test('filters out null/undefined/boolean children', () => {
+    const child = h('step', null)
+    const parent = h('phase', null, null, undefined, false, true, child)
+
+    expect(parent.children).toHaveLength(1)
+    expect(parent.children[0]).toBe(child)
+  })
+
+  test('handles key prop specially', () => {
+    const node = h('step', { key: 'unique', name: 'test' })
+
+    expect(node.key).toBe('unique')
+    expect(node.props.key).toBeUndefined()
+    expect(node.props.name).toBe('test')
+  })
+
+  test('handles numeric key', () => {
+    const node = h('step', { key: 123 })
+
+    expect(node.key).toBe(123)
+    expect(node.props.key).toBeUndefined()
+  })
+
+  test('calls function components with props', () => {
+    const MyComponent = (props: { name: string }) => {
+      return h('custom', { customName: props.name })
+    }
+
+    const result = h(MyComponent, { name: 'test' })
+
+    expect(result.type).toBe('custom')
+    expect(result.props.customName).toBe('test')
+  })
+
+  test('passes children to function components', () => {
+    const MyComponent = (props: { children: any }) => {
+      return h('wrapper', null, props.children)
+    }
+
+    const child = h('step', null)
+    const result = h(MyComponent, null, child)
+
+    expect(result.type).toBe('wrapper')
+    expect(result.children).toHaveLength(1)
+  })
+
+  test('handles mixed children (nodes, strings, numbers)', () => {
+    const child = h('step', null)
+    const parent = h('phase', null, 'Text before', child, 42, 'Text after')
+
+    expect(parent.children).toHaveLength(4)
+    expect(parent.children[0].type).toBe('TEXT')
+    expect(parent.children[0].props.value).toBe('Text before')
+    expect(parent.children[1]).toBe(child)
+    expect(parent.children[2].type).toBe('TEXT')
+    expect(parent.children[2].props.value).toBe('42')
+    expect(parent.children[3].type).toBe('TEXT')
+    expect(parent.children[3].props.value).toBe('Text after')
+  })
+})
+
+describe('Fragment', () => {
+  test('returns children as-is', () => {
+    const children = [h('step', null), h('step', null)]
+    const result = Fragment({ children })
+
+    expect(result).toBe(children)
+  })
+
+  test('handles single child', () => {
+    const child = h('step', null)
+    const result = Fragment({ children: child })
+
+    expect(result).toBe(child)
+  })
+
+  test('handles undefined children', () => {
+    const result = Fragment({})
+
+    expect(result).toBeUndefined()
+  })
+
+  test('handles string children', () => {
+    const result = Fragment({ children: 'text content' })
+
+    expect(result).toBe('text content')
+  })
+})

package/src/utils/vcs.test.ts

@@ -0,0 +1,203 @@
+/**
+ * Unit tests for vcs.ts - VCS utilities for git and jj operations.
+ */
+import { describe, test, expect } from 'bun:test'
+import { parseGitStatus, parseJJStatus, parseDiffStats, isGitRepo, getCurrentBranch } from './vcs'
+
+describe('parseGitStatus', () => {
+  test('parses modified files', () => {
+    const output = `M  src/file1.ts
+ M src/file2.ts`
+
+    const result = parseGitStatus(output)
+
+    expect(result.modified).toContain('src/file1.ts')
+    expect(result.modified).toContain('src/file2.ts')
+    expect(result.added).toHaveLength(0)
+    expect(result.deleted).toHaveLength(0)
+  })
+
+  test('parses added files', () => {
+    const output = `A  src/new-file.ts
+AM src/another.ts`
+
+    const result = parseGitStatus(output)
+
+    expect(result.added).toContain('src/new-file.ts')
+    expect(result.added).toContain('src/another.ts')
+  })
+
+  test('parses deleted files', () => {
+    const output = `D  src/removed.ts
+ D src/deleted.ts`
+
+    const result = parseGitStatus(output)
+
+    expect(result.deleted).toContain('src/removed.ts')
+    expect(result.deleted).toContain('src/deleted.ts')
+  })
+
+  test('parses mixed status', () => {
+    const output = `M  src/modified.ts
+A  src/added.ts
+D  src/deleted.ts
+?? src/untracked.ts`
+
+    const result = parseGitStatus(output)
+
+    expect(result.modified).toContain('src/modified.ts')
+    expect(result.added).toContain('src/added.ts')
+    expect(result.deleted).toContain('src/deleted.ts')
+    // Untracked files are not included (no M, A, or D status)
+  })
+
+  test('handles empty output', () => {
+    const result = parseGitStatus('')
+
+    expect(result.modified).toHaveLength(0)
+    expect(result.added).toHaveLength(0)
+    expect(result.deleted).toHaveLength(0)
+  })
+
+  test('handles whitespace-only lines', () => {
+    const output = `M  src/file.ts
+
+   
+A  src/other.ts`
+
+    const result = parseGitStatus(output)
+
+    expect(result.modified).toHaveLength(1)
+    expect(result.added).toHaveLength(1)
+  })
+})
+
+describe('parseJJStatus', () => {
+  test('parses modified files', () => {
+    const output = `M src/file1.ts
+M src/file2.ts`
+
+    const result = parseJJStatus(output)
+
+    expect(result.modified).toContain('src/file1.ts')
+    expect(result.modified).toContain('src/file2.ts')
+  })
+
+  test('parses added files', () => {
+    const output = `A src/new-file.ts
+A src/another.ts`
+
+    const result = parseJJStatus(output)
+
+    expect(result.added).toContain('src/new-file.ts')
+    expect(result.added).toContain('src/another.ts')
+  })
+
+  test('parses deleted files', () => {
+    const output = `D src/removed.ts
+D src/deleted.ts`
+
+    const result = parseJJStatus(output)
+
+    expect(result.deleted).toContain('src/removed.ts')
+    expect(result.deleted).toContain('src/deleted.ts')
+  })
+
+  test('parses mixed status', () => {
+    const output = `M src/modified.ts
+A src/added.ts
+D src/deleted.ts`
+
+    const result = parseJJStatus(output)
+
+    expect(result.modified).toContain('src/modified.ts')
+    expect(result.added).toContain('src/added.ts')
+    expect(result.deleted).toContain('src/deleted.ts')
+  })
+
+  test('handles empty output', () => {
+    const result = parseJJStatus('')
+
+    expect(result.modified).toHaveLength(0)
+    expect(result.added).toHaveLength(0)
+    expect(result.deleted).toHaveLength(0)
+  })
+})
+
+describe('parseDiffStats', () => {
+  test('parses file change lines', () => {
+    const output = ` src/file1.ts | 10 ++++++----
+ src/file2.ts | 5 +++++
+ src/file3.ts | 3 ---`
+
+    const result = parseDiffStats(output)
+
+    expect(result.files).toHaveLength(3)
+    expect(result.files).toContain('src/file1.ts')
+    expect(result.files).toContain('src/file2.ts')
+    expect(result.files).toContain('src/file3.ts')
+  })
+
+  test('counts insertions correctly', () => {
+    const output = ` src/file1.ts | 10 ++++++----`
+
+    const result = parseDiffStats(output)
+
+    // 6 + symbols
+    expect(result.insertions).toBe(6)
+  })
+
+  test('counts deletions correctly', () => {
+    const output = ` src/file1.ts | 10 ++++++----`
+
+    const result = parseDiffStats(output)
+
+    // 4 - symbols
+    expect(result.deletions).toBe(4)
+  })
+
+  test('sums insertions and deletions across files', () => {
+    const output = ` src/file1.ts | 10 ++++++----
+ src/file2.ts | 5 +++++
+ src/file3.ts | 3 ---`
+
+    const result = parseDiffStats(output)
+
+    // file1: 6+, 4-; file2: 5+, 0-; file3: 0+, 3-
+    expect(result.insertions).toBe(11)
+    expect(result.deletions).toBe(7)
+  })
+
+  test('handles empty output', () => {
+    const result = parseDiffStats('')
+
+    expect(result.files).toHaveLength(0)
+    expect(result.insertions).toBe(0)
+    expect(result.deletions).toBe(0)
+  })
+
+  test('ignores summary lines', () => {
+    const output = ` src/file.ts | 10 +++++++---
+ 2 files changed, 10 insertions(+), 5 deletions(-)`
+
+    const result = parseDiffStats(output)
+
+    // Only the first line should match
+    expect(result.files).toHaveLength(1)
+  })
+})
+
+describe('isGitRepo', () => {
+  test('returns true in current directory (which is a git repo)', async () => {
+    const result = await isGitRepo()
+    expect(result).toBe(true)
+  })
+})
+
+describe('getCurrentBranch', () => {
+  test('returns branch name in a git repo', async () => {
+    const branch = await getCurrentBranch()
+    // We're in a git repo, so should return something
+    expect(typeof branch).toBe('string')
+  })
+})