vibe-weaver 1.0.0

package/src/agent/deploy.ts

@@ -0,0 +1,171 @@
+/**
+ * Deploy functionality for Vibe-Weaver CLI
+ * Deploy projects and verify against live URL
+ */
+
+import chalk from 'chalk';
+import { getApiKey } from '../auth/index.js';
+import { getSupabaseUrl } from '../config/index.js';
+import { runShell } from '../tools/shell.js';
+
+export interface DeployOptions {
+  projectId?: string;
+  platform?: string;
+  siteUrl?: string;
+}
+
+export interface DeployResult {
+  success: boolean;
+  url?: string;
+  projectId?: string;
+  error?: string;
+}
+
+/**
+ * Submit deployment
+ */
+export async function submitDeploy(options: DeployOptions): Promise<DeployResult> {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+
+  const supabaseUrl = getSupabaseUrl();
+  
+  console.log(chalk.cyan('\n🚀 Submitting deployment...'));
+
+  const response = await fetch(`${supabaseUrl}/functions/v1/deploy-bridge`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      projectId: options.projectId,
+      platform: options.platform || 'web'
+    })
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+    return {
+      success: false,
+      error: error.error || error.message
+    };
+  }
+
+  const result = await response.json();
+  
+  console.log(chalk.green(`✓ Deployment submitted`));
+  console.log(chalk.gray(`  URL: ${result.url}`));
+
+  return {
+    success: true,
+    url: result.url,
+    projectId: result.projectId
+  };
+}
+
+/**
+ * Verify deployment by checking the URL
+ */
+export async function verifyDeploy(url: string, options: {
+  timeout?: number;
+  expectedStatus?: number;
+} = {}): Promise<{ success: boolean; status?: number; error?: string }> {
+  const timeout = options.timeout || 60000;
+  const expectedStatus = options.expectedStatus || 200;
+  
+  console.log(chalk.gray(`\nVerifying deployment at ${url}...`));
+
+  const startTime = Date.now();
+  
+  while (Date.now() - startTime < timeout) {
+    try {
+      const response = await fetch(url, { method: 'HEAD' });
+      
+      if (response.status === expectedStatus) {
+        console.log(chalk.green(`✓ Deployment verified (${response.status})`));
+        return { success: true, status: response.status };
+      }
+      
+      // If we get 404, the site might still be deploying
+      if (response.status === 404) {
+        console.log(chalk.yellow(`  Still deploying... (${response.status})`));
+      } else {
+        console.log(chalk.yellow(`  Unexpected status: ${response.status}`));
+      }
+    } catch (error) {
+      console.log(chalk.yellow(`  Waiting for deployment...`));
+    }
+    
+    await new Promise(resolve => setTimeout(resolve, 5000));
+  }
+
+  console.log(chalk.red(`✗ Deployment verification timed out`));
+  return {
+    success: false,
+    error: 'Deployment verification timed out'
+  };
+}
+
+/**
+ * Full deploy and verify workflow
+ */
+export async function deploy(options: {
+  projectId?: string;
+  platform?: string;
+  verify?: boolean;
+  cwd?: string;
+} = {}): Promise<DeployResult> {
+  const verify = options.verify !== false;
+  
+  console.log(chalk.cyan('\n🚀 Vibe-Weaver Deploy'));
+  
+  // First build locally
+  if (options.cwd) {
+    console.log(chalk.gray('\nBuilding project locally...'));
+    const buildResult = await runShell('npm run build', { cwd: options.cwd });
+    
+    if (!buildResult.success) {
+      return {
+        success: false,
+        error: `Build failed: ${buildResult.stderr}`
+      };
+    }
+    
+    console.log(chalk.green('✓ Build successful'));
+  }
+  
+  // Submit deployment
+  console.log(chalk.gray('\nSubmitting to Vibe-Weaver...'));
+  const deployResult = await submitDeploy({
+    projectId: options.projectId,
+    platform: options.platform
+  });
+
+  if (!deployResult.success) {
+    return deployResult;
+  }
+
+  // Verify if requested
+  if (verify && deployResult.url) {
+    const verifyResult = await verifyDeploy(deployResult.url);
+    
+    if (!verifyResult.success) {
+      return {
+        success: false,
+        url: deployResult.url,
+        error: verifyResult.error
+      };
+    }
+  }
+
+  return deployResult;
+}
+
+export default {
+  submitDeploy,
+  verifyDeploy,
+  deploy
+};

package/src/agent/swarm.ts

