smithers-orchestrator 0.1.9 → 0.1.12

package/bin/cli.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env bun
 
 import { Command } from 'commander'
-import { init } from '../src/orchestrator/commands/init.js'
-import { run } from '../src/orchestrator/commands/run.js'
-import { monitor } from '../src/orchestrator/commands/monitor.js'
-import { dbCommand } from '../src/orchestrator/commands/db.js'
+import { init } from '../src/orchestrator/commands/init.ts'
+import { run } from '../src/orchestrator/commands/run.ts'
+import { monitor } from '../src/orchestrator/commands/monitor.ts'
+import { dbCommand } from '../src/orchestrator/commands/db.ts'
 
 const program = new Command()
 
@@ -46,7 +46,7 @@ program
   .action(async (type: string, data: string, options: { path: string }) => {
     try {
       // Dynamically import to avoid loading DB on every CLI call
-      const { createSmithersDB } = await import('../src/orchestrator/db/index.js')
+      const { createSmithersDB } = await import('../src/orchestrator/db/index.ts')
 
       const db = await createSmithersDB({ path: options.path })
 

package/bunfig.toml

@@ -0,0 +1,12 @@
+# 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"
+
+[install]
+auto = "fallback"
+
+[test]
+preload = ["./test/preload.ts"]

package/package.json

@@ -1,117 +1,47 @@
 {
   "name": "smithers-orchestrator",
-  "version": "0.1.9",
+  "version": "0.1.12",
   "description": "Build AI agents with Solid.js - Declarative JSX for Claude orchestration",
   "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./src/index.ts",
   "bin": {
-    "smithers": "./bin/cli.js"
+    "smithers": "./bin/cli.ts"
   },
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./core": {
-      "types": "./dist/core/index.d.ts",
-      "import": "./dist/core/index.js"
-    },
-    "./solid": {
-      "types": "./dist/solid/index.d.ts",
-      "import": "./dist/solid/index.js"
-    },
-    "./components": {
-      "types": "./dist/components/index.d.ts",
-      "import": "./dist/components/index.js"
-    },
-    "./components/Ralph": {
-      "types": "./dist/components/Ralph.d.ts",
-      "import": "./dist/components/Ralph.jsx"
-    },
-    "./components/Review": {
-      "types": "./dist/components/Review.d.ts",
-      "import": "./dist/components/Review.jsx"
-    },
-    "./components/Phase": {
-      "types": "./dist/components/Phase.d.ts",
-      "import": "./dist/components/Phase.jsx"
-    },
-    "./components/Step": {
-      "types": "./dist/components/Step.d.ts",
-      "import": "./dist/components/Step.jsx"
-    },
-    "./components/JJ": {
-      "types": "./dist/components/JJ/index.d.ts",
-      "import": "./dist/components/JJ/index.js"
-    },
-    "./components/Git": {
-      "types": "./dist/components/Git/index.d.ts",
-      "import": "./dist/components/Git/index.js"
-    },
-    "./components/Hooks": {
-      "types": "./dist/components/Hooks/index.d.ts",
-      "import": "./dist/components/Hooks/index.js"
-    },
-    "./components/MCP": {
-      "types": "./dist/components/MCP/index.d.ts",
-      "import": "./dist/components/MCP/index.js"
-    },
-    "./orchestrator": {
-      "types": "./dist/orchestrator/components/index.d.ts",
-      "import": "./dist/orchestrator/components/index.js"
-    },
-    "./orchestrator/SmithersProvider": {
-      "types": "./dist/orchestrator/components/SmithersProvider.d.ts",
-      "import": "./dist/orchestrator/components/SmithersProvider.jsx"
-    },
-    "./orchestrator/Orchestration": {
-      "types": "./dist/orchestrator/components/Orchestration.d.ts",
-      "import": "./dist/orchestrator/components/Orchestration.jsx"
-    },
-    "./orchestrator/Claude": {
-      "types": "./dist/orchestrator/components/Claude.d.ts",
-      "import": "./dist/orchestrator/components/Claude.jsx"
-    },
-    "./orchestrator/Phase": {
-      "types": "./dist/orchestrator/components/Phase.d.ts",
-      "import": "./dist/orchestrator/components/Phase.jsx"
-    },
-    "./orchestrator/Step": {
-      "types": "./dist/orchestrator/components/Step.d.ts",
-      "import": "./dist/orchestrator/components/Step.jsx"
-    },
-    "./db": {
-      "types": "./dist/orchestrator/db/index.d.ts",
-      "import": "./dist/orchestrator/db/index.js"
-    },
-    "./debug": {
-      "types": "./dist/debug/index.d.ts",
-      "import": "./dist/debug/index.js"
-    },
-    "./renderer": {
-      "import": "./src/solid/renderer.js"
-    }
+    ".": "./src/index.ts",
+    "./core": "./src/core/index.ts",
+    "./solid": "./src/solid/index.ts",
+    "./components": "./src/components/index.ts",
+    "./components/Ralph": "./src/components/Ralph.tsx",
+    "./components/Review": "./src/components/Review.tsx",
+    "./components/Phase": "./src/components/Phase.tsx",
+    "./components/Step": "./src/components/Step.tsx",
+    "./components/JJ": "./src/components/JJ/index.ts",
+    "./components/Git": "./src/components/Git/index.ts",
+    "./components/Hooks": "./src/components/Hooks/index.ts",
+    "./components/MCP": "./src/components/MCP/index.ts",
+    "./orchestrator": "./src/orchestrator/components/index.ts",
+    "./orchestrator/SmithersProvider": "./src/orchestrator/components/SmithersProvider.tsx",
+    "./orchestrator/Orchestration": "./src/orchestrator/components/Orchestration.tsx",
+    "./orchestrator/Claude": "./src/orchestrator/components/Claude.tsx",
+    "./orchestrator/Phase": "./src/orchestrator/components/Phase.tsx",
+    "./orchestrator/Step": "./src/orchestrator/components/Step.tsx",
+    "./db": "./src/orchestrator/db/index.ts"
   },
   "files": [
-    "dist",
+    "src",
     "bin",
     "skills",
     "templates",
+    "bunfig.toml",
     "plugin.json",
-    "postinstall.cjs",
     "README.md"
   ],
   "scripts": {
-    "build": "tsc && cp src/orchestrator/db/schema.sql dist/orchestrator/db/ && bun build bin/cli.ts --outdir bin --target node",
-    "build:cli": "bun build bin/cli.ts --outdir bin --target node",
-    "dev": "tsc --watch",
+    "build": "echo 'No build needed - Bun runs TypeScript directly'",
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "postinstall": "node postinstall.cjs"
+    "test": "bun test",
+    "test:watch": "bun test --watch"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.1.76",
@@ -119,20 +49,14 @@
     "@electric-sql/pglite": "^0.3.15",
     "commander": "^12.0.0",
     "solid-js": "^1.9.10",
-    "zod": "^4.3.5",
-    "zustand": "^5.0.10"
+    "zod": "^4.3.5"
   },
   "peerDependencies": {
-    "solid-js": "^1.9.10",
     "bun": ">=1.0.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@types/node": "^25.0.9",
-    "happy-dom": "^20.3.1",
-    "typescript": "^5.7.2",
-    "vite-plugin-solid": "^2.11.10",
-    "vitest": "^4.0.17"
+    "typescript": "^5.7.2"
   },
   "keywords": [
     "ai",
@@ -144,16 +68,12 @@
     "claude",
     "anthropic",
     "orchestration",
-    "multi-agent",
-    "workflow"
+    "bun"
   ],
   "author": "William Cory",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/evmts/smithers.git"
-  },
-  "engines": {
-    "node": ">=18.0.0"
   }
 }

