vibebusiness 1.2.89 → 1.2.91

package/dist/scripts/analyze.js

@@ -103,7 +103,7 @@ var require_package = __commonJS({
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
     "use strict";
-    var fs5 = require("fs");
+    var fs7 = require("fs");
     var path4 = require("path");
     var os = require("os");
     var crypto3 = require("crypto");
@@ -242,7 +242,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs5.existsSync(filepath)) {
+            if (fs7.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -252,7 +252,7 @@ var require_main = __commonJS({
       } else {
         possibleVaultPath = path4.resolve(process.cwd(), ".env.vault");
       }
-      if (fs5.existsSync(possibleVaultPath)) {
+      if (fs7.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
@@ -305,7 +305,7 @@ var require_main = __commonJS({
       const parsedAll = {};
       for (const path5 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs5.readFileSync(path5, { encoding }));
+          const parsed = DotenvModule.parse(fs7.readFileSync(path5, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e) {
           if (debug) {
@@ -494,7 +494,7 @@ module.exports = __toCommonJS(analyze_exports);
 
 // scripts/analyze.ts
 var import_child_process2 = require("child_process");
-var fs4 = __toESM(require("fs"));
+var fs6 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
 
 // node_modules/uuid/dist/esm-node/rng.js
@@ -1241,8 +1241,198 @@ function detectBYOKKeys() {
   }
   return null;
 }
+function detectProvider(config) {
+  const cli = detectClaudeCLI(config?.claudePath);
+  if (cli.found) {
+    return {
+      provider: "claude-cli",
+      version: cli.version,
+      message: `Found Claude Code CLI${cli.version ? ` (${cli.version})` : ""}. Using your Claude subscription for AI reasoning.`
+    };
+  }
+  const byok = detectBYOKKeys();
+  if (byok) {
+    const providerNames = {
+      "claude-cli": "Claude CLI",
+      "anthropic-api": "Anthropic API",
+      "openai-api": "OpenAI API",
+      "google-api": "Google AI API"
+    };
+    return {
+      provider: byok.provider,
+      message: `Using ${providerNames[byok.provider]} key for AI reasoning.`
+    };
+  }
+  return {
+    provider: "claude-cli",
+    // default, will fail at invocation
+    message: "No AI provider found. Install Claude Code CLI or set an API key (ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY)."
+  };
+}
 var CONFIG_DIR = path.join(process.env.HOME || "", ".ai-analyst");
 var PROVIDER_CONFIG_FILE = path.join(CONFIG_DIR, "provider.json");
+function loadProviderConfig() {
+  try {
+    if (fs2.existsSync(PROVIDER_CONFIG_FILE)) {
+      return JSON.parse(fs2.readFileSync(PROVIDER_CONFIG_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function invokeClaudeCLI(options, claudePath) {
+  const bin = claudePath || "claude";
+  const args = ["--print"];
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.jsonSchema) {
+    args.push("--output-format", "json", "--json-schema", JSON.stringify(options.jsonSchema));
+  }
+  if (options.claudeFlags) {
+    args.push(...options.claudeFlags);
+  }
+  const useStdin = options.useStdin !== false && options.prompt.length > 1e4;
+  if (!useStdin) {
+    args.push("-p", options.prompt);
+  }
+  const startTime = Date.now();
+  const timeoutMs = options.timeoutMs || 3e5;
+  return new Promise((resolve) => {
+    const child = (0, import_child_process.spawn)(bin, args, {
+      cwd: options.cwd || process.cwd(),
+      env: process.env,
+      stdio: useStdin ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    if (useStdin && child.stdin) {
+      child.stdin.write(options.prompt);
+      child.stdin.end();
+    }
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      resolve({
+        output: stdout,
+        provider: "claude-cli",
+        durationMs: Date.now() - startTime,
+        error: `Timeout after ${timeoutMs}ms`
+      });
+    }, timeoutMs);
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      resolve({
+        output: stdout.trim(),
+        provider: "claude-cli",
+        durationMs: Date.now() - startTime,
+        error: code !== 0 ? `Claude CLI exited with code ${code}: ${stderr}` : void 0
+      });
+    });
+    child.on("error", (err) => {
+      clearTimeout(timeout);
+      resolve({
+        output: "",
+        provider: "claude-cli",
+        durationMs: Date.now() - startTime,
+        error: `Failed to spawn Claude CLI: ${err.message}`
+      });
+    });
+  });
+}
+async function invokeAnthropicAPI(options) {
+  const startTime = Date.now();
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    return {
+      output: "",
+      provider: "anthropic-api",
+      durationMs: 0,
+      error: "ANTHROPIC_API_KEY not set"
+    };
+  }
+  try {
+    const model = options.model || "claude-sonnet-4-6";
+    let prompt = options.prompt;
+    if (options.jsonSchema) {
+      prompt += `
+
+IMPORTANT: Respond with valid JSON matching this schema:
+${JSON.stringify(options.jsonSchema, null, 2)}
+
+Output ONLY the JSON object, no markdown code blocks or other text.`;
+    } else if (options.expectJson) {
+      prompt += "\n\nIMPORTANT: Respond with valid JSON only. No markdown code blocks or other text.";
+    }
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 16384,
+        messages: [{ role: "user", content: prompt }]
+      }),
+      signal: AbortSignal.timeout(options.timeoutMs || 3e5)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      return {
+        output: "",
+        provider: "anthropic-api",
+        durationMs: Date.now() - startTime,
+        error: `Anthropic API error ${response.status}: ${errorText}`
+      };
+    }
+    const data = await response.json();
+    const text = data.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+    return {
+      output: text,
+      provider: "anthropic-api",
+      durationMs: Date.now() - startTime
+    };
+  } catch (err) {
+    return {
+      output: "",
+      provider: "anthropic-api",
+      durationMs: Date.now() - startTime,
+      error: `Anthropic API call failed: ${err.message}`
+    };
+  }
+}
+async function invokeAI(options) {
+  const savedConfig = loadProviderConfig();
+  const detection = detectProvider(savedConfig || void 0);
+  switch (detection.provider) {
+    case "claude-cli":
+      return invokeClaudeCLI(options, savedConfig?.claudePath);
+    case "anthropic-api":
+      return invokeAnthropicAPI(options);
+    case "openai-api":
+    case "google-api":
+      return {
+        output: "",
+        provider: detection.provider,
+        durationMs: 0,
+        error: `${detection.provider} provider not yet implemented. Use Claude CLI or set ANTHROPIC_API_KEY.`
+      };
+    default:
+      return {
+        output: "",
+        provider: "claude-cli",
+        durationMs: 0,
+        error: detection.message
+      };
+  }
+}
 function requireClaudeCLI(feature) {
   const cli = detectClaudeCLI();
   if (cli.found) {
@@ -1265,6 +1455,291 @@ Or set an API key: export ANTHROPIC_API_KEY=sk-ant-...`
   );
 }
 
+// scripts/lib/vision/define.ts
+var fs4 = __toESM(require("fs"));
+
+// scripts/lib/paths.ts
+var path2 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+function findProjectRoot() {
+  const cwd = process.cwd();
+  if (fs3.existsSync(path2.join(cwd, "data", "config.json"))) {
+    return cwd;
+  }
+  try {
+    const entries = fs3.readdirSync(cwd, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const candidate = path2.join(cwd, entry.name, "data", "config.json");
+        if (fs3.existsSync(candidate)) {
+          return path2.join(cwd, entry.name);
+        }
+      }
+    }
+  } catch {
+  }
+  let dir = cwd;
+  for (let i = 0; i < 5; i++) {
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    if (fs3.existsSync(path2.join(parent, "data", "config.json"))) {
+      return parent;
+    }
+    dir = parent;
+  }
+  return cwd;
+}
+var PROJECT_DIR = findProjectRoot();
+var DATA_DIR = path2.join(PROJECT_DIR, "data");
+var STATUS_FILE = path2.join(PROJECT_DIR, "STATUS.md");
+var TODO_FILE = path2.join(PROJECT_DIR, "TODO.md");
+var MEMORY_FILE = path2.join(PROJECT_DIR, "MEMORY.md");
+var IDEAS_FILE = path2.join(DATA_DIR, "ideas.json");
+var GOALS_FILE = path2.join(DATA_DIR, "goals.json");
+var SESSIONS_FILE = path2.join(DATA_DIR, "sessions.json");
+var CONFIG_FILE = path2.join(DATA_DIR, "config.json");
+var BUSINESS_CONTEXT_FILE = path2.join(DATA_DIR, "business-context.json");
+var HYPOTHESES_FILE = path2.join(DATA_DIR, "hypotheses.json");
+var IMPLEMENTATIONS_FILE = path2.join(DATA_DIR, "implementations.json");
+var ROADMAP_FILE = path2.join(DATA_DIR, "roadmap.json");
+var PRODUCT_VISION_FILE = path2.join(DATA_DIR, "product-vision.json");
+var COMPETITORS_FILE = path2.join(DATA_DIR, "competitors.json");
+var POSITIONING_FILE = path2.join(DATA_DIR, "positioning.json");
+var PAGES_FILE = path2.join(DATA_DIR, "pages.json");
+var PAYMENTS_FILE = path2.join(DATA_DIR, "payments.json");
+var POSTHOG_FILE = path2.join(DATA_DIR, "posthog.json");
+var SOCIAL_FILE = path2.join(DATA_DIR, "social.json");
+var MARKETING_STRATEGIES_FILE = path2.join(DATA_DIR, "marketing-strategies.json");
+var CAMPAIGNS_DIR = path2.join(DATA_DIR, "campaigns");
+var TEMPLATES_DIR = path2.join(__dirname, "..", "..", "templates");
+var COMMAND_TEMPLATES_DIR = path2.join(TEMPLATES_DIR, "commands");
+
+// scripts/lib/vision/define.ts
+var PROJECT_DIR2 = PRODUCT_VISION_FILE.replace(/\/data\/product-vision\.json$/, "");
+function loadJson(filePath, defaultValue) {
+  try {
+    if (!fs4.existsSync(filePath)) return defaultValue;
+    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+  } catch {
+    return defaultValue;
+  }
+}
+function saveJson(filePath, data) {
+  fs4.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+function loadProductVision() {
+  if (!fs4.existsSync(PRODUCT_VISION_FILE)) return null;
+  try {
+    return JSON.parse(fs4.readFileSync(PRODUCT_VISION_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function generateProductVision() {
+  const positioning = loadJson(POSITIONING_FILE, null);
+  const businessContext = loadJson(BUSINESS_CONTEXT_FILE, null);
+  const competitors = loadJson(COMPETITORS_FILE, null);
+  const existingVision = loadProductVision();
+  const prompt = buildVisionPrompt(positioning, businessContext, competitors, existingVision);
+  const aiResult = await invokeAI({
+    prompt,
+    cwd: PROJECT_DIR2,
+    timeoutMs: 18e4,
+    useStdin: true,
+    expectJson: true
+  });
+  if (aiResult.error || !aiResult.output.trim()) {
+    console.error(`Vision generation failed: ${aiResult.error || "empty output"}`);
+    return null;
+  }
+  let vision = null;
+  try {
+    const raw = aiResult.output.trim();
+    const jsonMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const jsonStr = jsonMatch ? jsonMatch[1].trim() : raw;
+    vision = JSON.parse(jsonStr);
+  } catch {
+    console.error("Failed to parse vision JSON from AI output");
+    return null;
+  }
+  vision.last_updated = (/* @__PURE__ */ new Date()).toISOString();
+  vision.version = existingVision ? (existingVision.version || 0) + 1 : 1;
+  saveJson(PRODUCT_VISION_FILE, vision);
+  return vision;
+}
+async function deriveHypothesesFromVision(vision) {
+  const prompt = `You are a product strategist. Given this product vision, derive 5-8 testable business hypotheses.
+
+PRODUCT VISION:
+- One-liner: ${vision.one_liner}
+- Focus metric: ${vision.focus_metric}
+- Best-fit customers: ${vision.obviously_awesome.best_fit_customers.primary}
+- Value delivered: ${vision.obviously_awesome.value_delivered.join(", ")}
+- Problem (external): ${vision.storybrand.problem.external}
+- Problem (internal): ${vision.storybrand.problem.internal}
+- Success transformation: ${vision.storybrand.success.transformation}
+- Anti-goals: ${vision.anti_goals.join(", ")}
+
+Each hypothesis should be:
+- Specific and falsifiable ("If we build X, then Y will happen")
+- Tied to a funnel stage (acquisition, engagement, conversion, monetization)
+- Have clear validation criteria
+
+Respond with JSON only (no markdown):
+[
+  {
+    "title": "Short title",
+    "statement": "If we [action], then [outcome] because [reason]",
+    "description": "Detailed explanation",
+    "funnel_stage": "acquisition|engagement|conversion|monetization",
+    "priority": "critical|high|medium|low",
+    "effort_to_test": "xs|s|m|l|xl",
+    "validation_criteria": ["criteria 1", "criteria 2"]
+  }
+]`;
+  const aiResult = await invokeAI({
+    prompt,
+    cwd: PROJECT_DIR2,
+    timeoutMs: 12e4,
+    useStdin: true,
+    expectJson: true
+  });
+  if (aiResult.error || !aiResult.output.trim()) {
+    console.error(`Hypothesis derivation failed: ${aiResult.error || "empty output"}`);
+    return [];
+  }
+  try {
+    const raw = aiResult.output.trim();
+    const jsonMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const jsonStr = jsonMatch ? jsonMatch[1].trim() : raw;
+    return JSON.parse(jsonStr);
+  } catch {
+    console.error("Failed to parse hypotheses JSON");
+    return [];
+  }
+}
+function buildVisionPrompt(positioning, businessContext, competitors, existingVision) {
+  const sections = [];
+  sections.push(`You are a product strategist. Generate a structured product vision using two proven frameworks:
+
+1. **Obviously Awesome** (April Dunford) \u2014 5-step positioning:
+   - Competitive alternatives: What would customers do if you didn't exist?
+   - Unique attributes: What capabilities do you have that alternatives lack?
+   - Value: What value do those attributes enable?
+   - Best-fit customers: Who cares most about that value?
+   - Market category: What context makes your value obvious?
+
+2. **StoryBrand** (Donald Miller) \u2014 7-part narrative:
+   - Character: The customer \u2014 who are they, what do they want?
+   - Problem: External (tangible), Internal (emotional), Philosophical (why it matters)
+   - Guide: You \u2014 empathy + authority
+   - Plan: 3 simple steps to succeed
+   - Call to Action: Direct CTA + transitional CTA
+   - Failure: What happens if they don't act
+   - Success: The transformation (before \u2192 after)`);
+  if (businessContext) {
+    sections.push(`
+BUSINESS CONTEXT:
+Product: ${businessContext.product?.name || "Unknown"} \u2014 ${businessContext.product?.summary || ""}
+Funnels: ${JSON.stringify(businessContext.funnels?.map((f) => ({ name: f.name, status: f.status })) || [])}
+Monetization: MRR ${businessContext.monetization?.current_mrr || 0}, ${businessContext.monetization?.paying_lawyers || 0} paying customers
+Key constraints: ${businessContext.key_constraints?.join(", ") || "none"}`);
+  }
+  if (positioning) {
+    sections.push(`
+EXISTING POSITIONING:
+Tagline: ${positioning.current?.tagline || "none"}
+Value prop: ${positioning.current?.value_proposition || "none"}
+Target audience: ${JSON.stringify(positioning.current?.target_audience || {})}
+Differentiators: ${positioning.current?.differentiators?.join(", ") || "none"}`);
+  }
+  if (competitors?.competitors?.length) {
+    const topCompetitors = competitors.competitors.slice(0, 5);
+    sections.push(`
+COMPETITORS:
+${topCompetitors.map((c) => `- ${c.name}: ${c.positioning?.value_proposition || "unknown"}`).join("\n")}`);
+  }
+  if (existingVision) {
+    sections.push(`
+EXISTING VISION (v${existingVision.version}, refresh this):
+One-liner: ${existingVision.one_liner}
+Focus metric: ${existingVision.focus_metric}`);
+  }
+  sections.push(`
+Respond with JSON only (no markdown code blocks, just raw JSON):
+{
+  "last_updated": "${(/* @__PURE__ */ new Date()).toISOString()}",
+  "version": ${existingVision ? (existingVision.version || 0) + 1 : 1},
+  "obviously_awesome": {
+    "competitive_alternatives": ["alt1", "alt2", ...],
+    "unique_attributes": ["attr1", "attr2", ...],
+    "value_delivered": ["value1", "value2", ...],
+    "best_fit_customers": { "primary": "...", "characteristics": ["...", "..."] },
+    "market_category": "...",
+    "positioning_statement": "..."
+  },
+  "storybrand": {
+    "character": { "identity": "...", "desire": "..." },
+    "problem": { "external": "...", "internal": "...", "philosophical": "..." },
+    "guide": { "empathy": "...", "authority": "..." },
+    "plan": ["step 1", "step 2", "step 3"],
+    "call_to_action": { "direct": "...", "transitional": "..." },
+    "failure": "...",
+    "success": { "transformation": "...", "before": "...", "after": "..." }
+  },
+  "one_liner": "For [best_fit_customers] who [problem], [product] is the [category] that [value]. Unlike [alternatives], we [unique_attributes].",
+  "focus_metric": "The ONE metric that proves this vision is working",
+  "anti_goals": ["Things we explicitly will NOT build"]
+}`);
+  return sections.join("\n");
+}
+
+// scripts/lib/vision/hypotheses.ts
+var fs5 = __toESM(require("fs"));
+function loadJson2(filePath, defaultValue) {
+  try {
+    if (!fs5.existsSync(filePath)) return defaultValue;
+    return JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+  } catch {
+    return defaultValue;
+  }
+}
+function saveJson2(filePath, data) {
+  fs5.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+async function seedHypothesesFromVision(vision) {
+  const v = vision || loadProductVision();
+  if (!v) {
+    console.error("No product vision found. Run /vision first.");
+    return [];
+  }
+  const derived = await deriveHypothesesFromVision(v);
+  if (derived.length === 0) return [];
+  const store = loadJson2(HYPOTHESES_FILE, { hypotheses: [] });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newHypotheses = derived.map((h, i) => ({
+    id: `hyp-vision-${Date.now().toString(36)}-${i}`,
+    created_at: now,
+    updated_at: now,
+    title: h.title,
+    statement: h.statement,
+    description: h.description,
+    funnel_stage: h.funnel_stage,
+    priority: h.priority || "medium",
+    status: "stated",
+    evidence_for: [],
+    evidence_against: [],
+    validation_criteria: h.validation_criteria || [],
+    validation_ideas: [],
+    reference_model: "product-vision",
+    effort_to_test: h.effort_to_test || "m",
+    tags: ["vision-derived"]
+  }));
+  store.hypotheses.push(...newHypotheses);
+  saveJson2(HYPOTHESES_FILE, store);
+  return newHypotheses;
+}
+
 // scripts/lib/logger.ts
 function logError(context, error) {
   const entry = {
@@ -1585,59 +2060,6 @@ function formatValueSummary(ideas, analysisType, durationSeconds, repoName) {
   }
 }
 
-// scripts/lib/paths.ts
-var path2 = __toESM(require("path"));
-var fs3 = __toESM(require("fs"));
-function findProjectRoot() {
-  const cwd = process.cwd();
-  if (fs3.existsSync(path2.join(cwd, "data", "config.json"))) {
-    return cwd;
-  }
-  try {
-    const entries = fs3.readdirSync(cwd, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const candidate = path2.join(cwd, entry.name, "data", "config.json");
-        if (fs3.existsSync(candidate)) {
-          return path2.join(cwd, entry.name);
-        }
-      }
-    }
-  } catch {
-  }
-  let dir = cwd;
-  for (let i = 0; i < 5; i++) {
-    const parent = path2.dirname(dir);
-    if (parent === dir) break;
-    if (fs3.existsSync(path2.join(parent, "data", "config.json"))) {
-      return parent;
-    }
-    dir = parent;
-  }
-  return cwd;
-}
-var PROJECT_DIR = findProjectRoot();
-var DATA_DIR = path2.join(PROJECT_DIR, "data");
-var STATUS_FILE = path2.join(PROJECT_DIR, "STATUS.md");
-var TODO_FILE = path2.join(PROJECT_DIR, "TODO.md");
-var MEMORY_FILE = path2.join(PROJECT_DIR, "MEMORY.md");
-var IDEAS_FILE = path2.join(DATA_DIR, "ideas.json");
-var GOALS_FILE = path2.join(DATA_DIR, "goals.json");
-var SESSIONS_FILE = path2.join(DATA_DIR, "sessions.json");
-var CONFIG_FILE = path2.join(DATA_DIR, "config.json");
-var BUSINESS_CONTEXT_FILE = path2.join(DATA_DIR, "business-context.json");
-var HYPOTHESES_FILE = path2.join(DATA_DIR, "hypotheses.json");
-var IMPLEMENTATIONS_FILE = path2.join(DATA_DIR, "implementations.json");
-var ROADMAP_FILE = path2.join(DATA_DIR, "roadmap.json");
-var COMPETITORS_FILE = path2.join(DATA_DIR, "competitors.json");
-var POSITIONING_FILE = path2.join(DATA_DIR, "positioning.json");
-var PAGES_FILE = path2.join(DATA_DIR, "pages.json");
-var PAYMENTS_FILE = path2.join(DATA_DIR, "payments.json");
-var POSTHOG_FILE = path2.join(DATA_DIR, "posthog.json");
-var SOCIAL_FILE = path2.join(DATA_DIR, "social.json");
-var TEMPLATES_DIR = path2.join(__dirname, "..", "..", "templates");
-var COMMAND_TEMPLATES_DIR = path2.join(TEMPLATES_DIR, "commands");
-
 // scripts/analyze.ts
 function parseArgs() {
   const args = process.argv.slice(2);
@@ -1647,7 +2069,7 @@ function parseArgs() {
   for (const arg of args) {
     if (arg.startsWith("--type=")) {
       const value = arg.split("=")[1];
-      if (["quick", "deep", "metrics", "seo", "research", "growth"].includes(value)) {
+      if (["quick", "deep", "metrics", "seo", "research", "growth", "vision"].includes(value)) {
         type = value;
       }
     } else if (arg.startsWith("--topic=")) {
@@ -1659,35 +2081,35 @@ function parseArgs() {
   return { type, topic, context };
 }
 function loadConfig() {
-  if (!fs4.existsSync(CONFIG_FILE)) {
+  if (!fs6.existsSync(CONFIG_FILE)) {
     throw new Error("Config file not found. Please ensure data/config.json exists.");
   }
-  return JSON.parse(fs4.readFileSync(CONFIG_FILE, "utf-8"));
+  return JSON.parse(fs6.readFileSync(CONFIG_FILE, "utf-8"));
 }
 function loadBusinessContext() {
-  if (!fs4.existsSync(BUSINESS_CONTEXT_FILE)) {
+  if (!fs6.existsSync(BUSINESS_CONTEXT_FILE)) {
     return void 0;
   }
   try {
-    return JSON.parse(fs4.readFileSync(BUSINESS_CONTEXT_FILE, "utf-8"));
+    return JSON.parse(fs6.readFileSync(BUSINESS_CONTEXT_FILE, "utf-8"));
   } catch {
     return void 0;
   }
 }
 function loadIdeas() {
-  if (!fs4.existsSync(IDEAS_FILE)) {
+  if (!fs6.existsSync(IDEAS_FILE)) {
     return { ideas: [] };
   }
-  return JSON.parse(fs4.readFileSync(IDEAS_FILE, "utf-8"));
+  return JSON.parse(fs6.readFileSync(IDEAS_FILE, "utf-8"));
 }
 function saveIdeas(data) {
   atomicWriteFileSync(IDEAS_FILE, JSON.stringify(data, null, 2));
 }
 function loadSessions() {
-  if (!fs4.existsSync(SESSIONS_FILE)) {
+  if (!fs6.existsSync(SESSIONS_FILE)) {
     return { sessions: [] };
   }
-  return JSON.parse(fs4.readFileSync(SESSIONS_FILE, "utf-8"));
+  return JSON.parse(fs6.readFileSync(SESSIONS_FILE, "utf-8"));
 }
 function saveSessions(data) {
   atomicWriteFileSync(SESSIONS_FILE, JSON.stringify(data, null, 2));
@@ -1773,8 +2195,8 @@ function flushSessionLogs(sessionId) {
 }
 function loadGoalsContext() {
   try {
-    if (!fs4.existsSync(GOALS_FILE)) return "";
-    const goalsData = JSON.parse(fs4.readFileSync(GOALS_FILE, "utf-8"));
+    if (!fs6.existsSync(GOALS_FILE)) return "";
+    const goalsData = JSON.parse(fs6.readFileSync(GOALS_FILE, "utf-8"));
     const goals = goalsData.goals || [];
     if (goals.length === 0) return "";
     return goals.map((g) => {
@@ -1792,8 +2214,8 @@ function linkIdeasToHypotheses(ideas) {
   const ideasWithHypothesis = ideas.filter((i) => i.hypothesis_id);
   if (ideasWithHypothesis.length === 0) return;
   try {
-    if (!fs4.existsSync(HYPOTHESES_FILE)) return;
-    const data = JSON.parse(fs4.readFileSync(HYPOTHESES_FILE, "utf-8"));
+    if (!fs6.existsSync(HYPOTHESES_FILE)) return;
+    const data = JSON.parse(fs6.readFileSync(HYPOTHESES_FILE, "utf-8"));
     const hypotheses = data.hypotheses || [];
     let changed = false;
     for (const idea of ideasWithHypothesis) {
@@ -1817,8 +2239,8 @@ function linkIdeasToHypotheses(ideas) {
 }
 function matchNewIdeasToEpics(newIdeas, ideasData) {
   try {
-    if (!fs4.existsSync(ROADMAP_FILE)) return;
-    const roadmapData = JSON.parse(fs4.readFileSync(ROADMAP_FILE, "utf-8"));
+    if (!fs6.existsSync(ROADMAP_FILE)) return;
+    const roadmapData = JSON.parse(fs6.readFileSync(ROADMAP_FILE, "utf-8"));
     const epics = roadmapData.epics || [];
     if (epics.length === 0) return;
     let matched = 0;
@@ -1852,8 +2274,8 @@ function matchNewIdeasToEpics(newIdeas, ideasData) {
 }
 function loadHypothesesContext() {
   try {
-    if (!fs4.existsSync(HYPOTHESES_FILE)) return "";
-    const data = JSON.parse(fs4.readFileSync(HYPOTHESES_FILE, "utf-8"));
+    if (!fs6.existsSync(HYPOTHESES_FILE)) return "";
+    const data = JSON.parse(fs6.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(
@@ -2160,7 +2582,7 @@ Return ONLY this JSON structure (no markdown code blocks):
           const jsonMatch = output.match(/\{[\s\S]*\}/);
           if (jsonMatch) {
             const snapshot = JSON.parse(jsonMatch[0]);
-            fs4.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2));
+            fs6.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2));
             console.log(`Codebase snapshot saved to ${snapshotPath}`);
           }
         } catch (error) {
@@ -2183,6 +2605,33 @@ async function main() {
   if (type === "research" && topic) {
     console.log(`Research topic: ${topic}`);
   }
+  if (type === "vision") {
+    console.log("Generating product vision (Obviously Awesome + StoryBrand)...\n");
+    const vision = await generateProductVision();
+    if (!vision) {
+      console.error("Vision generation failed");
+      process.exit(1);
+    }
+    console.log(`
+\u2713 Vision saved to data/product-vision.json (v${vision.version})`);
+    console.log(`  One-liner: ${vision.one_liner}`);
+    console.log(`  Focus metric: ${vision.focus_metric}`);
+    console.log(`  Anti-goals: ${vision.anti_goals.join(", ")}
+`);
+    console.log("Deriving hypotheses from vision...");
+    const hypotheses = await seedHypothesesFromVision(vision);
+    if (hypotheses.length > 0) {
+      console.log(`\u2713 ${hypotheses.length} hypotheses seeded to data/hypotheses.json
+`);
+      for (const h of hypotheses) {
+        console.log(`  - [${h.funnel_stage}] ${h.title}`);
+      }
+    } else {
+      console.log("  No hypotheses generated (you can add them manually)");
+    }
+    console.log("\n=== Vision Analysis Complete ===");
+    return;
+  }
   const config = loadConfig();
   console.log(`Analyzing ${config.repos.length} repositories...`);
   const session = createSession(type, config.repos.map((r) => r.name));