smithers-orchestrator 0.1.16 → 0.1.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smithers-orchestrator",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "Build AI agents with Solid.js - Declarative JSX for Claude orchestration",
   "type": "module",
   "main": "./src/index.ts",
@@ -51,7 +51,6 @@
     "@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",

package/preload.ts

@@ -1,10 +1,69 @@
-import { SolidPlugin } from "@dschz/bun-plugin-solid";
-
-await Bun.plugin(
-  SolidPlugin({
-    generate: "universal",
-    moduleName: "smithers-orchestrator/solid",
-    hydratable: false,
-    debug: false,
-  }),
-);
+/**
+ * Preload script for Smithers orchestration files.
+ *
+ * This sets up the Solid JSX transform using babel directly,
+ * pointing to smithers-orchestrator/solid as the render module.
+ */
+import tsPreset from "@babel/preset-typescript";
+import solidPreset from "babel-preset-solid";
+
+const logPrefix = "\x1b[36m[smithers-solid-jsx]\x1b[0m";
+
+await Bun.plugin({
+  name: "smithers-solid-jsx",
+  setup: (build) => {
+    let babel: typeof import("@babel/core") | null = null;
+    let babelTransformPresets: any[] | null = null;
+
+    // Only match tsx/jsx files outside of node_modules
+    // Use negative lookahead to exclude node_modules paths
+    build.onLoad({ filter: /^(?!.*node_modules).*\.[tj]sx$/ }, async ({ path }) => {
+
+      if (!babel) {
+        babel = await import("@babel/core");
+      }
+
+      if (!babelTransformPresets) {
+        babelTransformPresets = [
+          [tsPreset, {}],
+          [solidPreset, {
+            // Use universal mode (non-DOM) for the custom renderer
+            generate: "universal",
+            // Point to smithers-orchestrator's solid module for JSX runtime
+            moduleName: "smithers-orchestrator/solid",
+            // No hydration needed for non-DOM rendering
+            hydratable: false,
+          }],
+        ];
+      }
+
+      console.log(`${logPrefix} Transforming: ${path}`);
+      const start = performance.now();
+
+      try {
+        const result = await babel.transformFileAsync(path, {
+          presets: babelTransformPresets,
+          filename: path,
+          sourceMaps: "inline",
+        });
+
+        const end = performance.now();
+        console.log(`${logPrefix} Transformed: ${path} in ${Math.round(end - start)}ms`);
+
+        if (!result || !result.code) {
+          console.warn(`${logPrefix} No code for: ${path}`);
+          // Return undefined to let bun handle the file normally
+          return undefined;
+        }
+
+        return {
+          loader: "js",
+          contents: result.code,
+        };
+      } catch (error) {
+        console.error(`${logPrefix} Error transforming ${path}:`, error);
+        throw error;
+      }
+    });
+  },
+});

package/src/orchestrator/commands/monitor.ts

@@ -1,11 +1,30 @@
 import { spawn } from 'child_process'
 import * as fs from 'fs'
 import * as path from 'path'
+import { fileURLToPath } from 'url'
 import { OutputParser } from '../monitor/output-parser.jsx'
 import { StreamFormatter } from '../monitor/stream-formatter.jsx'
 import { LogWriter } from '../monitor/log-writer.jsx'
 import { summarizeWithHaiku } from '../monitor/haiku-summarizer.jsx'
 