package/src/components/Claude.tsx

@@ -0,0 +1,116 @@
+import { createSignal, onMount, useContext, type JSX } from 'solid-js'
+import { RalphContext } from './Ralph'
+
+/**
+ * Execute a prompt using Claude Agent SDK.
+ * This is a placeholder - will integrate with @anthropic-ai/claude-agent-sdk.
+ */
+async function executeWithClaudeSDK(config: {
+  prompt: string
+  model: string
+  maxTurns?: number
+  tools?: string[]
+  systemPrompt?: string
+}): Promise<unknown> {
+  // TODO: Integrate with @anthropic-ai/claude-agent-sdk
+
+  // For now, return mock response for testing
+  if (process.env.NODE_ENV === 'test' || process.env.MOCK_MODE === 'true') {
+    // Simulate some async delay
+    await new Promise(resolve => setTimeout(resolve, 10))
+
+    return {
+      output: `Mock response for: ${config.prompt}`,
+      model: config.model,
+      turns: 1,
+    }
+  }
+
+  throw new Error('Claude SDK integration not yet implemented')
+}
+
+export interface ClaudeProps {
+  children?: JSX.Element
+  model?: string
+  maxTurns?: number
+  tools?: string[]
+  systemPrompt?: string
+  onFinished?: (result: unknown) => void
+  onError?: (error: Error) => void
+  validate?: (result: unknown) => Promise<boolean>
+  [key: string]: unknown
+}
+
+/**
+ * Claude component that executes on mount.
+ *
+ * CRITICAL PATTERN: This component is BOTH declaration AND execution.
+ * When it mounts, it executes itself. No external orchestrator needed.
+ *
+ * GOTCHA: Use fire-and-forget async IIFE inside onMount:
+ *   onMount(() => {
+ *     (async () => { ... })()  // ← Fire and forget
+ *   })
+ *
+ * NOT: onMount(async () => { ... })  // ← Doesn't work!
+ */
+export function Claude(props: ClaudeProps): JSX.Element {
+  const ralph = useContext(RalphContext)
+  const [status, setStatus] = createSignal<'pending' | 'running' | 'complete' | 'error'>('pending')
+  const [result, setResult] = createSignal<unknown>(null)
+  const [error, setError] = createSignal<Error | null>(null)
+
+  onMount(() => {
+    // Fire-and-forget async IIFE
+    // This is the CRITICAL pattern for async execution in Solid onMount
+    (async () => {
+      // Register with Ralph (if present)
+      ralph?.registerTask()
+
+      try {
+        setStatus('running')
+
+        const response = await executeWithClaudeSDK({
+          prompt: String(props.children),
+          model: props.model || 'claude-sonnet-4',
+          maxTurns: props.maxTurns,
+          tools: props.tools,
+          systemPrompt: props.systemPrompt,
+        })
+
+        // Optional validation
+        if (props.validate) {
+          const isValid = await props.validate(response)
+          if (!isValid) {
+            throw new Error('Validation failed')
+          }
+        }
+
+        setResult(response)
+        setStatus('complete')
+        props.onFinished?.(response)
+
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err))
+        setError(errorObj)
+        setStatus('error')
+        props.onError?.(errorObj)
+      } finally {
+        // Always complete task with Ralph
+        ralph?.completeTask()
+      }
+    })()
+    // Note: No await, no return - just fire and forget
+  })
+
+  return (
+    <claude
+      status={status()}
+      result={result()}
+      error={error()?.message}
+      model={props.model}
+    >
+      {props.children}
+    </claude>
+  )
+}