@@ -0,0 +1,167 @@
+/**
+ * Sub-agent Swarm for Vibe-Weaver CLI
+ * Runs multiple agents in parallel for complex tasks
+ */
+
+import chalk from 'chalk';
+import { generateCode } from '../lib/vibe-api.js';
+import { writeCodeBlocks } from '../lib/code-parser.js';
+import { runShell } from '../tools/shell.js';
+import path from 'path';
+
+export interface AgentTask {
+  id: string;
+  name: string;
+  goal: string;
+  status: 'pending' | 'running' | 'completed' | 'failed';
+  result?: string;
+  error?: string;
+}
+
+export interface SwarmResult {
+  success: boolean;
+  completed: number;
+  failed: number;
+  results: AgentTask[];
+}
+
+/**
+ * Split a complex goal into sub-tasks for parallel execution
+ */
+export async function planSubTasks(goal: string): Promise<string[]> {
+  const result = await generateCode({
+    goal: `Break down this complex goal into 3-5 independent subtasks that can run in parallel. List only the subtask descriptions, one per line:\n\n${goal}`,
+    modelId: 'balanced'
+  });
+
+  // Parse subtasks from result
+  const lines = result.explanation.split('\n').filter(line => line.trim().length > 0);
+  return lines.slice(0, 5); // Limit to 5 subtasks
+}
+
+/**
+ * Execute a single subtask
+ */
+async function executeSubTask(task: AgentTask, baseDir: string): Promise<AgentTask> {
+  task.status = 'running';
+  
+  try {
+    console.log(chalk.gray(`[${task.id}] Starting: ${task.name}`));
+    
+    const result = await generateCode({
+      goal: task.goal,
+      modelId: 'balanced'
+    });
+
+    // Write generated files
+    if (result.parsed.blocks.length > 0) {
+      const writeResult = await writeCodeBlocks(result.parsed.blocks, baseDir);
+      
+      if (writeResult.failed.length > 0) {
+        task.status = 'failed';
+        task.error = `Failed to write files: ${writeResult.failed.map(f => f.path).join(', ')}`;
+      } else {
+        task.status = 'completed';
+        task.result = `Generated ${writeResult.success.length} files: ${writeResult.success.join(', ')}`;
+      }
+    } else {
+      task.status = 'completed';
+      task.result = result.explanation;
+    }
+
+    console.log(chalk.green(`[${task.id}] Completed: ${task.name}`));
+  } catch (error) {
+    task.status = 'failed';
+    task.error = error instanceof Error ? error.message : String(error);
+    console.log(chalk.red(`[${task.id}] Failed: ${task.name} - ${task.error}`));
+  }
+
+  return task;
+}
+
+/**
+ * Run multiple agents in parallel (swarm)
+ */
+export async function runSwarm(goal: string, options: {
+  maxParallel?: number;
+  baseDir?: string;
+} = {}): Promise<SwarmResult> {
+  const maxParallel = options.maxParallel || 3;
+  const baseDir = options.baseDir || process.cwd();
+
+  console.log(chalk.cyan('\n🎯 Vibe-Weaver Agent Swarm'));
+  console.log(chalk.gray(`Planning subtasks for: ${goal.substring(0, 50)}...\n`));
+
+  // Plan subtasks
+  const subtaskGoals = await planSubTasks(goal);
+  
+  if (subtaskGoals.length === 0) {
+    console.log(chalk.yellow('Could not generate subtasks. Running as single task.'));
+    subtaskGoals.push(goal);
+  }
+
+  console.log(chalk.gray(`Found ${subtaskGoals.length} subtasks:\n`));
+  for (let i = 0; i < subtaskGoals.length; i++) {
+    console.log(chalk.gray(`  ${i + 1}. ${subtaskGoals[i].substring(0, 60)}...`));
+  }
+  console.log();
+
+  // Create tasks
+  const tasks: AgentTask[] = subtaskGoals.map((subGoal, i) => ({
+    id: `agent-${i + 1}`,
+    name: `Agent ${i + 1}`,
+    goal: subGoal,
+    status: 'pending' as const
+  }));
+
+  // Run tasks in batches
+  const results: AgentTask[] = [];
+  
+  for (let i = 0; i < tasks.length; i += maxParallel) {
+    const batch = tasks.slice(i, i + maxParallel);
+    
+    console.log(chalk.cyan(`\n--- Running batch ${Math.floor(i / maxParallel) + 1} (${batch.length} agents) ---\n`));
+    
+    // Execute batch in parallel
+    const batchResults = await Promise.all(
+      batch.map(task => executeSubTask(task, baseDir))
+    );
+    
+    results.push(...batchResults);
+
+    // Show progress
+    const completed = results.filter(t => t.status === 'completed').length;
+    const failed = results.filter(t => t.status === 'failed').length;
+    console.log(chalk.gray(`\nProgress: ${completed} completed, ${failed} failed\n`));
+  }
+
+  // Summary
+  const completed = results.filter(t => t.status === 'completed').length;
+  const failed = results.filter(t => t.status === 'failed').length;
+
+  console.log(chalk.cyan('\n=== Swarm Results ==='));
+  console.log(chalk.green(`Completed: ${completed}`));
+  if (failed > 0) {
+    console.log(chalk.red(`Failed: ${failed}`));
+  }
+
+  for (const task of results) {
+    if (task.status === 'completed') {
+      console.log(chalk.green(`  ✓ ${task.name}: ${task.result?.substring(0, 50)}...`));
+    } else if (task.status === 'failed') {
+      console.log(chalk.red(`  ✗ ${task.name}: ${task.error}`));
+    }
+  }
+
+  return {
+    success: failed === 0,
+    completed,
+    failed,
+    results
+  };
+}
+
+export default {
+  runSwarm,
+  planSubTasks
+};