+/**
+ * Find the preload.ts file from the smithers-orchestrator package
+ */
+function findPreloadPath(): string {
+  const __filename = fileURLToPath(import.meta.url)
+  const __dirname = path.dirname(__filename)
+  // Navigate up from src/orchestrator/commands to package root
+  let dir = __dirname
+  while (dir !== path.dirname(dir)) {
+    const preloadPath = path.join(dir, 'preload.ts')
+    if (fs.existsSync(preloadPath)) {
+      return preloadPath
+    }
+    dir = path.dirname(dir)
+  }
+  throw new Error('Could not find preload.ts - smithers-orchestrator may be incorrectly installed')
+}
+
 interface MonitorOptions {
   file?: string
   summary?: boolean
@@ -42,7 +61,8 @@ export async function monitor(fileArg?: string, options: MonitorOptions = {}) {
 
   // Start execution
   const startTime = Date.now()
-  const child = spawn('bun', ['--install=fallback', filePath], {
+  const preloadPath = findPreloadPath()
+  const child = spawn('bun', ['--preload', preloadPath, '--install=fallback', filePath], {
     stdio: ['inherit', 'pipe', 'pipe'],
     shell: true,
   })

package/src/orchestrator/commands/run.ts

@@ -1,6 +1,25 @@
 import { spawn } from 'child_process'
 import * as fs from 'fs'
 import * as path from 'path'
+import { fileURLToPath } from 'url'
+
+/**
+ * Find the preload.ts file from the smithers-orchestrator package
+ */
+function findPreloadPath(): string {
+  const __filename = fileURLToPath(import.meta.url)
+  const __dirname = path.dirname(__filename)
+  // Navigate up from src/orchestrator/commands to package root
+  let dir = __dirname
+  while (dir !== path.dirname(dir)) {
+    const preloadPath = path.join(dir, 'preload.ts')
+    if (fs.existsSync(preloadPath)) {
+      return preloadPath
+    }
+    dir = path.dirname(dir)
+  }
+  throw new Error('Could not find preload.ts - smithers-orchestrator may be incorrectly installed')
+}
 
 interface RunOptions {
   file?: string
@@ -35,7 +54,8 @@ export async function run(fileArg?: string, options: RunOptions = {}) {
   console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
   console.log('')
 
-  const child = spawn('bun', ['--install=fallback', filePath], {
+  const preloadPath = findPreloadPath()
+  const child = spawn('bun', ['--preload', preloadPath, '--install=fallback', filePath], {
     stdio: 'inherit',
     shell: true,
   })

package/src/orchestrator/components/SmithersProvider.tsx

@@ -172,9 +172,14 @@ export function SmithersProvider(props: SmithersProviderProps): JSX.Element {
     isRebaseRequested: rebaseRequested,
   }
 
+  // Use a function to render children lazily after context is established
+  // This is important for Solid.js universal renderer where children may
+  // be evaluated eagerly before the context provider is set up
+  const renderChildren = () => props.children
+
   return (
     <SmithersContext.Provider value={value}>
-      {props.children}
+      {renderChildren()}
     </SmithersContext.Provider>
   )
 }

package/src/orchestrator/tools/ReportTool.test.ts

@@ -0,0 +1,227 @@
+/**
+ * Unit tests for ReportTool.ts
+ */
+import { describe, test, expect, mock } from 'bun:test'
+import { createReportTool, getReportToolDescription } from './ReportTool'
+
+describe('getReportToolDescription', () => {
+  test('returns a non-empty string', () => {
+    const description = getReportToolDescription()
+    expect(typeof description).toBe('string')
+    expect(description.length).toBeGreaterThan(0)
+  })
+
+  test('contains Report Tool header', () => {
+    const description = getReportToolDescription()
+    expect(description).toContain('## Report Tool')
+  })
+
+  test('describes report types', () => {
+    const description = getReportToolDescription()
+    expect(description).toContain('progress')
+    expect(description).toContain('findings')
+    expect(description).toContain('warnings')
+    expect(description).toContain('errors')
+    expect(description).toContain('metrics')
+    expect(description).toContain('decisions')
+  })
+
+  test('includes example usage', () => {
+    const description = getReportToolDescription()
+    expect(description).toContain('Example usage')
+    expect(description).toContain('"type": "finding"')
+    expect(description).toContain('"title"')
+    expect(description).toContain('"content"')
+  })
+
+  test('mentions severity levels', () => {
+    const description = getReportToolDescription()
+    expect(description).toContain('severity')
+    expect(description).toContain('critical')
+  })
+})
+
+describe('createReportTool', () => {
+  // Create a mock context
+  const mockAddReport = mock(async () => 'report-123')
+  const mockContext = {
+    db: {
+      vcs: {
+        addReport: mockAddReport,
+      },
+    },
+    agentId: 'test-agent',
+  }
+
+  test('returns a tool with correct name', () => {
+    const tool = createReportTool(mockContext as any)
+    expect(tool.name).toBe('Report')
+  })
+
+  test('has description', () => {
+    const tool = createReportTool(mockContext as any)
+    expect(tool.description).toBeDefined()
+    expect(tool.description.length).toBeGreaterThan(0)
+  })
+
+  test('has input schema', () => {
+    const tool = createReportTool(mockContext as any)
+    expect(tool.inputSchema).toBeDefined()
+    expect(tool.inputSchema.type).toBe('object')
+    expect(tool.inputSchema.properties).toBeDefined()
+  })
+
+  test('input schema has required fields', () => {
+    const tool = createReportTool(mockContext as any)
+    expect(tool.inputSchema.required).toContain('type')
+    expect(tool.inputSchema.required).toContain('title')
+    expect(tool.inputSchema.required).toContain('content')
+  })
+
+  test('input schema has type enum', () => {
+    const tool = createReportTool(mockContext as any)
+    const typeProperty = tool.inputSchema.properties?.type as any
+    expect(typeProperty.enum).toContain('progress')
+    expect(typeProperty.enum).toContain('finding')
+    expect(typeProperty.enum).toContain('warning')
+    expect(typeProperty.enum).toContain('error')
+    expect(typeProperty.enum).toContain('metric')
+    expect(typeProperty.enum).toContain('decision')
+  })
+
+  test('input schema has severity enum', () => {
+    const tool = createReportTool(mockContext as any)
+    const severityProperty = tool.inputSchema.properties?.severity as any
+    expect(severityProperty.enum).toContain('info')
+    expect(severityProperty.enum).toContain('warning')
+    expect(severityProperty.enum).toContain('critical')
+  })
+
+  test('has execute function', () => {
+    const tool = createReportTool(mockContext as any)
+    expect(typeof tool.execute).toBe('function')
+  })
+
+  test('execute calls addReport with correct data', async () => {
+    const addReport = mock(async () => 'report-456')
+    const context = {
+      db: { vcs: { addReport } },
+      agentId: 'agent-123',
+    }
+
+    const tool = createReportTool(context as any)
+    await tool.execute({
+      type: 'progress',
+      title: 'Test Progress',
+      content: 'Progress update content',
+    })
+
+    expect(addReport).toHaveBeenCalledWith({
+      type: 'progress',
+      title: 'Test Progress',
+      content: 'Progress update content',
+      data: undefined,
+      severity: 'info',
+      agent_id: 'agent-123',
+    })
+  })
+
+  test('execute returns success with reportId', async () => {
+    const addReport = mock(async () => 'report-789')
+    const context = {
+      db: { vcs: { addReport } },
+      agentId: 'agent-123',
+    }
+
+    const tool = createReportTool(context as any)
+    const result = await tool.execute({
+      type: 'finding',
+      title: 'Test Finding',
+      content: 'Finding content',
+    })
+
+    expect(result.success).toBe(true)
+    expect(result.reportId).toBe('report-789')
+    expect(result.message).toContain('Test Finding')
+  })
+
+  test('defaults severity to critical for error type', async () => {
+    const addReport = mock(async () => 'report-err')
+    const context = {
+      db: { vcs: { addReport } },
+      agentId: 'agent-123',
+    }
+
+    const tool = createReportTool(context as any)
+    await tool.execute({
+      type: 'error',
+      title: 'Test Error',
+      content: 'Error content',
+    })
+
+    expect(addReport).toHaveBeenCalledWith(
+      expect.objectContaining({ severity: 'critical' })
+    )
+  })
+
+  test('defaults severity to warning for warning type', async () => {
+    const addReport = mock(async () => 'report-warn')
+    const context = {
+      db: { vcs: { addReport } },
+      agentId: 'agent-123',
+    }
+
+    const tool = createReportTool(context as any)
+    await tool.execute({
+      type: 'warning',
+      title: 'Test Warning',
+      content: 'Warning content',
+    })
+
+    expect(addReport).toHaveBeenCalledWith(
+      expect.objectContaining({ severity: 'warning' })
+    )
+  })
+
+  test('uses provided severity over default', async () => {
+    const addReport = mock(async () => 'report-custom')
+    const context = {
+      db: { vcs: { addReport } },
+      agentId: 'agent-123',
+    }
+
+    const tool = createReportTool(context as any)
+    await tool.execute({
+      type: 'error',
+      title: 'Test Error',
+      content: 'Error content',
+      severity: 'info', // Override critical default
+    })
+
+    expect(addReport).toHaveBeenCalledWith(
+      expect.objectContaining({ severity: 'info' })
+    )
+  })
+
+  test('includes data in report', async () => {
+    const addReport = mock(async () => 'report-data')
+    const context = {
+      db: { vcs: { addReport } },
+      agentId: 'agent-123',
+    }
+
+    const tool = createReportTool(context as any)
+    await tool.execute({
+      type: 'metric',
+      title: 'Test Metric',
+      content: 'Metric content',
+      data: { value: 42, unit: 'ms' },
+    })
+
+    expect(addReport).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: { value: 42, unit: 'ms' },
+      })
+    )
+  })
+})