package/src/components/ClaudeApi.tsx

@@ -0,0 +1,33 @@
+import type { JSX } from 'solid-js'
+
+export interface ClaudeApiProps {
+  children?: JSX.Element
+  model?: string
+  maxTurns?: number
+  tools?: string[]
+  systemPrompt?: string
+  onFinished?: (result: unknown) => void
+  onError?: (error: Error) => void
+  [key: string]: unknown
+}
+
+/**
+ * ClaudeApi component - alternative executor using the Anthropic API directly.
+ *
+ * Unlike the standard Claude component which uses Claude Code CLI,
+ * ClaudeApi uses the Anthropic SDK directly for API calls.
+ *
+ * @example
+ * ```tsx
+ * <ClaudeApi model="claude-sonnet-4">
+ *   Generate a haiku about programming
+ * </ClaudeApi>
+ * ```
+ */
+export function ClaudeApi(props: ClaudeApiProps): JSX.Element {
+  return (
+    <claude-api model={props.model}>
+      {props.children}
+    </claude-api>
+  )
+}

package/src/components/Constraints.tsx

@@ -0,0 +1,31 @@
+import type { JSX } from 'solid-js'
+
+export interface ConstraintsProps {
+  children?: JSX.Element
+  [key: string]: unknown
+}
+
+/**
+ * Constraints component - defines constraints for Claude's responses.
+ *
+ * Constraints are added to the prompt to guide Claude's behavior.
+ *
+ * @example
+ * ```tsx
+ * <Claude>
+ *   <Constraints>
+ *     - Keep responses concise
+ *     - Focus on security
+ *     - Cite sources
+ *   </Constraints>
+ *   Analyze this code
+ * </Claude>
+ * ```
+ */
+export function Constraints(props: ConstraintsProps): JSX.Element {
+  return (
+    <constraints>
+      {props.children}
+    </constraints>
+  )
+}

