vibebusiness 1.2.11

package/.next/standalone/scripts/analyze.ts

@@ -0,0 +1,681 @@
+#!/usr/bin/env npx tsx
+
+/**
+ * AI Business Analyst - Analysis Script
+ *
+ * This script runs Claude Code to analyze the codebase and generate improvement ideas.
+ *
+ * Usage:
+ *   npm run analyze -- --type=quick
+ *   npm run analyze -- --type=deep
+ *   npm run analyze -- --type=metrics
+ *   npm run analyze -- --type=seo
+ *   npm run analyze -- --type=research --topic="response time optimization" --context=<base64>
+ */
+
+import { execSync, spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+import { getAnalysisPrompt } from '../src/lib/prompts';
+import type { AnalystConfig as ImportedAnalystConfig, BusinessConfig } from '../src/lib/types';
+
+// Local type alias for compatibility
+type AnalystConfig = ImportedAnalystConfig;
+
+interface IdeaInput {
+  title: string;
+  summary: string;
+  category: string;
+  priority: string;
+  effort: string;
+  impact: string;
+  context: string;
+  rationale: string;
+  implementation_plan: string;
+  success_metrics: string[];
+  tags?: string[];
+  files_analyzed?: string[];
+  goal_id?: string;
+  hypothesis_id?: string;
+}
+
+interface BusinessIdea {
+  id: string;
+  created_at: string;
+  updated_at: string;
+  title: string;
+  summary: string;
+  category: string;
+  priority: string;
+  effort: string;
+  impact: string;
+  context: string;
+  rationale: string;
+  implementation_plan: string;
+  success_metrics: string[];
+  stage: string;
+  source: {
+    type: string;
+    session_id: string;
+    files_analyzed?: string[];
+  };
+  implementation: {
+    branch_name: string | null;
+    pr_url: string | null;
+    pr_number: number | null;
+    commits: string[];
+    started_at: string | null;
+    completed_at: string | null;
+  };
+  comments: Array<unknown>;
+  tags: string[];
+  related_ideas: string[];
+  goal_id?: string | null;
+  hypothesis_id?: string | null;
+}
+
+interface Session {
+  id: string;
+  created_at: string;
+  completed_at: string | null;
+  type: string;
+  status: string;
+  repos_analyzed: string[];
+  ideas_generated: string[];
+  error_message: string | null;
+  logs: string[];
+}
+
+// Paths — centralized in lib/paths.ts (uses process.cwd() for portability)
+import {
+  DATA_DIR,
+  IDEAS_FILE,
+  SESSIONS_FILE,
+  CONFIG_FILE,
+  GOALS_FILE,
+  HYPOTHESES_FILE,
+  BUSINESS_CONTEXT_FILE,
+} from './lib/paths';
+
+// Analysis types
+type AnalysisType = 'quick' | 'deep' | 'metrics' | 'seo' | 'research';
+
+// Parse command line arguments
+function parseArgs(): { type: AnalysisType; topic?: string; context?: string } {
+  const args = process.argv.slice(2);
+  let type: AnalysisType = 'quick';
+  let topic: string | undefined;
+  let context: string | undefined;
+
+  for (const arg of args) {
+    if (arg.startsWith('--type=')) {
+      const value = arg.split('=')[1];
+      if (['quick', 'deep', 'metrics', 'seo', 'research'].includes(value)) {
+        type = value as AnalysisType;
+      }
+    } else if (arg.startsWith('--topic=')) {
+      topic = arg.split('=').slice(1).join('='); // Handle topics with = in them
+    } else if (arg.startsWith('--context=')) {
+      context = arg.split('=').slice(1).join('=');
+    }
+  }
+
+  return { type, topic, context };
+}
+
+// Load config
+function loadConfig(): AnalystConfig {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    throw new Error('Config file not found. Please ensure data/config.json exists.');
+  }
+  return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+}
+
+// Load business context
+function loadBusinessContext(): BusinessConfig | undefined {
+  if (!fs.existsSync(BUSINESS_CONTEXT_FILE)) {
+    return undefined;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(BUSINESS_CONTEXT_FILE, 'utf-8'));
+  } catch {
+    return undefined;
+  }
+}
+
+// Load ideas
+function loadIdeas(): { ideas: BusinessIdea[] } {
+  if (!fs.existsSync(IDEAS_FILE)) {
+    return { ideas: [] };
+  }
+  return JSON.parse(fs.readFileSync(IDEAS_FILE, 'utf-8'));
+}
+
+// Save ideas
+function saveIdeas(data: { ideas: BusinessIdea[] }): void {
+  fs.writeFileSync(IDEAS_FILE, JSON.stringify(data, null, 2));
+}
+
+// Load sessions
+function loadSessions(): { sessions: Session[] } {
+  if (!fs.existsSync(SESSIONS_FILE)) {
+    return { sessions: [] };
+  }
+  return JSON.parse(fs.readFileSync(SESSIONS_FILE, 'utf-8'));
+}
+
+// Save sessions
+function saveSessions(data: { sessions: Session[] }): void {
+  fs.writeFileSync(SESSIONS_FILE, JSON.stringify(data, null, 2));
+}
+
+// Clean up stuck sessions (running for more than 30 minutes)
+function cleanupStuckSessions(): number {
+  const sessions = loadSessions();
+  const now = new Date();
+  const STUCK_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutes
+  let cleanedCount = 0;
+
+  for (const session of sessions.sessions) {
+    if (session.status === 'running') {
+      const createdAt = new Date(session.created_at);
+      const ageMs = now.getTime() - createdAt.getTime();
+
+      if (ageMs > STUCK_THRESHOLD_MS) {
+        session.status = 'failed';
+        session.completed_at = now.toISOString();
+        session.error_message = `Session timed out (stuck in running state for ${Math.round(ageMs / 60000)} minutes)`;
+        session.logs.push(`[${now.toISOString()}] Session marked as failed (stuck timeout)`);
+        cleanedCount++;
+        console.log(`Cleaned up stuck session: ${session.id} (was running for ${Math.round(ageMs / 60000)} min)`);
+      }
+    }
+  }
+
+  if (cleanedCount > 0) {
+    saveSessions(sessions);
+  }
+
+  return cleanedCount;
+}
+
+// Create a new session
+function createSession(type: string, repos: string[]): Session {
+  // First, clean up any stuck sessions
+  cleanupStuckSessions();
+
+  const now = new Date().toISOString();
+  const session: Session = {
+    id: `session-${uuidv4().slice(0, 8)}`,
+    created_at: now,
+    completed_at: null,
+    type,
+    status: 'running',
+    repos_analyzed: repos,
+    ideas_generated: [],
+    error_message: null,
+    logs: [`[${now}] Session started`],
+  };
+
+  const sessions = loadSessions();
+  sessions.sessions.push(session);
+  saveSessions(sessions);
+
+  return session;
+}
+
+// Update session
+function updateSession(sessionId: string, updates: Partial<Session>): void {
+  const sessions = loadSessions();
+  const index = sessions.sessions.findIndex((s) => s.id === sessionId);
+  if (index !== -1) {
+    sessions.sessions[index] = { ...sessions.sessions[index], ...updates };
+    saveSessions(sessions);
+  }
+}
+
+// Add log to session
+function addSessionLog(sessionId: string, message: string): void {
+  const sessions = loadSessions();
+  const index = sessions.sessions.findIndex((s) => s.id === sessionId);
+  if (index !== -1) {
+    const timestamp = new Date().toISOString();
+    sessions.sessions[index].logs.push(`[${timestamp}] ${message}`);
+    saveSessions(sessions);
+  }
+  console.log(message);
+}
+
+// Load goals and format as context string for prompts
+function loadGoalsContext(): string {
+  try {
+    if (!fs.existsSync(GOALS_FILE)) return '';
+    const goalsData = JSON.parse(fs.readFileSync(GOALS_FILE, 'utf-8'));
+    const goals = goalsData.goals || [];
+    if (goals.length === 0) return '';
+
+    return goals.map((g: { id: string; title: string; status: string; current_value: number | null; target_value: number; target_unit: string; deadline: string; kpis: Array<{ name: string; current_value: number | null; target_value: number; unit: string; direction: string }> }) => {
+      const kpiLines = g.kpis.map((k) =>
+        `  - ${k.name}: ${k.current_value ?? 'N/A'} / ${k.target_value} ${k.unit} (${k.direction})`
+      ).join('\n');
+      return `**${g.id}: ${g.title}** — Status: ${g.status}, Progress: ${g.current_value ?? 0} / ${g.target_value} ${g.target_unit}, Deadline: ${g.deadline}\n${kpiLines}`;
+    }).join('\n\n');
+  } catch {
+    return '';
+  }
+}
+
+// Auto-link ideas with hypothesis_id to the hypothesis's validation_ideas array
+function linkIdeasToHypotheses(ideas: BusinessIdea[]): void {
+  const ideasWithHypothesis = ideas.filter((i) => i.hypothesis_id);
+  if (ideasWithHypothesis.length === 0) return;
+
+  try {
+    if (!fs.existsSync(HYPOTHESES_FILE)) return;
+    const data = JSON.parse(fs.readFileSync(HYPOTHESES_FILE, 'utf-8'));
+    const hypotheses = data.hypotheses || [];
+    let changed = false;
+
+    for (const idea of ideasWithHypothesis) {
+      const hypIndex = hypotheses.findIndex(
+        (h: { id: string }) => h.id === idea.hypothesis_id
+      );
+      if (hypIndex === -1) continue;
+
+      if (!hypotheses[hypIndex].validation_ideas.includes(idea.id)) {
+        hypotheses[hypIndex].validation_ideas.push(idea.id);
+        hypotheses[hypIndex].updated_at = new Date().toISOString();
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      fs.writeFileSync(HYPOTHESES_FILE, JSON.stringify({ hypotheses }, null, 2));
+      console.log(`Linked ${ideasWithHypothesis.length} idea(s) to their hypotheses`);
+    }
+  } catch (error) {
+    console.error('Failed to link ideas to hypotheses:', error);
+  }
+}
+
+// Load hypotheses and format as context string for prompts
+function loadHypothesesContext(): string {
+  try {
+    if (!fs.existsSync(HYPOTHESES_FILE)) return '';
+    const data = JSON.parse(fs.readFileSync(HYPOTHESES_FILE, 'utf-8'));
+    const hypotheses = data.hypotheses || [];
+    if (hypotheses.length === 0) return '';
+
+    return hypotheses
+      .filter((h: { status: string }) => h.status === 'stated' || h.status === 'testing')
+      .map((h: { id: string; title: string; statement: string; funnel_stage: string; priority: string; status: string; effort_to_test: string }) =>
+        `**${h.id}: ${h.title}** [${h.funnel_stage}] — Status: ${h.status}, Priority: ${h.priority}, Effort: ${h.effort_to_test}\n  Statement: ${h.statement}`
+      ).join('\n\n');
+  } catch {
+    return '';
+  }
+}
+
+// Generate the analysis prompt using the centralized prompts module
+function generatePrompt(
+  type: AnalysisType,
+  config: AnalystConfig,
+  topic?: string,
+  context?: string
+): string {
+  const schedule = config.schedules[type] || config.schedules.quick;
+  const goalsContext = loadGoalsContext();
+  const hypothesesContext = loadHypothesesContext();
+  const businessConfig = loadBusinessContext();
+  return getAnalysisPrompt({
+    type,
+    config,
+    maxIdeas: schedule.max_ideas,
+    topic,
+    context,
+    goalsContext: goalsContext || undefined,
+    hypothesesContext: hypothesesContext || undefined,
+    businessConfig,
+  });
+}
+
+// Parse ideas from Claude's response
+function parseIdeas(response: string, sessionId: string): BusinessIdea[] {
+  // Try to extract JSON array from the response
+  const jsonMatch = response.match(/\[\s*\{[\s\S]*\}\s*\]/);
+  if (!jsonMatch) {
+    console.error('No JSON array found in response');
+    return [];
+  }
+
+  try {
+    const rawIdeas: IdeaInput[] = JSON.parse(jsonMatch[0]);
+    const now = new Date().toISOString();
+
+    return rawIdeas.map((idea) => ({
+      id: `idea-${uuidv4().slice(0, 8)}`,
+      created_at: now,
+      updated_at: now,
+      title: idea.title || 'Untitled Idea',
+      summary: idea.summary || '',
+      category: idea.category || 'product',
+      priority: idea.priority || 'medium',
+      effort: idea.effort || 'm',
+      impact: idea.impact || 'm',
+      context: idea.context || '',
+      rationale: idea.rationale || '',
+      implementation_plan: idea.implementation_plan || '',
+      success_metrics: idea.success_metrics || [],
+      stage: 'inbox',
+      source: {
+        type: 'codebase_analysis',
+        session_id: sessionId,
+        files_analyzed: idea.files_analyzed,
+      },
+      implementation: {
+        branch_name: null,
+        pr_url: null,
+        pr_number: null,
+        commits: [],
+        started_at: null,
+        completed_at: null,
+      },
+      comments: [],
+      tags: idea.tags || [],
+      related_ideas: [],
+      goal_id: idea.goal_id || null,
+      hypothesis_id: idea.hypothesis_id || null,
+    }));
+  } catch (error) {
+    console.error('Failed to parse ideas JSON:', error);
+    return [];
+  }
+}
+
+// Run Claude Code with the analysis prompt
+async function runClaudeAnalysis(
+  prompt: string,
+  config: AnalystConfig,
+  timeoutMs: number = 600000 // 10 minute default timeout
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    // Build the command to run Claude Code
+    // We'll use the --print flag to get the response directly
+    const repoPaths = config.repos.map((r) => r.path);
+    const workDir = repoPaths[0]; // Use frontend repo as working directory
+
+    console.log('Starting Claude Code analysis...');
+    console.log(`Working directory: ${workDir}`);
+    console.log(`Timeout: ${timeoutMs / 1000}s`);
+
+    // Create a temporary file with the prompt
+    const tempPromptFile = path.join(DATA_DIR, '.analysis-prompt.txt');
+    fs.writeFileSync(tempPromptFile, prompt);
+
+    // Run Claude Code with the prompt via stdin (avoids shell arg length limits)
+    const claude = spawn('claude', [
+      '--print',
+      '--dangerously-skip-permissions',
+    ], {
+      cwd: workDir,
+      env: { ...process.env },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    // Write prompt to stdin and close it
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+
+    let output = '';
+    let errorOutput = '';
+    let isResolved = false;
+    const startTime = Date.now();
+
+    // Progress indicator every 30 seconds
+    const progressInterval = setInterval(() => {
+      if (!isResolved) {
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+        const outputLen = output.length;
+        console.log(`  ...Claude Code working (${elapsed}s elapsed, ${outputLen} chars output)`);
+      }
+    }, 30000);
+
+    // Timeout handler
+    const timeout = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true;
+        clearInterval(progressInterval);
+        claude.kill('SIGTERM');
+        // Give it 5 seconds to clean up, then force kill
+        setTimeout(() => {
+          try { claude.kill('SIGKILL'); } catch {}
+        }, 5000);
+
+        // Clean up temp file
+        try { fs.unlinkSync(tempPromptFile); } catch {}
+
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+        reject(new Error(`Claude Code timed out after ${elapsed}s (limit: ${timeoutMs / 1000}s)`));
+      }
+    }, timeoutMs);
+
+    claude.stdout.on('data', (data) => {
+      const text = data.toString();
+      output += text;
+      process.stdout.write(text);
+    });
+
+    claude.stderr.on('data', (data) => {
+      const text = data.toString();
+      errorOutput += text;
+      process.stderr.write(text);
+    });
+
+    claude.on('close', (code) => {
+      if (isResolved) return; // Already timed out
+      isResolved = true;
+      clearInterval(progressInterval);
+      clearTimeout(timeout);
+
+      // Clean up temp file
+      try {
+        fs.unlinkSync(tempPromptFile);
+      } catch {
+        // Ignore cleanup errors
+      }
+
+      const elapsed = Math.round((Date.now() - startTime) / 1000);
+      if (code === 0) {
+        console.log(`Claude Code completed in ${elapsed}s`);
+        resolve(output);
+      } else {
+        reject(new Error(`Claude Code exited with code ${code} after ${elapsed}s: ${errorOutput}`));
+      }
+    });
+
+    claude.on('error', (error) => {
+      if (isResolved) return;
+      isResolved = true;
+      clearInterval(progressInterval);
+      clearTimeout(timeout);
+      try { fs.unlinkSync(tempPromptFile); } catch {}
+      reject(error);
+    });
+  });
+}
+
+// Generate a codebase snapshot for the heartbeat
+async function generateCodebaseSnapshot(config: AnalystConfig): Promise<void> {
+  const snapshotPath = path.join(DATA_DIR, 'codebase-snapshot.json');
+
+  console.log('Generating codebase snapshot...');
+
+  const prompt = `You are analyzing the codebase to generate a structured snapshot.
+
+## Repositories
+${config.repos.map((r) => `- ${r.name}: ${r.path} (${r.type})`).join('\n')}
+
+## Your Task
+
+Generate a JSON snapshot of the codebase architecture. This will be used by the heartbeat to understand what exists.
+
+Focus on:
+1. What notification/alert systems exist (email, WhatsApp, push, in-app)
+2. What API endpoints handle leads, lawyers, marketplace
+3. What background jobs/schedulers exist
+4. What monitoring/analytics integrations exist
+5. What's notably MISSING that's relevant to a CRM
+
+Be FAST — use Glob to find files by pattern, don't read every file.
+
+## Output Format
+
+Return ONLY this JSON structure (no markdown code blocks):
+{
+  "generated_at": "ISO timestamp",
+  "services": {
+    "notifications": ["list of notification channels that exist"],
+    "api_endpoints": ["key endpoints for leads/lawyers/marketplace"],
+    "background_jobs": ["schedulers, cron, workers that exist"],
+    "integrations": ["external services: Loops, Whapi, PostHog, etc."]
+  },
+  "missing": ["notable gaps relevant to CRM/lawyer success"],
+  "file_counts": {
+    "frontend_components": 0,
+    "api_routes": 0,
+    "backend_routers": 0
+  }
+}`;
+
+  return new Promise((resolve) => {
+    const claude = spawn('claude', [
+      '--print',
+      '--dangerously-skip-permissions',
+      '--model', 'haiku',
+    ], {
+      cwd: config.repos[0].path,
+      env: process.env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    // Write prompt to stdin and close it
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+
+    let output = '';
+    const timeout = setTimeout(() => {
+      claude.kill('SIGTERM');
+      console.log('Snapshot generation timed out');
+      resolve();
+    }, 60000); // 60s timeout
+
+    claude.stdout.on('data', (data) => { output += data.toString(); });
+    claude.stderr.on('data', (data) => { process.stderr.write(data.toString()); });
+
+    claude.on('close', (code) => {
+      clearTimeout(timeout);
+      if (code === 0) {
+        try {
+          // Extract JSON from response
+          const jsonMatch = output.match(/\{[\s\S]*\}/);
+          if (jsonMatch) {
+            const snapshot = JSON.parse(jsonMatch[0]);
+            fs.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2));
+            console.log(`Codebase snapshot saved to ${snapshotPath}`);
+          }
+        } catch (error) {
+          console.log(`Failed to parse snapshot: ${error instanceof Error ? error.message : 'Unknown'}`);
+        }
+      }
+      resolve();
+    });
+
+    claude.on('error', () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+  });
+}
+
+// Main function
+async function main() {
+  const { type, topic, context } = parseArgs();
+  console.log(`\n=== AI Business Analyst - ${type.toUpperCase()} Analysis ===\n`);
+
+  if (type === 'research' && topic) {
+    console.log(`Research topic: ${topic}`);
+  }
+
+  // Load config
+  const config = loadConfig();
+  console.log(`Analyzing ${config.repos.length} repositories...`);
+
+  // Create session
+  const session = createSession(type, config.repos.map((r) => r.name));
+  console.log(`Session ID: ${session.id}`);
+
+  try {
+    // Generate prompt
+    const prompt = generatePrompt(type, config, topic, context);
+    addSessionLog(session.id, `Generated ${type} analysis prompt`);
+
+    // Set timeout based on analysis type (research needs more time)
+    const timeoutMs = type === 'research' ? 900000 : 600000; // 15 min for research, 10 min otherwise
+
+    // Run analysis
+    addSessionLog(session.id, 'Running Claude Code analysis...');
+    const response = await runClaudeAnalysis(prompt, config, timeoutMs);
+    addSessionLog(session.id, 'Analysis complete');
+
+    // Parse ideas from response
+    const newIdeas = parseIdeas(response, session.id);
+    addSessionLog(session.id, `Parsed ${newIdeas.length} ideas from response`);
+
+    if (newIdeas.length > 0) {
+      // Save ideas
+      const ideasData = loadIdeas();
+      ideasData.ideas.push(...newIdeas);
+      saveIdeas(ideasData);
+      addSessionLog(session.id, `Saved ${newIdeas.length} new ideas`);
+
+      // Auto-link ideas to hypotheses
+      linkIdeasToHypotheses(newIdeas);
+
+      // Update session
+      updateSession(session.id, {
+        status: 'completed',
+        completed_at: new Date().toISOString(),
+        ideas_generated: newIdeas.map((i) => i.id),
+      });
+
+      console.log(`\n=== Analysis Complete ===`);
+      console.log(`Generated ${newIdeas.length} new ideas:`);
+      newIdeas.forEach((idea, i) => {
+        console.log(`  ${i + 1}. [${idea.priority}] ${idea.title}`);
+      });
+    } else {
+      addSessionLog(session.id, 'No ideas generated');
+      updateSession(session.id, {
+        status: 'completed',
+        completed_at: new Date().toISOString(),
+      });
+    }
+
+    // Generate codebase snapshot after analysis (for heartbeat context)
+    await generateCodebaseSnapshot(config);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+    addSessionLog(session.id, `Error: ${errorMessage}`);
+    updateSession(session.id, {
+      status: 'failed',
+      completed_at: new Date().toISOString(),
+      error_message: errorMessage,
+    });
+    console.error('\n=== Analysis Failed ===');
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);