vibe-weaver 1.0.0

package/src/lib/code-parser.ts

@@ -0,0 +1,150 @@
+/**
+ * Code Block Parser for Vibe-Weaver CLI
+ * Parses markdown code blocks with language and file path
+ * Format: ```lang path\n...```
+ */
+
+export interface ParsedCodeBlock {
+  language: string;
+  path: string;
+  content: string;
+  startLine: number;
+  endLine: number;
+}
+
+export interface ParseResult {
+  blocks: ParsedCodeBlock[];
+  explanation?: string;
+  quality?: {
+    score: number;
+    issues: string[];
+    suggestions: string[];
+  };
+  stats?: {
+    mode: string;
+    parameters: string;
+    architecture: string;
+    inferenceTimeMs: number;
+  };
+}
+
+/**
+ * Parse code blocks from the AI response
+ * Supports format: ```typescript src/App.tsx\n...content...```
+ */
+export function parseCodeBlocks(response: string): ParseResult {
+  const blocks: ParsedCodeBlock[] = [];
+  
+  // Regex to match code blocks with optional language and path
+  // Format: ```[lang[ path]]\n...content...\n```
+  const codeBlockRegex = /```(\w+)?\s+(.+?)\n([\s\S]*?)```/g;
+  
+  let match;
+  while ((match = codeBlockRegex.exec(response)) !== null) {
+    const language = match[1] || 'text';
+    const path = match[2].trim();
+    const content = match[3];
+    
+    // Calculate line numbers
+    const beforeBlock = response.substring(0, match.index);
+    const startLine = (beforeBlock.match(/\n/g) || []).length + 1;
+    const endLine = startLine + (content.match(/\n/g) || []).length;
+    
+    blocks.push({
+      language,
+      path,
+      content,
+      startLine,
+      endLine
+    });
+  }
+  
+  // Try to extract explanation (text before first code block)
+  let explanation: string | undefined;
+  const firstCodeBlockIndex = response.indexOf('```');
+  if (firstCodeBlockIndex > 0) {
+    explanation = response.substring(0, firstCodeBlockIndex).trim();
+  }
+  
+  return { blocks, explanation };
+}
+
+/**
+ * Parse a single code block string
+ */
+export function parseSingleCodeBlock(blockStr: string): { language: string; path: string; content: string } | null {
+  const match = blockStr.match(/^(\w+)?\s+(.+?)\n([\s\S]*)$/);
+  if (!match) return null;
+  
+  return {
+    language: match[1] || 'text',
+    path: match[2].trim(),
+    content: match[3]
+  };
+}
+
+/**
+ * Write parsed code blocks to disk
+ */
+export async function writeCodeBlocks(
+  blocks: ParsedCodeBlock[],
+  baseDir: string,
+  options: { dryRun?: boolean } = {}
+): Promise<{ success: string[]; failed: { path: string; error: string }[] }> {
+  const fs = await import('fs/promises');
+  const path = await import('path');
+  
+  const success: string[] = [];
+  const failed: { path: string; error: string }[] = [];
+  
+  for (const block of blocks) {
+    try {
+      const fullPath = path.join(baseDir, block.path);
+      const dir = path.dirname(fullPath);
+      
+      if (!options.dryRun) {
+        // Create directory if it doesn't exist
+        await fs.mkdir(dir, { recursive: true });
+        
+        // Write file
+        await fs.writeFile(fullPath, block.content, 'utf-8');
+      }
+      
+      success.push(block.path);
+    } catch (error) {
+      failed.push({
+        path: block.path,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  
+  return { success, failed };
+}
+
+/**
+ * Generate a diff between old and new content
+ */
+export function generateDiff(oldContent: string, newContent: string, filePath: string): string {
+  const diff = require('diff');
+  const changes = diff.diffLines(oldContent, newContent);
+  
+  let result = `--- ${filePath}\n+++ ${filePath}\n`;
+  
+  for (const change of changes) {
+    const prefix = change.added ? '+' : change.removed ? '-' : ' ';
+    const lines = change.value.split('\n').filter((l: string) => l.length > 0);
+    for (const line of lines) {
+      result += `${prefix}${line}\n`;
+    }
+  }
+  
+  return result;
+}
+
+export default {
+  parseCodeBlocks,
+  parseSingleCodeBlock,
+  writeCodeBlocks,
+  generateDiff
+};

package/src/lib/vibe-api.ts

@@ -0,0 +1,197 @@
+/**
+ * Vibe-Weaver API Client
+ * Communicates with the vibe-ai-api edge function
+ */
+
+import { getApiKey, getGithubToken } from '../auth/index.js';
+import { getSupabaseUrl } from '../config/index.js';
+import { parseCodeBlocks, ParseResult } from './code-parser.js';
+
+export type ModelId = 'fast' | 'balanced' | 'deep_reasoning' | 'refactor';
+export type Platform = 'web' | 'roblox' | 'mobile' | 'desktop' | 'api';
+export type Language = 'typescript' | 'javascript' | 'python' | 'lua' | 'rust';
+
+export interface GenerateOptions {
+  goal: string;
+  platform?: Platform;
+  language?: Language;
+  modelId?: ModelId;
+  context?: string;
+  stream?: boolean;
+}
+
+export interface GenerateResult {
+  code: string;
+  explanation: string;
+  quality: {
+    score: number;
+    issues: string[];
+    suggestions: string[];
+  };
+  stats: {
+    mode: string;
+    parameters: string;
+    architecture: string;
+    inferenceTimeMs: number;
+  };
+  parsed: ParseResult;
+}
+
+export interface CreditInfo {
+  cost: number;
+  remaining: number;
+  plan: string;
+}
+
+/**
+ * Get credit cost for a given model
+ */
+export function getCreditCost(modelId: ModelId): number {
+  const costs: Record<ModelId, number> = {
+    'fast': 0.2,
+    'balanced': 0.5,
+    'deep_reasoning': 1.0,
+    'refactor': 1.0
+  };
+  return costs[modelId] || 0.5;
+}
+
+/**
+ * Call the vibe-ai-api to generate code
+ */
+export async function generateCode(options: GenerateOptions): Promise<GenerateResult> {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+  
+  const supabaseUrl = getSupabaseUrl();
+  const endpoint = `${supabaseUrl}/functions/v1/vibe-ai-api`;
+  
+  const payload = {
+    goal: options.goal,
+    platform: options.platform || 'web',
+    language: options.language || 'typescript',
+    modelId: options.modelId || 'balanced'
+  };
+  
+  console.log(`\n${'[Vibe-Weaver]'.padEnd(20)} Calling ${payload.modelId.toUpperCase()} model for: ${options.goal.substring(0, 50)}...`);
+  
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(payload)
+  });
+  
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+    
+    if (response.status === 401) {
+      throw new Error('Authentication failed. Please run "vibe-weaver login" again.');
+    }
+    if (response.status === 402) {
+      throw new Error(`Insufficient credits: ${error.message}`);
+    }
+    
+    throw new Error(`API error: ${error.error || error.message}`);
+  }
+  
+  const result = await response.json();
+  
+  // Parse code blocks from the response
+  const parsed = parseCodeBlocks(result.code);
+  
+  return {
+    code: result.code,
+    explanation: result.explanation || '',
+    quality: result.quality || { score: 0, issues: [], suggestions: [] },
+    stats: result.stats || { mode: payload.modelId, parameters: 'N/A', architecture: 'N/A', inferenceTimeMs: 0 },
+    parsed
+  };
+}
+
+/**
+ * Stream code generation (for future implementation)
+ */
+export async function* streamGenerate(options: GenerateOptions): AsyncGenerator<{ delta: string; done: boolean }> {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+  
+  const supabaseUrl = getSupabaseUrl();
+  const endpoint = `${supabaseUrl}/functions/v1/vibe-ai-api`;
+  
+  const payload = {
+    goal: options.goal,
+    platform: options.platform || 'web',
+    language: options.language || 'typescript',
+    modelId: options.modelId || 'balanced'
+  };
+  
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(payload)
+  });
+  
+  if (!response.ok) {
+    throw new Error(`API error: ${response.status}`);
+  }
+  
+  // For now, yield the full result
+  const result = await response.json();
+  yield { delta: result.code, done: true };
+}
+
+/**
+ * Get remaining credits for the user
+ */
+export async function getCredits(): Promise<CreditInfo> {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+  
+  const supabaseUrl = getSupabaseUrl();
+  
+  try {
+    // Try to get profile info
+    const response = await fetch(`${supabaseUrl}/rest/v1/profiles?select=credits,plan`, {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'apikey': `${supabaseUrl}/rest/v1/apikey`
+      }
+    });
+    
+    if (response.ok) {
+      const data = await response.json();
+      if (Array.isArray(data) && data.length > 0) {
+        return {
+          cost: 0,
+          remaining: data[0].credits || 0,
+          plan: data[0].plan || 'free'
+        };
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+  
+  return { cost: 0, remaining: 0, plan: 'unknown' };
+}
+
+export default {
+  generateCode,
+  streamGenerate,
+  getCredits,
+  getCreditCost
+};
+
+export type { ModelId, Platform, Language };

package/src/mcp/index.ts

@@ -0,0 +1,273 @@
+/**
+ * MCP Client for Vibe-Weaver CLI
+ * Connects to MCP servers via JSON-RPC
+ */
+
+import chalk from 'chalk';
+import { getSupabaseUrl } from '../config/index.js';
+
+export interface MCPServer {
+  name: string;
+  url: string;
+  enabled: boolean;
+}
+
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: Record<string, any>;
+}
+
+export interface MCPInitializeResult {
+  protocolVersion: string;
+  serverInfo: {
+    name: string;
+    version: string;
+  };
+  capabilities: Record<string, any>;
+}
+
+export interface MCPToolsResult {
+  tools: MCPTool[];
+}
+
+/**
+ * Default MCP servers provided by Vibe-Weaver
+ */
+export function getDefaultMCPServers(): MCPServer[] {
+  const supabaseUrl = getSupabaseUrl();
+  return [
+    { name: 'github-mcp', url: `${supabaseUrl}/functions/v1/github-mcp`, enabled: true },
+    { name: 'filesystem-mcp', url: `${supabaseUrl}/functions/v1/filesystem-mcp`, enabled: true },
+    { name: 'supabase-mcp', url: `${supabaseUrl}/functions/v1/supabase-mcp`, enabled: true },
+    { name: 'roblox-mcp', url: `${supabaseUrl}/functions/v1/roblox-mcp`, enabled: true },
+    { name: 'linear-mcp', url: `${supabaseUrl}/functions/v1/linear-mcp`, enabled: false },
+    { name: 'notion-mcp', url: `${supabaseUrl}/functions/v1/notion-mcp`, enabled: false },
+    { name: 'slack-mcp', url: `${supabaseUrl}/functions/v1/slack-mcp`, enabled: false },
+    { name: 'discord-mcp', url: `${supabaseUrl}/functions/v1/discord-mcp`, enabled: false },
+    { name: 'vercel-mcp', url: `${supabaseUrl}/functions/v1/vercel-mcp`, enabled: false },
+    { name: 'stripe-mcp', url: `${supabaseUrl}/functions/v1/stripe-mcp`, enabled: false },
+  ];
+}
+
+/**
+ * MCP JSON-RPC client
+ */
+export class MCPClient {
+  private url: string;
+  private initialized: boolean = false;
+  private serverInfo: MCPInitializeResult['serverInfo'] | null = null;
+  private capabilities: Record<string, any> = {};
+  private requestId: number = 0;
+
+  constructor(url: string) {
+    this.url = url;
+  }
+
+  /**
+   * Send a JSON-RPC request
+   */
+  private async request(method: string, params?: Record<string, any>): Promise<any> {
+    const id = ++this.requestId;
+    
+    const response = await fetch(this.url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id,
+        method,
+        params: params || {}
+      })
+    });
+
+    if (!response.ok) {
+      throw new Error(`MCP request failed: ${response.status} ${response.statusText}`);
+    }
+
+    const result = await response.json();
+    
+    if (result.error) {
+      throw new Error(`MCP error: ${result.error.message}`);
+    }
+
+    return result.result;
+  }
+
+  /**
+   * Initialize the MCP connection
+   */
+  async initialize(): Promise<MCPInitializeResult> {
+    try {
+      const result = await this.request('initialize', {
+        protocolVersion: '2024-11-05',
+        capabilities: {},
+        clientInfo: {
+          name: 'vibe-weaver-cli',
+          version: '1.0.0'
+        }
+      });
+
+      this.initialized = true;
+      this.serverInfo = result.serverInfo;
+      this.capabilities = result.capabilities;
+
+      return result;
+    } catch (error) {
+      throw new Error(`Failed to initialize MCP server: ${error instanceof Error ? error.message : error}`);
+    }
+  }
+
+  /**
+   * List available tools
+   */
+  async listTools(): Promise<MCPToolsResult> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    return this.request('tools/list');
+  }
+
+  /**
+   * Call a tool
+   */
+  async callTool(name: string, args: Record<string, any>): Promise<any> {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    return this.request('tools/call', {
+      name,
+      arguments: args
+    });
+  }
+
+  /**
+   * Check if server is alive
+   */
+  async ping(): Promise<boolean> {
+    try {
+      await this.request('ping');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  getServerInfo(): MCPInitializeResult['serverInfo'] | null {
+    return this.serverInfo;
+  }
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+}
+
+/**
+ * MCP Manager - handles multiple MCP servers
+ */
+export class MCPManager {
+  private clients: Map<string, MCPClient> = new Map();
+  private servers: MCPServer[] = [];
+
+  constructor(servers?: MCPServer[]) {
+    this.servers = servers || getDefaultMCPServers();
+  }
+
+  /**
+   * Initialize all enabled MCP servers
+   */
+  async initializeAll(): Promise<{ success: string[]; failed: { name: string; error: string }[] }> {
+    const success: string[] = [];
+    const failed: { name: string; error: string }[] = [];
+
+    for (const server of this.servers) {
+      if (!server.enabled) continue;
+
+      const client = new MCPClient(server.url);
+      
+      try {
+        const result = await client.initialize();
+        this.clients.set(server.name, client);
+        success.push(`${server.name} (${result.serverInfo.version})`);
+        console.log(chalk.green(`✓ Connected to ${server.name}`));
+      } catch (error) {
+        failed.push({
+          name: server.name,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        console.log(chalk.red(`✗ Failed to connect to ${server.name}`));
+      }
+    }
+
+    return { success, failed };
+  }
+
+  /**
+   * List all available tools from connected servers
+   */
+  async listAllTools(): Promise<{ server: string; tools: MCPTool[] }[]> {
+    const results: { server: string; tools: MCPTool[] }[] = [];
+
+    for (const [name, client] of this.clients) {
+      try {
+        const result = await client.listTools();
+        results.push({ server: name, tools: result.tools });
+      } catch (error) {
+        console.warn(chalk.yellow(`Warning: Failed to list tools from ${name}: ${error}`));
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Call a tool on a specific server
+   */
+  async callTool(serverName: string, toolName: string, args: Record<string, any>): Promise<any> {
+    const client = this.clients.get(serverName);
+    
+    if (!client) {
+      throw new Error(`MCP server "${serverName}" not connected`);
+    }
+
+    return client.callTool(toolName, args);
+  }
+
+  /**
+   * Get status of all servers
+   */
+  getStatus(): { name: string; connected: boolean; tools: number }[] {
+    const status: { name: string; connected: boolean; tools: number }[] = [];
+    
+    for (const server of this.servers) {
+      const client = this.clients.get(server.name);
+      status.push({
+        name: server.name,
+        connected: !!client && client.isInitialized(),
+        tools: 0 // Would need to cache tool list
+      });
+    }
+
+    return status;
+  }
+
+  /**
+   * Enable/disable a server
+   */
+  setServerEnabled(name: string, enabled: boolean): void {
+    const server = this.servers.find(s => s.name === name);
+    if (server) {
+      server.enabled = enabled;
+    }
+  }
+}
+
+export default {
+  MCPClient,
+  MCPManager,
+  getDefaultMCPServers
+};