package/src/components/Git/Commit.tsx

@@ -0,0 +1,167 @@
+import { createSignal, onMount, useContext, type JSX } from 'solid-js'
+import { RalphContext } from '../Ralph'
+import { useSmithers } from '../../orchestrator/components/SmithersProvider'
+import { addGitNotes, getCommitHash, getDiffStats } from '../../utils/vcs'
+
+export interface CommitProps {
+  /** Commit message (optional if autoGenerate is true) */
+  message?: string
+  /** Auto-generate commit message using Claude */
+  autoGenerate?: boolean
+  /** Metadata to store in git notes */
+  notes?: Record<string, any>
+  /** Specific files to stage (default: all with -A) */
+  files?: string[]
+  /** Stage all tracked files with -a flag */
+  all?: boolean
+  /** Children content (used as message if message prop not provided) */
+  children?: JSX.Element
+  /** Callback when commit is complete */
+  onFinished?: (result: CommitResult) => void
+  /** Callback on error */
+  onError?: (error: Error) => void
+}
+
+export interface CommitResult {
+  commitHash: string
+  message: string
+  filesChanged: string[]
+  insertions: number
+  deletions: number
+}
+
+/**
+ * Generate commit message using Claude CLI
+ */
+async function generateCommitMessage(): Promise<string> {
+  // Get the diff for context
+  const diffResult = await Bun.$`git diff --cached --stat`.text()
+  const diffContent = await Bun.$`git diff --cached`.text()
+
+  const prompt = `Generate a concise git commit message for these changes. Return ONLY the commit message, nothing else.
+
+Staged files:
+${diffResult}
+
+Diff:
+${diffContent.slice(0, 5000)}${diffContent.length > 5000 ? '\n...(truncated)' : ''}`
+
+  // Use claude CLI with --print to get the response
+  const result = await Bun.$`claude --print --prompt ${prompt}`.text()
+  return result.trim()
+}
+
+/**
+ * Commit component - creates a git commit with smithers metadata
+ *
+ * CRITICAL PATTERN: Uses fire-and-forget async IIFE in onMount
+ */
+export function Commit(props: CommitProps): JSX.Element {
+  const ralph = useContext(RalphContext)
+  const smithers = useSmithers()
+  const [status, setStatus] = createSignal<'pending' | 'running' | 'complete' | 'error'>('pending')
+  const [result, setResult] = createSignal<CommitResult | null>(null)
+  const [error, setError] = createSignal<Error | null>(null)
+
+  onMount(() => {
+    // Fire-and-forget async IIFE
+    (async () => {
+      ralph?.registerTask()
+
+      try {
+        setStatus('running')
+
+        // Stage files
+        if (props.files && props.files.length > 0) {
+          // Stage specific files
+          for (const file of props.files) {
+            await Bun.$`git add ${file}`.quiet()
+          }
+        } else {
+          // Stage all files with -A
+          await Bun.$`git add -A`.quiet()
+        }
+
+        // Get or generate commit message
+        let message = props.message
+
+        if (!message && props.children) {
+          // Use children content as message
+          message = String(props.children)
+        }
+
+        if (!message && props.autoGenerate) {
+          message = await generateCommitMessage()
+        }
+
+        if (!message) {
+          throw new Error('No commit message provided and autoGenerate is false')
+        }
+
+        // Create commit
+        const commitFlag = props.all ? '-a' : ''
+        if (commitFlag) {
+          await Bun.$`git commit -a -m ${message}`.quiet()
+        } else {
+          await Bun.$`git commit -m ${message}`.quiet()
+        }
+
+        // Get commit info
+        const commitHash = await getCommitHash('HEAD')
+        const diffStats = await getDiffStats('HEAD~1')
+
+        // Add git notes with smithers metadata
+        const notesData = {
+          smithers: true,
+          executionId: smithers.executionId,
+          timestamp: Date.now(),
+          ...props.notes,
+        }
+
+        await addGitNotes(JSON.stringify(notesData, null, 2), 'HEAD', false)
+
+        // Log to database
+        await smithers.db.vcs.logCommit({
+          vcs_type: 'git',
+          commit_hash: commitHash,
+          message,
+          files_changed: diffStats.files,
+          insertions: diffStats.insertions,
+          deletions: diffStats.deletions,
+          smithers_metadata: notesData,
+        })
+
+        const commitResult: CommitResult = {
+          commitHash,
+          message,
+          filesChanged: diffStats.files,
+          insertions: diffStats.insertions,
+          deletions: diffStats.deletions,
+        }
+
+        setResult(commitResult)
+        setStatus('complete')
+        props.onFinished?.(commitResult)
+
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err))
+        setError(errorObj)
+        setStatus('error')
+        props.onError?.(errorObj)
+      } finally {
+        ralph?.completeTask()
+      }
+    })()
+  })
+
+  return (
+    <git-commit
+      status={status()}
+      commit-hash={result()?.commitHash}
+      message={result()?.message}
+      error={error()?.message}
+    >
+      {props.children}
+    </git-commit>
+  )
+}

