vibebusiness 1.2.11

package/dist/scripts/analyze.js

@@ -0,0 +1,1047 @@
+#!/usr/bin/env npx tsx
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// scripts/analyze.ts
+var import_child_process = require("child_process");
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// node_modules/uuid/dist/esm-node/rng.js
+var import_crypto = __toESM(require("crypto"));
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    import_crypto.default.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// node_modules/uuid/dist/esm-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+
+// node_modules/uuid/dist/esm-node/native.js
+var import_crypto2 = __toESM(require("crypto"));
+var native_default = {
+  randomUUID: import_crypto2.default.randomUUID
+};
+
+// node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/lib/prompts.ts
+var IDEA_SCHEMA = `
+Each idea must be a valid JSON object with these fields:
+{
+  "title": "string - Clear, actionable title (max 80 chars)",
+  "summary": "string - One sentence describing the improvement",
+  "category": "product | ux_design | growth | performance | tech_debt | security | infrastructure | content | analytics | integration",
+  "priority": "critical | high | medium | low",
+  "effort": "xs | s | m | l | xl",
+  "impact": "xs | s | m | l | xl",
+  "context": "string - What triggered this idea (observations, data)",
+  "rationale": "string - Why this matters for the business",
+  "implementation_plan": "string - Step-by-step implementation (markdown ok)",
+  "success_metrics": ["array of measurable outcomes"],
+  "tags": ["array of relevant tags"],
+  "files_analyzed": ["array of relevant file paths"],
+  "goal_id": "optional - ID of the business goal this idea supports (e.g., goal-001, goal-003)",
+  "hypothesis_id": "optional - ID of the business hypothesis this idea validates (e.g., hyp-001, hyp-003). Include when this idea is an experiment to test a hypothesis.",
+  "prerequisites": "optional - For growth/revenue/monetization ideas, specify conditions that must be met before this idea should proceed. Format: { description: string, funnel_stage: string, conditions: [{ kpi_id: string, operator: 'gte'|'lte', value: number, label: string }] }"
+}
+`;
+function buildBaseContext(businessConfig) {
+  if (!businessConfig) {
+    return `You are an AI Business Analyst.
+
+Your role is to analyze the codebase and generate actionable improvement ideas.`;
+  }
+  const { product } = businessConfig;
+  let architectureSection = "";
+  if (product.architecture && product.architecture.length > 0) {
+    const components = product.architecture.map((c, i) => {
+      const techLine = c.tech_stack.length > 0 ? `
+   Tech: ${c.tech_stack.join(", ")}` : "";
+      return `${i + 1}. **${c.name} (${c.repo_name})**: ${c.description}${techLine}`;
+    }).join("\n\n");
+    architectureSection = `
+
+The product consists of:
+${components}`;
+  }
+  return `You are an AI Business Analyst for ${product.name}, ${product.summary}.${architectureSection}
+
+Your role is to analyze the codebase and generate actionable improvement ideas.`;
+}
+function buildResearchProtocol(businessConfig) {
+  const competitors = businessConfig?.competitors?.join(", ") || "industry competitors";
+  let constraintsSection = "";
+  if (businessConfig?.key_constraints && businessConfig.key_constraints.length > 0) {
+    constraintsSection = `### Business Model Constraints
+${businessConfig.key_constraints.map((c) => `- ${c}`).join("\n")}
+`;
+  }
+  let regulatorySection = "";
+  if (businessConfig?.regulatory && businessConfig.regulatory.length > 0) {
+    regulatorySection = `
+### Regulatory & Compliance
+${businessConfig.regulatory.map((r) => `- ${r}`).join("\n")}
+`;
+  }
+  let funnelSection = "";
+  if (businessConfig?.funnel_stages?.stages) {
+    const stages = Object.entries(businessConfig.funnel_stages.stages);
+    if (stages.length > 0) {
+      const stageLines = stages.map(([key, stage]) => {
+        const thresholds = stage.healthy_thresholds || (stage.healthy_threshold ? [stage.healthy_threshold] : []);
+        const thresholdText = thresholds.map((t) => t.label).join(", ") || "no threshold defined";
+        return `- ${key.charAt(0).toUpperCase() + key.slice(1)}: ${stage.question} (${thresholdText})`;
+      }).join("\n");
+      funnelSection = `
+### Business Funnel Assessment (MANDATORY for growth/product/revenue ideas)
+Consider the business funnel before proposing ideas:
+${stageLines}
+If earlier stages are broken, propose fixes for THOSE stages. Include "prerequisites" on every growth/revenue idea that depends on a later funnel stage.
+`;
+    }
+  }
+  return `
+## Research Protocol
+
+Before generating ideas, conduct research to ground proposals in reality:
+
+### Codebase Verification (MANDATORY)
+For every idea, VERIFY using Glob and Grep that:
+- The feature/system you reference actually exists
+- You understand the current implementation before proposing changes
+- files_analyzed contains real paths you confirmed exist
+
+### Web Research
+Use WebSearch to research:
+- Industry best practices for the problem
+- How competitors solve similar problems (${competitors})
+${businessConfig?.product?.locale ? `- ${businessConfig.product.locale.startsWith("pt") ? "Brazil" : "local market"}-specific context (search in ${businessConfig.product.locale.startsWith("pt") ? "Portuguese" : "the local language"} when relevant)` : "- Market-specific context when relevant"}
+- Technology approaches with measurable outcomes
+
+${constraintsSection}${regulatorySection}
+### Monitoring & Observability (MANDATORY for every idea)
+
+success_metrics MUST be:
+- Quantifiable with baseline \u2192 target \u2192 timeline format
+- Verifiable via logs, metrics, or database queries
+- Include at least one monitoring metric (e.g., error rate, latency, delivery rate)
+
+implementation_plan MUST include a "Monitoring" step that specifies:
+- What to log (entry/exit of services, errors with context, data validation)
+- What metrics to track (latency, success rate, throughput)
+- Alert thresholds if applicable (e.g., "alert if error_rate > 5%")
+- How to verify the feature works post-deploy (health check, smoke test)
+
+BAD success_metrics (reject): "Improve response time", "Better UX"
+GOOD success_metrics: "Reduce avg response time from 86h to <8h within 2 weeks, verified via Firestore query on response_time field"
+${funnelSection}`;
+}
+function buildGoalsSection(goalsContext) {
+  if (!goalsContext) return "";
+  return `
+### Active Business Goals (WEIGHT ideas toward these)
+
+${goalsContext}
+
+When generating ideas, PREFER ideas that directly move a goal's KPIs. Include \`goal_id\` in the idea JSON if it aligns with a specific goal (e.g., "goal_id": "goal-003").
+`;
+}
+function buildHypothesesSection(hypothesesContext) {
+  if (!hypothesesContext) return "";
+  return `
+### Active Business Hypotheses (VALIDATE through experiments)
+
+${hypothesesContext}
+
+When generating ideas, PREFER ideas that validate or invalidate an active hypothesis. Set \`hypothesis_id\` in the idea JSON to the hypothesis ID (e.g., "hypothesis_id": "hyp-003"). The cheapest validation experiment for each hypothesis is the highest-priority idea.
+`;
+}
+function generateQuickAnalysisPrompt(options) {
+  const baseContext = buildBaseContext(options.businessConfig);
+  const researchProtocol = buildResearchProtocol(options.businessConfig);
+  const repoList = options.config.repos.map((r) => `- ${r.name}: ${r.path} (${r.type})`).join("\n");
+  return `${baseContext}
+
+## Quick Analysis Task
+
+Perform a quick scan of the codebase focusing on:
+- Recent changes (git log --oneline -20)
+- TODO/FIXME comments that need attention
+- Error handling gaps
+- Console.log statements left in production code
+- Obvious performance issues (N+1 queries, missing indexes)
+- Security quick wins (exposed secrets, missing validation)
+
+## Repositories to Analyze
+${repoList}
+
+## Analysis Steps
+
+1. For each repository:
+   a. Check recent git commits for patterns
+   b. Search for TODO, FIXME, HACK comments
+   c. Look for console.log/print statements in non-test files
+   d. Check for obvious security issues (hardcoded credentials, SQL injection patterns)
+
+2. Prioritize findings by business impact
+
+3. Generate up to ${options.maxIdeas} improvement ideas
+${researchProtocol}
+${buildGoalsSection(options.goalsContext)}
+${buildHypothesesSection(options.hypothesesContext)}
+## Output Format
+
+Return a JSON array of ideas:
+\`\`\`json
+[
+  ${IDEA_SCHEMA}
+]
+\`\`\`
+
+Only output the JSON array, no other text.
+`;
+}
+function generateDeepAnalysisPrompt(options) {
+  const baseContext = buildBaseContext(options.businessConfig);
+  const researchProtocol = buildResearchProtocol(options.businessConfig);
+  const repoList = options.config.repos.map((r) => `- ${r.name}: ${r.path} (${r.type})`).join("\n");
+  return `${baseContext}
+
+## Deep Analysis Task
+
+Perform a comprehensive review of the codebase focusing on:
+
+### Architecture & Design
+- Component organization and reusability
+- API design consistency
+- State management patterns
+- Error boundary coverage
+- Code duplication across modules
+
+### Tech Debt
+- Outdated dependencies
+- Deprecated API usage
+- Missing TypeScript types
+- Test coverage gaps
+- Documentation gaps
+
+### Security
+- Authentication/authorization patterns
+- Input validation completeness
+- XSS/CSRF protection
+- Rate limiting coverage
+- Secret management
+
+### Performance
+- Bundle size optimization opportunities
+- Database query optimization
+- Caching opportunities
+- Image optimization
+- Core Web Vitals issues
+
+### Scalability
+- Database schema design
+- API pagination patterns
+- Background job handling
+- Real-time sync architecture
+
+## Repositories to Analyze
+${repoList}
+
+## Analysis Steps
+
+1. Analyze the overall architecture of each repository
+2. Identify patterns and anti-patterns
+3. Look for opportunities to reduce complexity
+4. Find security vulnerabilities
+5. Identify performance bottlenecks
+6. Suggest architectural improvements
+${researchProtocol}
+${buildGoalsSection(options.goalsContext)}
+${buildHypothesesSection(options.hypothesesContext)}
+## Output Format
+
+Return a JSON array of up to ${options.maxIdeas} ideas:
+\`\`\`json
+[
+  ${IDEA_SCHEMA}
+]
+\`\`\`
+
+Only output the JSON array, no other text.
+`;
+}
+function generateMetricsAnalysisPrompt(options) {
+  const baseContext = buildBaseContext(options.businessConfig);
+  const researchProtocol = buildResearchProtocol(options.businessConfig);
+  return `${baseContext}
+
+## Metrics Analysis Task
+
+Analyze the application from a product metrics perspective:
+
+### Conversion Funnels
+- Landing page \u2192 Signup conversion paths
+- Lead capture \u2192 Qualification rates
+- Trial \u2192 Paid conversion
+
+### User Experience Flows
+- Onboarding completion rates
+- Feature adoption patterns
+- Drop-off points in key flows
+- Time-to-value for new users
+
+### Growth Opportunities
+- SEO content gaps
+- Referral mechanisms
+- Viral loops
+- Retention hooks
+
+### Revenue Optimization
+- Pricing page effectiveness
+- Upsell opportunities
+- Churn reduction tactics
+- LTV improvement ideas
+
+## Analysis Steps
+
+1. Map out all user flows in the application
+2. Identify potential conversion blockers
+3. Find opportunities to reduce friction
+4. Suggest A/B test ideas
+5. Propose new growth features
+${researchProtocol}
+${buildGoalsSection(options.goalsContext)}
+${buildHypothesesSection(options.hypothesesContext)}
+## Output Format
+
+Return a JSON array of up to ${options.maxIdeas} ideas:
+\`\`\`json
+[
+  ${IDEA_SCHEMA}
+]
+\`\`\`
+
+Only output the JSON array, no other text.
+`;
+}
+function generateSEOAnalysisPrompt(options) {
+  const baseContext = buildBaseContext(options.businessConfig);
+  const researchProtocol = buildResearchProtocol(options.businessConfig);
+  const locale = options.businessConfig?.product?.locale;
+  const localeSEOSection = locale?.startsWith("pt") ? `### Local SEO (Brazil focus)
+- Location-based pages
+- Portuguese language optimization
+- Local schema markup` : `### Local SEO
+- Location-based pages
+- Language optimization
+- Local schema markup`;
+  return `${baseContext}
+
+## SEO Analysis Task
+
+Analyze the application's SEO implementation:
+
+### Technical SEO
+- Meta tags and Open Graph implementation
+- Schema.org structured data
+- Sitemap completeness
+- Robots.txt configuration
+- Core Web Vitals
+- Mobile responsiveness
+- Canonical URLs
+
+### Content SEO
+- Blog post optimization
+- Keyword targeting
+- Internal linking structure
+- Content freshness
+- Content gaps vs competitors
+
+${localeSEOSection}
+
+### Link Building
+- Linkable asset opportunities
+- PR/outreach opportunities
+- Directory listings
+
+## Analysis Steps
+
+1. Audit all public-facing pages for SEO basics
+2. Review schema.org implementation
+3. Analyze blog content strategy
+4. Identify keyword opportunities
+5. Suggest technical improvements
+${researchProtocol}
+${buildGoalsSection(options.goalsContext)}
+${buildHypothesesSection(options.hypothesesContext)}
+## Output Format
+
+Return a JSON array of up to ${options.maxIdeas} ideas:
+\`\`\`json
+[
+  ${IDEA_SCHEMA}
+]
+\`\`\`
+
+Only output the JSON array, no other text.
+`;
+}
+function generateResearchPrompt(options) {
+  const baseContext = buildBaseContext(options.businessConfig);
+  const competitors = options.businessConfig?.competitors?.join(", ") || "industry competitors";
+  const constraints = options.businessConfig?.key_constraints || [];
+  const locale = options.businessConfig?.product?.locale;
+  const repoList = options.config.repos.map((r) => `- ${r.name}: ${r.path} (${r.type})`).join("\n");
+  let decodedContext = "";
+  if (options.context) {
+    try {
+      decodedContext = Buffer.from(options.context, "base64").toString("utf-8");
+    } catch {
+      decodedContext = options.context;
+    }
+  }
+  return `${baseContext}
+
+## Research Task: ${options.topic || "Deep Investigation"}
+
+You are conducting a focused research investigation. This is NOT a general codebase scan \u2014 you are investigating a SPECIFIC issue.
+
+${decodedContext ? `### Context from Heartbeat
+${decodedContext}
+
+` : ""}### Your Investigation Goal
+
+${options.topic ? `Investigate: **${options.topic}**` : "Conduct a deep investigation based on the context above."}
+
+### Research Protocol (CRITICAL)
+
+1. **Codebase Exploration (MANDATORY)**
+   - Use Glob to find relevant files by pattern
+   - Use Grep to search for specific implementations
+   - Use Read to understand existing code BEFORE proposing changes
+   - Document every file path you verify exists
+
+2. **Web Research (MANDATORY)**
+   - Use WebSearch to find industry best practices
+   - Search for how competitors (${competitors}) solve this
+${locale?.startsWith("pt") ? "   - Find Brazil-specific context when relevant (search in Portuguese)" : "   - Find market-specific context when relevant"}
+   - Look for measurable outcomes from similar implementations
+
+3. **Business Model Constraints (CRITICAL)**
+${constraints.length > 0 ? constraints.map((c) => `   - ${c}`).join("\n") : "   - Review business constraints before proposing changes"}
+
+### Repositories Available
+${repoList}
+${buildGoalsSection(options.goalsContext)}
+${buildHypothesesSection(options.hypothesesContext)}
+### Output Requirements
+
+Generate exactly 1 deeply-researched idea based on your investigation.
+
+The idea MUST include:
+- **files_analyzed**: Real paths you verified exist
+- **context**: Specific observations from code + web research
+- **implementation_plan**: Grounded in what you found in the codebase
+
+## Output Format
+
+Return a JSON array with a single idea:
+\`\`\`json
+[
+  ${IDEA_SCHEMA}
+]
+\`\`\`
+
+Only output the JSON array, no other text.
+`;
+}
+function getAnalysisPrompt(options) {
+  switch (options.type) {
+    case "quick":
+      return generateQuickAnalysisPrompt(options);
+    case "deep":
+      return generateDeepAnalysisPrompt(options);
+    case "metrics":
+      return generateMetricsAnalysisPrompt(options);
+    case "seo":
+      return generateSEOAnalysisPrompt(options);
+    case "research":
+      return generateResearchPrompt(options);
+    default:
+      return generateQuickAnalysisPrompt(options);
+  }
+}
+
+// scripts/lib/paths.ts
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+function findProjectRoot() {
+  const cwd = process.cwd();
+  if (fs.existsSync(path.join(cwd, "data", "config.json"))) {
+    return cwd;
+  }
+  try {
+    const entries = fs.readdirSync(cwd, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const candidate = path.join(cwd, entry.name, "data", "config.json");
+        if (fs.existsSync(candidate)) {
+          return path.join(cwd, entry.name);
+        }
+      }
+    }
+  } catch {
+  }
+  let dir = cwd;
+  for (let i = 0; i < 5; i++) {
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    if (fs.existsSync(path.join(parent, "data", "config.json"))) {
+      return parent;
+    }
+    dir = parent;
+  }
+  return cwd;
+}
+var PROJECT_DIR = findProjectRoot();
+var DATA_DIR = path.join(PROJECT_DIR, "data");
+var STATUS_FILE = path.join(PROJECT_DIR, "STATUS.md");
+var TODO_FILE = path.join(PROJECT_DIR, "TODO.md");
+var MEMORY_FILE = path.join(PROJECT_DIR, "MEMORY.md");
+var IDEAS_FILE = path.join(DATA_DIR, "ideas.json");
+var GOALS_FILE = path.join(DATA_DIR, "goals.json");
+var SESSIONS_FILE = path.join(DATA_DIR, "sessions.json");
+var CONFIG_FILE = path.join(DATA_DIR, "config.json");
+var BUSINESS_CONTEXT_FILE = path.join(DATA_DIR, "business-context.json");
+var HYPOTHESES_FILE = path.join(DATA_DIR, "hypotheses.json");
+var IMPLEMENTATIONS_FILE = path.join(DATA_DIR, "implementations.json");
+var COMPETITORS_FILE = path.join(DATA_DIR, "competitors.json");
+var POSITIONING_FILE = path.join(DATA_DIR, "positioning.json");
+var PAGES_FILE = path.join(DATA_DIR, "pages.json");
+var TEMPLATES_DIR = path.join(__dirname, "..", "..", "templates");
+var COMMAND_TEMPLATES_DIR = path.join(TEMPLATES_DIR, "commands");
+
+// scripts/analyze.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let type = "quick";
+  let topic;
+  let context;
+  for (const arg of args) {
+    if (arg.startsWith("--type=")) {
+      const value = arg.split("=")[1];
+      if (["quick", "deep", "metrics", "seo", "research"].includes(value)) {
+        type = value;
+      }
+    } else if (arg.startsWith("--topic=")) {
+      topic = arg.split("=").slice(1).join("=");
+    } else if (arg.startsWith("--context=")) {
+      context = arg.split("=").slice(1).join("=");
+    }
+  }
+  return { type, topic, context };
+}
+function loadConfig() {
+  if (!fs2.existsSync(CONFIG_FILE)) {
+    throw new Error("Config file not found. Please ensure data/config.json exists.");
+  }
+  return JSON.parse(fs2.readFileSync(CONFIG_FILE, "utf-8"));
+}
+function loadBusinessContext() {
+  if (!fs2.existsSync(BUSINESS_CONTEXT_FILE)) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(fs2.readFileSync(BUSINESS_CONTEXT_FILE, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function loadIdeas() {
+  if (!fs2.existsSync(IDEAS_FILE)) {
+    return { ideas: [] };
+  }
+  return JSON.parse(fs2.readFileSync(IDEAS_FILE, "utf-8"));
+}
+function saveIdeas(data) {
+  fs2.writeFileSync(IDEAS_FILE, JSON.stringify(data, null, 2));
+}
+function loadSessions() {
+  if (!fs2.existsSync(SESSIONS_FILE)) {
+    return { sessions: [] };
+  }
+  return JSON.parse(fs2.readFileSync(SESSIONS_FILE, "utf-8"));
+}
+function saveSessions(data) {
+  fs2.writeFileSync(SESSIONS_FILE, JSON.stringify(data, null, 2));
+}
+function cleanupStuckSessions() {
+  const sessions = loadSessions();
+  const now = /* @__PURE__ */ new Date();
+  const STUCK_THRESHOLD_MS = 30 * 60 * 1e3;
+  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 / 6e4)} 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 / 6e4)} min)`);
+      }
+    }
+  }
+  if (cleanedCount > 0) {
+    saveSessions(sessions);
+  }
+  return cleanedCount;
+}
+function createSession(type, repos) {
+  cleanupStuckSessions();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const session = {
+    id: `session-${v4_default().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;
+}
+function updateSession(sessionId, updates) {
+  const sessions = loadSessions();
+  const index = sessions.sessions.findIndex((s) => s.id === sessionId);
+  if (index !== -1) {
+    sessions.sessions[index] = { ...sessions.sessions[index], ...updates };
+    saveSessions(sessions);
+  }
+}
+function addSessionLog(sessionId, message) {
+  const sessions = loadSessions();
+  const index = sessions.sessions.findIndex((s) => s.id === sessionId);
+  if (index !== -1) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    sessions.sessions[index].logs.push(`[${timestamp}] ${message}`);
+    saveSessions(sessions);
+  }
+  console.log(message);
+}
+function loadGoalsContext() {
+  try {
+    if (!fs2.existsSync(GOALS_FILE)) return "";
+    const goalsData = JSON.parse(fs2.readFileSync(GOALS_FILE, "utf-8"));
+    const goals = goalsData.goals || [];
+    if (goals.length === 0) return "";
+    return goals.map((g) => {
+      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}** \u2014 Status: ${g.status}, Progress: ${g.current_value ?? 0} / ${g.target_value} ${g.target_unit}, Deadline: ${g.deadline}
+${kpiLines}`;
+    }).join("\n\n");
+  } catch {
+    return "";
+  }
+}
+function linkIdeasToHypotheses(ideas) {
+  const ideasWithHypothesis = ideas.filter((i) => i.hypothesis_id);
+  if (ideasWithHypothesis.length === 0) return;
+  try {
+    if (!fs2.existsSync(HYPOTHESES_FILE)) return;
+    const data = JSON.parse(fs2.readFileSync(HYPOTHESES_FILE, "utf-8"));
+    const hypotheses = data.hypotheses || [];
+    let changed = false;
+    for (const idea of ideasWithHypothesis) {
+      const hypIndex = hypotheses.findIndex(
+        (h) => 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 = (/* @__PURE__ */ new Date()).toISOString();
+        changed = true;
+      }
+    }
+    if (changed) {
+      fs2.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);
+  }
+}
+function loadHypothesesContext() {
+  try {
+    if (!fs2.existsSync(HYPOTHESES_FILE)) return "";
+    const data = JSON.parse(fs2.readFileSync(HYPOTHESES_FILE, "utf-8"));
+    const hypotheses = data.hypotheses || [];
+    if (hypotheses.length === 0) return "";
+    return hypotheses.filter((h) => h.status === "stated" || h.status === "testing").map(
+      (h) => `**${h.id}: ${h.title}** [${h.funnel_stage}] \u2014 Status: ${h.status}, Priority: ${h.priority}, Effort: ${h.effort_to_test}
+  Statement: ${h.statement}`
+    ).join("\n\n");
+  } catch {
+    return "";
+  }
+}
+function generatePrompt(type, config, topic, context) {
+  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 || void 0,
+    hypothesesContext: hypothesesContext || void 0,
+    businessConfig
+  });
+}
+function parseIdeas(response, sessionId) {
+  const jsonMatch = response.match(/\[\s*\{[\s\S]*\}\s*\]/);
+  if (!jsonMatch) {
+    console.error("No JSON array found in response");
+    return [];
+  }
+  try {
+    const rawIdeas = JSON.parse(jsonMatch[0]);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return rawIdeas.map((idea) => ({
+      id: `idea-${v4_default().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 [];
+  }
+}
+async function runClaudeAnalysis(prompt, config, timeoutMs = 6e5) {
+  return new Promise((resolve, reject) => {
+    const repoPaths = config.repos.map((r) => r.path);
+    const workDir = repoPaths[0];
+    console.log("Starting Claude Code analysis...");
+    console.log(`Working directory: ${workDir}`);
+    console.log(`Timeout: ${timeoutMs / 1e3}s`);
+    const tempPromptFile = path2.join(DATA_DIR, ".analysis-prompt.txt");
+    fs2.writeFileSync(tempPromptFile, prompt);
+    const claude = (0, import_child_process.spawn)("claude", [
+      "--print",
+      "--dangerously-skip-permissions"
+    ], {
+      cwd: workDir,
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+    let output = "";
+    let errorOutput = "";
+    let isResolved = false;
+    const startTime = Date.now();
+    const progressInterval = setInterval(() => {
+      if (!isResolved) {
+        const elapsed = Math.round((Date.now() - startTime) / 1e3);
+        const outputLen = output.length;
+        console.log(`  ...Claude Code working (${elapsed}s elapsed, ${outputLen} chars output)`);
+      }
+    }, 3e4);
+    const timeout = setTimeout(() => {
+      if (!isResolved) {
+        isResolved = true;
+        clearInterval(progressInterval);
+        claude.kill("SIGTERM");
+        setTimeout(() => {
+          try {
+            claude.kill("SIGKILL");
+          } catch {
+          }
+        }, 5e3);
+        try {
+          fs2.unlinkSync(tempPromptFile);
+        } catch {
+        }
+        const elapsed = Math.round((Date.now() - startTime) / 1e3);
+        reject(new Error(`Claude Code timed out after ${elapsed}s (limit: ${timeoutMs / 1e3}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;
+      isResolved = true;
+      clearInterval(progressInterval);
+      clearTimeout(timeout);
+      try {
+        fs2.unlinkSync(tempPromptFile);
+      } catch {
+      }
+      const elapsed = Math.round((Date.now() - startTime) / 1e3);
+      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 {
+        fs2.unlinkSync(tempPromptFile);
+      } catch {
+      }
+      reject(error);
+    });
+  });
+}
+async function generateCodebaseSnapshot(config) {
+  const snapshotPath = path2.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 \u2014 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 = (0, import_child_process.spawn)("claude", [
+      "--print",
+      "--dangerously-skip-permissions",
+      "--model",
+      "haiku"
+    ], {
+      cwd: config.repos[0].path,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+    let output = "";
+    const timeout = setTimeout(() => {
+      claude.kill("SIGTERM");
+      console.log("Snapshot generation timed out");
+      resolve();
+    }, 6e4);
+    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 {
+          const jsonMatch = output.match(/\{[\s\S]*\}/);
+          if (jsonMatch) {
+            const snapshot = JSON.parse(jsonMatch[0]);
+            fs2.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();
+    });
+  });
+}
+async function main() {
+  const { type, topic, context } = parseArgs();
+  console.log(`
+=== AI Business Analyst - ${type.toUpperCase()} Analysis ===
+`);
+  if (type === "research" && topic) {
+    console.log(`Research topic: ${topic}`);
+  }
+  const config = loadConfig();
+  console.log(`Analyzing ${config.repos.length} repositories...`);
+  const session = createSession(type, config.repos.map((r) => r.name));
+  console.log(`Session ID: ${session.id}`);
+  try {
+    const prompt = generatePrompt(type, config, topic, context);
+    addSessionLog(session.id, `Generated ${type} analysis prompt`);
+    const timeoutMs = type === "research" ? 9e5 : 6e5;
+    addSessionLog(session.id, "Running Claude Code analysis...");
+    const response = await runClaudeAnalysis(prompt, config, timeoutMs);
+    addSessionLog(session.id, "Analysis complete");
+    const newIdeas = parseIdeas(response, session.id);
+    addSessionLog(session.id, `Parsed ${newIdeas.length} ideas from response`);
+    if (newIdeas.length > 0) {
+      const ideasData = loadIdeas();
+      ideasData.ideas.push(...newIdeas);
+      saveIdeas(ideasData);
+      addSessionLog(session.id, `Saved ${newIdeas.length} new ideas`);
+      linkIdeasToHypotheses(newIdeas);
+      updateSession(session.id, {
+        status: "completed",
+        completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+        ideas_generated: newIdeas.map((i) => i.id)
+      });
+      console.log(`
+=== 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: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    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: (/* @__PURE__ */ new Date()).toISOString(),
+      error_message: errorMessage
+    });
+    console.error("\n=== Analysis Failed ===");
+    console.error(error);
+    process.exit(1);
+  }
+}
+main().catch(console.error);