package/src/agent/tasks.ts

@@ -0,0 +1,205 @@
+/**
+ * Background Tasks for Vibe-Weaver CLI
+ * Submit server-side runs and check status
+ */
+
+import chalk from 'chalk';
+import { getApiKey } from '../auth/index.js';
+import { getSupabaseUrl } from '../config/index.js';
+
+export interface TaskSubmission {
+  id?: string;
+  goal: string;
+  platform?: string;
+  language?: string;
+  modelId?: string;
+}
+
+export interface TaskStatus {
+  id: string;
+  status: 'pending' | 'running' | 'completed' | 'failed';
+  progress?: number;
+  result?: string;
+  error?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * Submit a background task to the server
+ */
+export async function submitTask(options: TaskSubmission): Promise<{ id: string; status: string }> {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+
+  const supabaseUrl = getSupabaseUrl();
+  
+  console.log(chalk.gray(`\nSubmitting background task: ${options.goal.substring(0, 50)}...`));
+
+  const response = await fetch(`${supabaseUrl}/functions/v1/automation-executor`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      goal: options.goal,
+      platform: options.platform || 'web',
+      language: options.language || 'typescript',
+      modelId: options.modelId || 'balanced'
+    })
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+    throw new Error(`Failed to submit task: ${error.error || error.message}`);
+  }
+
+  const result = await response.json();
+  
+  console.log(chalk.green(`✓ Task submitted: ${result.id}`));
+  console.log(chalk.gray(`  Use "vibe-weaver task status ${result.id}" to check progress\n`));
+
+  return {
+    id: result.id,
+    status: result.status || 'pending'
+  };
+}
+
+/**
+ * Get task status
+ */
+export async function getTaskStatus(taskId: string): Promise<TaskStatus> {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+
+  const supabaseUrl = getSupabaseUrl();
+
+  const response = await fetch(`${supabaseUrl}/functions/v1/automation-executor?id=${taskId}`, {
+    method: 'GET',
+    headers: {
+      'Authorization': `Bearer ${apiKey}`
+    }
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+    throw new Error(`Failed to get task status: ${error.error || error.message}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Stream task logs
+ */
+export async function* streamTaskLogs(taskId: string): AsyncGenerator<string> {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+
+  const supabaseUrl = getSupabaseUrl();
+  
+  const response = await fetch(`${supabaseUrl}/functions/v1/automation-executor/logs?id=${taskId}`, {
+    method: 'GET',
+    headers: {
+      'Authorization': `Bearer ${apiKey}`
+    }
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to get task logs: ${response.status}`);
+  }
+
+  const reader = response.body?.getReader();
+  const decoder = new TextDecoder();
+
+  if (!reader) {
+    throw new Error('Could not read response body');
+  }
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      
+      if (done) break;
+      
+      yield decoder.decode(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+/**
+ * Poll task status until completion
+ */
+export async function waitForTask(taskId: string, options: {
+  pollInterval?: number;
+  onProgress?: (status: TaskStatus) => void;
+} = {}): Promise<TaskStatus> {
+  const pollInterval = options.pollInterval || 5000;
+  
+  while (true) {
+    const status = await getTaskStatus(taskId);
+    
+    if (options.onProgress) {
+      options.onProgress(status);
+    }
+
+    if (status.status === 'completed') {
+      return status;
+    }
+    
+    if (status.status === 'failed') {
+      throw new Error(`Task failed: ${status.error}`);
+    }
+
+    // Wait before next poll
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+  }
+}
+
+/**
+ * Display task status nicely
+ */
+export function displayTaskStatus(status: TaskStatus): void {
+  const statusColor: Record<string, (s: string) => string> = {
+    pending: chalk.yellow,
+    running: chalk.blue,
+    completed: chalk.green,
+    failed: chalk.red
+  };
+
+  console.log(chalk.bold(`\nTask: ${status.id}`));
+  console.log(chalk.gray(`Status: ${statusColor[status.status] ? statusColor[status.status](status.status) : chalk.gray(status.status)}`));
+  
+  if (status.progress !== undefined) {
+    console.log(chalk.gray(`Progress: ${status.progress}%`));
+  }
+  
+  if (status.result) {
+    console.log(chalk.gray(`\nResult:`));
+    console.log(status.result);
+  }
+  
+  if (status.error) {
+    console.log(chalk.red(`\nError: ${status.error}`));
+  }
+  
+  console.log(chalk.gray(`\nCreated: ${new Date(status.createdAt).toLocaleString()}`));
+  console.log(chalk.gray(`Updated: ${new Date(status.updatedAt).toLocaleString()}`));
+}
+
+export default {
+  submitTask,
+  getTaskStatus,
+  streamTaskLogs,
+  waitForTask,
+  displayTaskStatus
+};