package/src/components/Git/Notes.tsx

@@ -0,0 +1,91 @@
+import { createSignal, onMount, useContext, type JSX } from 'solid-js'
+import { RalphContext } from '../Ralph'
+import { useSmithers } from '../../orchestrator/components/SmithersProvider'
+import { addGitNotes, getGitNotes } from '../../utils/vcs'
+
+export interface NotesProps {
+  /** Commit reference (default: HEAD) */
+  commitRef?: string
+  /** Data to store in notes */
+  data: Record<string, any>
+  /** Append to existing notes instead of replacing */
+  append?: boolean
+  /** Callback when notes are added */
+  onFinished?: (result: NotesResult) => void
+  /** Callback on error */
+  onError?: (error: Error) => void
+}
+
+export interface NotesResult {
+  commitRef: string
+  data: Record<string, any>
+  previousNotes: string | null
+}
+
+/**
+ * Notes component - adds/appends git notes with smithers tracking
+ *
+ * CRITICAL PATTERN: Uses fire-and-forget async IIFE in onMount
+ */
+export function Notes(props: NotesProps): JSX.Element {
+  const ralph = useContext(RalphContext)
+  const smithers = useSmithers()
+  const [status, setStatus] = createSignal<'pending' | 'running' | 'complete' | 'error'>('pending')
+  const [result, setResult] = createSignal<NotesResult | null>(null)
+  const [error, setError] = createSignal<Error | null>(null)
+
+  onMount(() => {
+    // Fire-and-forget async IIFE
+    (async () => {
+      ralph?.registerTask()
+
+      try {
+        setStatus('running')
+
+        const commitRef = props.commitRef ?? 'HEAD'
+
+        // Get existing notes if appending
+        const previousNotes = props.append ? await getGitNotes(commitRef) : null
+
+        // Prepare notes content with smithers metadata
+        const notesData = {
+          smithers: true,
+          executionId: smithers.executionId,
+          timestamp: Date.now(),
+          ...props.data,
+        }
+
+        const notesContent = JSON.stringify(notesData, null, 2)
+
+        // Add or append notes
+        await addGitNotes(notesContent, commitRef, props.append ?? false)
+
+        const notesResult: NotesResult = {
+          commitRef,
+          data: notesData,
+          previousNotes,
+        }
+
+        setResult(notesResult)
+        setStatus('complete')
+        props.onFinished?.(notesResult)
+
+      } catch (err) {
+        const errorObj = err instanceof Error ? err : new Error(String(err))
+        setError(errorObj)
+        setStatus('error')
+        props.onError?.(errorObj)
+      } finally {
+        ralph?.completeTask()
+      }
+    })()
+  })
+
+  return (
+    <git-notes
+      status={status()}
+      commit-ref={result()?.commitRef}
+      error={error()?.message}
+    />
+  )
+}

package/{dist/components/Git/index.d.ts → src/components/Git/index.ts}

@@ -1,3 +1,3 @@
-export { Commit, type CommitProps, type CommitResult } from './Commit';
-export { Notes, type NotesProps, type NotesResult } from './Notes';
-//# sourceMappingURL=index.d.ts.map
+// Git VCS components
+export { Commit, type CommitProps, type CommitResult } from './Commit'
+export { Notes, type NotesProps, type NotesResult } from './Notes'