@stacksjs/defaults 0.70.58 → 0.70.59

package/app/Actions/Buddy/BuddyProcessStreamAction.ts

@@ -0,0 +1,128 @@
+import { Action } from '@stacksjs/actions'
+import { apiKeys, applyChanges, buddyProcessStreaming, buddyState, buddyStreamSimple, openRepository } from '@stacksjs/ai'
+
+/**
+ * Process a command with streaming output (Server-Sent Events)
+ *
+ * This endpoint streams Claude CLI output in real-time as it's generated.
+ * Use EventSource or fetch with streaming to consume this endpoint.
+ *
+ * Request body:
+ * - command: The user's command/instruction (required)
+ * - repo/repository: Repository path or GitHub URL (required if no repo is currently open)
+ * - driver: (optional) AI driver to use (only claude-cli-local supports streaming)
+ * - mode: (optional) 'simple' for Q&A with true token-by-token streaming, 'agentic' for tool use (default)
+ */
+export default new Action({
+  name: 'BuddyProcessStreamAction',
+  description: 'Process a command with streaming AI output',
+  method: 'POST',
+
+  async handle(request: RequestInstance) {
+    try {
+      const command = request.get('command')
+      const repo = request.get('repo') || request.get('repository')
+      const driver = request.get('driver')
+      const history = request.get('history') as Array<{role: string; content: string}> | undefined
+      const mode = request.get('mode') as string | undefined // 'simple' or 'agentic'
+
+      if (!command) {
+        return new Response(JSON.stringify({ error: 'Command is required' }), {
+          status: 422,
+          headers: { 'Content-Type': 'application/json' },
+        })
+      }
+
+      // Determine actual mode - simple mode requires API key, otherwise falls back to agentic
+      const useSimpleMode = mode === 'simple' && apiKeys.anthropic
+
+      // Check if we need to open a repo (required for agentic mode)
+      const currentState = buddyState.getState()
+      if (!useSimpleMode) {
+        if (!currentState.repo) {
+          if (!repo) {
+            return new Response(JSON.stringify({
+              error: 'No repository is currently open. Please provide a repo path or URL.',
+            }), {
+              status: 422,
+              headers: { 'Content-Type': 'application/json' },
+            })
+          }
+          await openRepository(repo)
+        }
+        else if (repo && repo !== currentState.repo.path) {
+          await openRepository(repo)
+        }
+      }
+      const { stream, fullResponse } = useSimpleMode
+        ? await buddyStreamSimple(command, history)
+        : await buddyProcessStreaming(command, driver || undefined, history)
+
+      // Create SSE response
+      const encoder = new TextEncoder()
+      const decoder = new TextDecoder()
+
+      const isSimpleMode = useSimpleMode
+      const sseStream = new ReadableStream({
+        async start(controller) {
+          // Send initial event
+          controller.enqueue(encoder.encode(`event: start\ndata: ${JSON.stringify({ status: 'processing', mode: isSimpleMode ? 'simple' : 'agentic' })}\n\n`))
+
+          const reader = stream.getReader()
+
+          try {
+            let result = await reader.read()
+            while (!result.done) {
+              // Convert chunk to text and send as SSE data event
+              const text = decoder.decode(result.value, { stream: true })
+              controller.enqueue(encoder.encode(`event: chunk\ndata: ${JSON.stringify({ text })}\n\n`))
+              result = await reader.read()
+            }
+
+            // Wait for full response
+            const response = await fullResponse
+
+            // Only apply changes for agentic mode (simple mode has no file changes)
+            let modifiedFiles: string[] = []
+            if (!isSimpleMode) {
+              modifiedFiles = await applyChanges(response)
+            }
+
+            // Send completion event with metadata
+            controller.enqueue(encoder.encode(`event: done\ndata: ${JSON.stringify({
+              status: 'complete',
+              hasChanges: modifiedFiles.length > 0,
+              modifiedFiles,
+              repo: buddyState.getState().repo,
+            })}\n\n`))
+
+            controller.close()
+          }
+          catch (error) {
+            controller.enqueue(encoder.encode(`event: error\ndata: ${JSON.stringify({
+              error: (error as Error).message,
+            })}\n\n`))
+            controller.close()
+          }
+        },
+      })
+
+      return new Response(sseStream, {
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Headers': 'Content-Type',
+        },
+      })
+    }
+    catch (error) {
+      console.error('[BuddyProcessStreamAction] Error:', error)
+      return new Response(JSON.stringify({ error: (error as Error).message }), {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+  },
+})

package/app/Actions/Buddy/BuddyPushAction.ts

@@ -0,0 +1,21 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { pushChanges } from '@stacksjs/ai'
+
+/**
+ * Push committed changes to the remote repository
+ */
+export default new Action({
+  name: 'BuddyPushAction',
+  description: 'Push committed changes to the remote repository',
+  method: 'POST',
+  async handle(_request: RequestInstance) {
+    try {
+      await pushChanges()
+      return response.json({ success: true })
+    }
+    catch (error) {
+      return response.json({ success: false, error: (error as Error).message }, { status: 400 })
+    }
+  },
+})

package/app/Actions/Buddy/BuddyRepoOpenAction.ts

@@ -0,0 +1,44 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { openRepository } from '@stacksjs/ai'
+
+/**
+ * Open or clone a repository
+ *
+ * Request body/query:
+ * - path, input, repo, or repository: GitHub URL or local path
+ */
+export default new Action({
+  name: 'BuddyRepoOpenAction',
+  description: 'Open or clone a repository for Buddy to work on',
+  method: 'POST',
+
+  async handle(request: RequestInstance) {
+    try {
+      // Debug: log what we're receiving
+      const allInput = request.all ? request.all() : {}
+      console.log('[BuddyRepoOpenAction] All input:', JSON.stringify(allInput))
+      console.log('[BuddyRepoOpenAction] jsonBody:', JSON.stringify((request as any).jsonBody))
+
+      // Accept multiple field names for flexibility
+      const input = request.get<string>('path')
+        || request.get<string>('input')
+        || request.get<string>('repo')
+        || request.get<string>('repository')
+
+      console.log('[BuddyRepoOpenAction] Resolved input:', input)
+
+      if (!input) {
+        return response.unprocessableEntity('Repository input is required', {
+          path: ['Provide path, input, repo, or repository field'],
+        })
+      }
+
+      const repo = await openRepository(input)
+      return response.success({ repo })
+    }
+    catch (error) {
+      return response.badRequest((error as Error).message)
+    }
+  },
+})

package/app/Actions/Buddy/BuddyRepoValidateAction.ts

@@ -0,0 +1,35 @@
+import { existsSync, statSync } from 'node:fs'
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+/**
+ * Validate that a repository path exists and is a directory
+ */
+export default new Action({
+  name: 'BuddyRepoValidateAction',
+  description: 'Validate a repository path',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const path = request.get('path')
+
+    if (!path) {
+      return response.json({ valid: false, error: 'No path provided' })
+    }
+
+    try {
+      if (!existsSync(path)) {
+        return response.json({ valid: false, error: 'Path does not exist' })
+      }
+
+      const stat = statSync(path)
+      if (!stat.isDirectory()) {
+        return response.json({ valid: false, error: 'Path is not a directory' })
+      }
+
+      return response.json({ valid: true })
+    }
+    catch (error) {
+      return response.json({ valid: false, error: 'Path validation failed' })
+    }
+  },
+})

package/app/Actions/Buddy/BuddySettingsAction.ts

@@ -0,0 +1,21 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { apiKeys } from '@stacksjs/ai'
+
+/**
+ * Get the current settings status (which API keys are configured)
+ */
+export default new Action({
+  name: 'BuddySettingsAction',
+  description: 'Get the current Buddy settings status',
+  method: 'GET',
+  async handle(_request: RequestInstance) {
+    return response.json({
+      configured: {
+        anthropic: !!apiKeys.anthropic,
+        openai: !!apiKeys.openai,
+        claudeCliHost: !!apiKeys.claudeCliHost,
+      },
+    })
+  },
+})

package/app/Actions/Buddy/BuddySettingsUpdateAction.ts

@@ -0,0 +1,46 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+import { apiKeys } from '@stacksjs/ai'
+
+/**
+ * Update API keys for AI drivers
+ *
+ * Request body:
+ * - apiKeys: { anthropic?: string, openai?: string, claudeCliHost?: string }
+ */
+export default new Action({
+  name: 'BuddySettingsUpdateAction',
+  description: 'Update API keys for AI drivers',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    try {
+      const body = await request.json() as { apiKeys: { anthropic?: string, openai?: string, claudeCliHost?: string } }
+      const newKeys = body.apiKeys
+
+      if (newKeys.anthropic !== undefined) {
+        apiKeys.anthropic = newKeys.anthropic || undefined
+        console.log(`Anthropic API key ${newKeys.anthropic ? 'set' : 'cleared'}`)
+      }
+      if (newKeys.openai !== undefined) {
+        apiKeys.openai = newKeys.openai || undefined
+        console.log(`OpenAI API key ${newKeys.openai ? 'set' : 'cleared'}`)
+      }
+      if (newKeys.claudeCliHost !== undefined) {
+        apiKeys.claudeCliHost = newKeys.claudeCliHost || undefined
+        console.log(`Claude CLI Host ${newKeys.claudeCliHost ? `set to ${newKeys.claudeCliHost}` : 'cleared'}`)
+      }
+
+      return response.json({
+        success: true,
+        configured: {
+          anthropic: !!apiKeys.anthropic,
+          openai: !!apiKeys.openai,
+          claudeCliHost: !!apiKeys.claudeCliHost,
+        },
+      })
+    }
+    catch (error) {
+      return response.json({ success: false, error: (error as Error).message }, { status: 400 })
+    }
+  },
+})

package/app/Actions/Buddy/BuddyStateAction.ts

@@ -0,0 +1,28 @@
+import { Action } from '@stacksjs/actions'
+import { buddyState, getAvailableDrivers } from '@stacksjs/ai'
+import { response } from '@stacksjs/router'
+
+/**
+ * Get the current Buddy state including repo info, driver, and GitHub connection
+ */
+export default new Action({
+  name: 'BuddyStateAction',
+  description: 'Get the current Buddy state',
+  method: 'GET',
+  async handle(_request: RequestInstance) {
+    const state = buddyState.getState()
+    return response.json({
+      repo: state.repo,
+      currentDriver: state.currentDriver,
+      availableDrivers: getAvailableDrivers(),
+      github: state.github
+        ? {
+            username: state.github.username,
+            name: state.github.name,
+            connected: true,
+          }
+        : { connected: false },
+      conversationLength: state.conversationHistory.length,
+    })
+  },
+})

package/app/Actions/Buddy/BuddyTitleAction.ts

@@ -0,0 +1,49 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+/**
+ * Generate a short title for a chat based on the initial prompt
+ *
+ * Uses Claude to summarize the user's first message into a concise title.
+ */
+export default new Action({
+  name: 'BuddyTitleAction',
+  description: 'Generate a chat title from initial prompt',
+  method: 'POST',
+
+  async handle(request: RequestInstance) {
+    try {
+      const prompt = request.get('prompt') as string
+
+      if (!prompt) {
+        return response.json({ error: 'Prompt is required' }, 422)
+      }
+
+      const { $: _$ } = await import('bun')
+
+      // Use Claude to generate a short title (max 5 words)
+      const titlePrompt = `Summarize this user request into a very short title (2-5 words max, no quotes, no punctuation at end). Just output the title, nothing else.
+
+User request: "${prompt.substring(0, 500)}"`
+
+      try {
+        const result = await _$`claude --print --dangerously-skip-permissions ${titlePrompt}`.quiet()
+        const title = result.text().trim()
+          .replace(/^["']|["']$/g, '') // Remove surrounding quotes
+          .replace(/[.!?]$/, '') // Remove trailing punctuation
+          .substring(0, 50) // Max 50 chars
+
+        return response.json({ title })
+      }
+      catch (error) {
+        // Fallback: just truncate the prompt
+        const fallbackTitle = prompt.substring(0, 30).trim() + (prompt.length > 30 ? '...' : '')
+        return response.json({ title: fallbackTitle })
+      }
+    }
+    catch (error) {
+      console.error('[BuddyTitleAction] Error:', error)
+      return response.json({ error: (error as Error).message }, 500)
+    }
+  },
+})