vibebusiness 1.2.11

package/dist/scripts/init.js

@@ -0,0 +1,1083 @@
+"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/init.ts
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var readline = __toESM(require("readline"));
+var import_child_process2 = require("child_process");
+
+// scripts/lib/ai-provider.ts
+var import_child_process = require("child_process");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+function detectClaudeCLI(customPath) {
+  const claudeBin = customPath || "claude";
+  try {
+    const version = (0, import_child_process.execSync)(`${claudeBin} --version 2>/dev/null`, {
+      timeout: 1e4,
+      encoding: "utf-8"
+    }).trim();
+    return { found: true, path: claudeBin, version };
+  } catch {
+    const commonPaths = [
+      "/usr/local/bin/claude",
+      path.join(process.env.HOME || "", ".claude", "bin", "claude"),
+      path.join(process.env.HOME || "", ".local", "bin", "claude")
+    ];
+    for (const p of commonPaths) {
+      try {
+        if (fs.existsSync(p)) {
+          const version = (0, import_child_process.execSync)(`${p} --version 2>/dev/null`, {
+            timeout: 1e4,
+            encoding: "utf-8"
+          }).trim();
+          return { found: true, path: p, version };
+        }
+      } catch {
+        continue;
+      }
+    }
+    return { found: false, path: claudeBin };
+  }
+}
+function detectBYOKKeys() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return { provider: "anthropic-api", key: process.env.ANTHROPIC_API_KEY };
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return { provider: "openai-api", key: process.env.OPENAI_API_KEY };
+  }
+  if (process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY) {
+    return { provider: "google-api", key: process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY };
+  }
+  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 saveProviderConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  const safeConfig = {
+    type: config.type,
+    model: config.model,
+    claudePath: config.claudePath
+  };
+  fs.writeFileSync(PROVIDER_CONFIG_FILE, JSON.stringify(safeConfig, null, 2));
+}
+
+// scripts/lib/license.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var CONFIG_DIR2 = path2.join(process.env.HOME || "", ".vibebusiness");
+var LICENSE_FILE = path2.join(CONFIG_DIR2, "license.json");
+var TRIAL_DURATION_DAYS = 14;
+var OFFLINE_GRACE_DAYS = 30;
+var TIER_LIMITS = {
+  trial: { maxRepos: 999 },
+  // unlimited during trial
+  solo: { maxRepos: 3 },
+  pro: { maxRepos: 999 },
+  // unlimited
+  team: { maxRepos: 999 },
+  enterprise: { maxRepos: 999 }
+};
+function loadStoredLicense() {
+  try {
+    if (fs2.existsSync(LICENSE_FILE)) {
+      return JSON.parse(fs2.readFileSync(LICENSE_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveStoredLicense(license) {
+  if (!fs2.existsSync(CONFIG_DIR2)) {
+    fs2.mkdirSync(CONFIG_DIR2, { recursive: true });
+  }
+  fs2.writeFileSync(LICENSE_FILE, JSON.stringify(license, null, 2));
+}
+function generateInstanceId() {
+  const os = require("os");
+  const hostname = os.hostname();
+  const user = os.userInfo().username;
+  return `${user}@${hostname}`;
+}
+function maskKey(key) {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 4) + "****" + key.slice(-4);
+}
+function startTrial() {
+  const now = /* @__PURE__ */ new Date();
+  const expiresAt = new Date(now.getTime() + TRIAL_DURATION_DAYS * 24 * 60 * 60 * 1e3);
+  const stored = {
+    key: "",
+    tier: "trial",
+    status: "trial",
+    lastValidated: now.toISOString(),
+    expiresAt: expiresAt.toISOString(),
+    activatedAt: now.toISOString(),
+    instanceId: generateInstanceId()
+  };
+  saveStoredLicense(stored);
+  return {
+    status: "trial",
+    tier: "trial",
+    keyMasked: "(trial)",
+    lastValidated: stored.lastValidated,
+    expiresAt: stored.expiresAt,
+    maxRepos: TIER_LIMITS.trial.maxRepos,
+    message: `Free trial started. Expires in ${TRIAL_DURATION_DAYS} days (${expiresAt.toLocaleDateString()}).`
+  };
+}
+async function validateLicense() {
+  const stored = loadStoredLicense();
+  if (!stored) {
+    return {
+      status: "unknown",
+      tier: "trial",
+      keyMasked: "",
+      lastValidated: null,
+      expiresAt: null,
+      maxRepos: 0,
+      message: "No license found. Run `vibebusiness init` to start a trial or enter a license key."
+    };
+  }
+  const now = /* @__PURE__ */ new Date();
+  if (stored.status === "trial" || stored.tier === "trial") {
+    if (stored.expiresAt && new Date(stored.expiresAt) < now) {
+      return {
+        status: "expired",
+        tier: "trial",
+        keyMasked: "(trial)",
+        lastValidated: stored.lastValidated,
+        expiresAt: stored.expiresAt,
+        maxRepos: 0,
+        message: "Trial expired. Enter a license key to continue using VibeBusiness."
+      };
+    }
+    const daysLeft = stored.expiresAt ? Math.ceil((new Date(stored.expiresAt).getTime() - now.getTime()) / (24 * 60 * 60 * 1e3)) : 0;
+    return {
+      status: "trial",
+      tier: "trial",
+      keyMasked: "(trial)",
+      lastValidated: stored.lastValidated,
+      expiresAt: stored.expiresAt,
+      maxRepos: TIER_LIMITS.trial.maxRepos,
+      message: `Trial active. ${daysLeft} days remaining.`
+    };
+  }
+  const lastValidated = stored.lastValidated ? new Date(stored.lastValidated) : null;
+  const daysSinceValidation = lastValidated ? (now.getTime() - lastValidated.getTime()) / (24 * 60 * 60 * 1e3) : Infinity;
+  if (daysSinceValidation > 7) {
+    const needsOnlineCheck = daysSinceValidation > OFFLINE_GRACE_DAYS;
+    if (needsOnlineCheck) {
+      return {
+        status: "expired",
+        tier: stored.tier,
+        keyMasked: maskKey(stored.key),
+        lastValidated: stored.lastValidated,
+        expiresAt: stored.expiresAt,
+        maxRepos: 0,
+        message: `License validation expired (last checked ${Math.floor(daysSinceValidation)} days ago). Connect to the internet to re-validate.`
+      };
+    }
+    stored.lastValidated = now.toISOString();
+    saveStoredLicense(stored);
+  }
+  return {
+    status: "valid",
+    tier: stored.tier,
+    keyMasked: maskKey(stored.key),
+    lastValidated: stored.lastValidated,
+    expiresAt: stored.expiresAt,
+    maxRepos: TIER_LIMITS[stored.tier].maxRepos,
+    email: stored.email,
+    message: `License valid (${stored.tier} tier).`
+  };
+}
+
+// scripts/lib/scaffold.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+function scaffoldSlashCommands(rootDir) {
+  let templatesDir = path3.join(__dirname, "..", "..", "templates", "commands");
+  if (!fs3.existsSync(templatesDir)) {
+    templatesDir = path3.join(__dirname, "..", "..", "..", "templates", "commands");
+  }
+  if (!fs3.existsSync(templatesDir)) return;
+  const targetDir = path3.join(rootDir, ".claude", "commands");
+  fs3.mkdirSync(targetDir, { recursive: true });
+  const templates = fs3.readdirSync(templatesDir).filter((f) => f.endsWith(".md"));
+  let copied = 0;
+  for (const file of templates) {
+    const src = path3.join(templatesDir, file);
+    const dest = path3.join(targetDir, file);
+    fs3.copyFileSync(src, dest);
+    copied++;
+  }
+  if (copied > 0) {
+    console.log(`  \u2713 Scaffolded ${copied} slash commands into .claude/commands/`);
+  }
+}
+
+// src/lib/repo-detection.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".venv",
+  "venv",
+  "dist",
+  "build",
+  "__pycache__",
+  ".next",
+  ".nuxt",
+  "target",
+  "coverage",
+  "workspaces"
+]);
+function detectProjectType(dir) {
+  const pkgJsonPath = path4.join(dir, "package.json");
+  if (fs4.existsSync(pkgJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (fs4.existsSync(path4.join(dir, "next.config.js")) || fs4.existsSync(path4.join(dir, "next.config.mjs")) || fs4.existsSync(path4.join(dir, "next.config.ts")) || allDeps["next"]) {
+        return { type: "nextjs", confidence: "high" };
+      }
+      if (fs4.existsSync(path4.join(dir, "nuxt.config.js")) || fs4.existsSync(path4.join(dir, "nuxt.config.ts")) || allDeps["nuxt"]) {
+        return { type: "nuxtjs", confidence: "high" };
+      }
+      return { type: "nodejs", confidence: "medium" };
+    } catch {
+      return { type: "nodejs", confidence: "medium" };
+    }
+  }
+  const requirementsPath = path4.join(dir, "requirements.txt");
+  if (fs4.existsSync(requirementsPath)) {
+    try {
+      const requirements = fs4.readFileSync(requirementsPath, "utf-8").toLowerCase();
+      if (requirements.includes("fastapi")) return { type: "fastapi", confidence: "high" };
+      if (requirements.includes("django")) return { type: "django", confidence: "high" };
+      if (requirements.includes("flask")) return { type: "flask", confidence: "high" };
+      return { type: "python", confidence: "medium" };
+    } catch {
+      return { type: "python", confidence: "medium" };
+    }
+  }
+  const pyprojectPath = path4.join(dir, "pyproject.toml");
+  if (fs4.existsSync(pyprojectPath)) {
+    try {
+      const pyproject = fs4.readFileSync(pyprojectPath, "utf-8").toLowerCase();
+      if (pyproject.includes("fastapi")) return { type: "fastapi", confidence: "high" };
+      if (pyproject.includes("django")) return { type: "django", confidence: "high" };
+      if (pyproject.includes("flask")) return { type: "flask", confidence: "high" };
+      return { type: "python", confidence: "medium" };
+    } catch {
+      return { type: "python", confidence: "medium" };
+    }
+  }
+  if (fs4.existsSync(path4.join(dir, "go.mod"))) {
+    return { type: "go", confidence: "high" };
+  }
+  if (fs4.existsSync(path4.join(dir, "Cargo.toml"))) {
+    return { type: "rust", confidence: "high" };
+  }
+  const gemfilePath = path4.join(dir, "Gemfile");
+  if (fs4.existsSync(gemfilePath)) {
+    try {
+      const gemfile = fs4.readFileSync(gemfilePath, "utf-8").toLowerCase();
+      if (gemfile.includes("rails")) return { type: "rails", confidence: "high" };
+      return { type: "ruby", confidence: "medium" };
+    } catch {
+      return { type: "ruby", confidence: "medium" };
+    }
+  }
+  return null;
+}
+function autoDetectRepos(rootDir) {
+  const detected = [];
+  try {
+    const entries = fs4.readdirSync(rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) {
+        continue;
+      }
+      const subDir = path4.join(rootDir, entry.name);
+      const result = detectProjectType(subDir);
+      if (result) {
+        detected.push({
+          name: entry.name,
+          path: subDir,
+          type: result.type,
+          confidence: result.confidence
+        });
+      }
+    }
+  } catch {
+  }
+  const rootResult = detectProjectType(rootDir);
+  if (rootResult) {
+    if (detected.length === 0) {
+      detected.push({
+        name: path4.basename(rootDir),
+        path: rootDir,
+        type: rootResult.type,
+        confidence: rootResult.confidence
+      });
+    }
+  }
+  return detected;
+}
+
+// scripts/init.ts
+var rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+function ask(question, defaultValue) {
+  const suffix = defaultValue ? ` [${defaultValue}]` : "";
+  return new Promise((resolve2) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve2(answer.trim() || defaultValue || "");
+    });
+  });
+}
+function askYesNo(question, defaultYes = true) {
+  const hint = defaultYes ? "[Y/n]" : "[y/N]";
+  return new Promise((resolve2) => {
+    rl.question(`${question} ${hint}: `, (answer) => {
+      const a = answer.trim().toLowerCase();
+      if (a === "") resolve2(defaultYes);
+      else resolve2(a === "y" || a === "yes");
+    });
+  });
+}
+function askChoice(question, options) {
+  return new Promise((resolve2) => {
+    console.log(`
+${question}`);
+    options.forEach((opt, i) => console.log(`  ${i + 1}. ${opt}`));
+    rl.question(`Choice [1-${options.length}]: `, (answer) => {
+      const idx = parseInt(answer.trim(), 10) - 1;
+      resolve2(idx >= 0 && idx < options.length ? idx : 0);
+    });
+  });
+}
+function print(msg) {
+  console.log(msg);
+}
+function printHeader(title) {
+  const line = "\u2500".repeat(60);
+  console.log(`
+${line}`);
+  console.log(`  ${title}`);
+  console.log(line);
+}
+function printSuccess(msg) {
+  console.log(`  \u2713 ${msg}`);
+}
+function printWarning(msg) {
+  console.log(`  \u26A0 ${msg}`);
+}
+function toKebabCase(input) {
+  return input.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function checkPrerequisites() {
+  print("\n  Checking prerequisites...\n");
+  try {
+    const nodeVersion = (0, import_child_process2.execSync)("node --version", { encoding: "utf-8" }).trim();
+    printSuccess(`Node.js ${nodeVersion}`);
+  } catch {
+    printWarning("Node.js not found. Frontend scaffolding may fail.");
+  }
+  try {
+    const pythonVersion = (0, import_child_process2.execSync)("python3 --version", { encoding: "utf-8" }).trim();
+    printSuccess(`${pythonVersion}`);
+  } catch {
+    printWarning("Python 3 not found. You will need it to run the backend.");
+  }
+}
+function scaffoldFastAPIBackend(dir) {
+  fs5.mkdirSync(dir, { recursive: true });
+  fs5.writeFileSync(
+    path5.join(dir, "main.py"),
+    `"""FastAPI backend \u2014 generated by VibeBusiness."""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI(title="Backend API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.get("/")
+def root():
+    return {"message": "Welcome to the API. Visit /docs for interactive documentation."}
+`
+  );
+  fs5.writeFileSync(
+    path5.join(dir, "requirements.txt"),
+    `fastapi>=0.115.0
+uvicorn[standard]>=0.30.0
+python-dotenv>=1.0.0
+`
+  );
+  fs5.writeFileSync(
+    path5.join(dir, ".env.example"),
+    `# Copy to .env and fill in values
+DATABASE_URL=sqlite:///./dev.db
+SECRET_KEY=change-me
+DEBUG=true
+`
+  );
+  fs5.writeFileSync(
+    path5.join(dir, ".gitignore"),
+    `__pycache__/
+*.pyc
+.env
+.venv/
+venv/
+*.egg-info/
+dist/
+`
+  );
+  fs5.writeFileSync(
+    path5.join(dir, "README.md"),
+    `# Backend
+
+FastAPI backend generated by [VibeBusiness](https://www.vibebusiness.com).
+
+## Quick start
+
+\`\`\`bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+cp .env.example .env
+uvicorn main:app --reload --port 8001
+\`\`\`
+
+API docs: http://localhost:8001/docs
+`
+  );
+}
+function buildReposFromScaffold(scaffold) {
+  const repos = [];
+  if (scaffold.frontendOk) {
+    repos.push({
+      name: "frontend",
+      path: scaffold.frontendDir,
+      type: "nextjs",
+      default_branch: "main",
+      test_commands: ["npx tsc --noEmit"]
+    });
+  }
+  if (scaffold.backendOk) {
+    repos.push({
+      name: "backend",
+      path: scaffold.backendDir,
+      type: "fastapi",
+      default_branch: "main",
+      test_commands: ["python3 -m pytest"]
+    });
+  }
+  return repos;
+}
+function buildReposFromDetected(detected) {
+  return detected.map((d) => ({
+    name: d.name,
+    path: d.path,
+    type: d.type,
+    default_branch: "main",
+    test_commands: []
+  }));
+}
+async function stepProjectMode() {
+  const choice = await askChoice("What would you like to do?", [
+    "Create a new project (Next.js + FastAPI)",
+    "Add an existing project"
+  ]);
+  if (choice === 1) {
+    const rootDir = await ask("Project root directory", process.cwd());
+    const resolvedDir = path5.resolve(rootDir);
+    if (!fs5.existsSync(resolvedDir)) {
+      printWarning(`Directory not found: ${resolvedDir}`);
+      print("  Creating it...");
+      fs5.mkdirSync(resolvedDir, { recursive: true });
+    }
+    return { type: "existing", rootDir: resolvedDir };
+  }
+  const rawName = await ask("Project name", "my-saas");
+  const projectName = toKebabCase(rawName) || "my-saas";
+  const projectDir = path5.resolve(process.cwd(), projectName);
+  if (fs5.existsSync(projectDir)) {
+    const reuse = await askYesNo(`Directory "${projectName}" already exists. Use it anyway?`, false);
+    if (!reuse) {
+      print("\n  Aborted. Please choose a different name or remove the directory.");
+      process.exit(0);
+    }
+  } else {
+    fs5.mkdirSync(projectDir, { recursive: true });
+  }
+  checkPrerequisites();
+  const frontendDir = path5.join(projectDir, "frontend");
+  const backendDir = path5.join(projectDir, "backend");
+  let frontendOk = false;
+  print("\n  Scaffolding Next.js frontend...\n");
+  try {
+    (0, import_child_process2.execSync)(
+      'npx create-next-app@latest frontend --typescript --tailwind --eslint --app --src-dir --import-alias "@/*" --use-npm --no-git',
+      {
+        cwd: projectDir,
+        stdio: "inherit"
+      }
+    );
+    frontendOk = true;
+    printSuccess("Frontend created at frontend/");
+  } catch {
+    printWarning("Frontend scaffolding failed (network issue?). You can add it later.");
+  }
+  let backendOk = false;
+  print("\n  Scaffolding FastAPI backend...\n");
+  try {
+    scaffoldFastAPIBackend(backendDir);
+    backendOk = true;
+    printSuccess("Backend created at backend/");
+  } catch (err) {
+    printWarning(`Backend scaffolding failed: ${err.message}`);
+  }
+  const rootGitignore = path5.join(projectDir, ".gitignore");
+  if (!fs5.existsSync(rootGitignore)) {
+    fs5.writeFileSync(
+      rootGitignore,
+      `node_modules/
+.env
+.env.local
+.next/
+__pycache__/
+*.pyc
+.venv/
+dist/
+workspaces/
+`
+    );
+  }
+  try {
+    (0, import_child_process2.execSync)("git init", { cwd: projectDir, stdio: "pipe" });
+    printSuccess("Initialized git repository");
+  } catch {
+    printWarning("Could not initialize git (is git installed?).");
+  }
+  return {
+    type: "scaffold",
+    scaffold: {
+      projectName,
+      projectDir,
+      frontendDir,
+      backendDir,
+      frontendOk,
+      backendOk
+    }
+  };
+}
+async function stepAIProvider(rootDir) {
+  const detection = detectProvider();
+  if (detection.provider === "claude-cli") {
+    printSuccess("AI: Claude Code CLI detected");
+    const config2 = { type: "claude-cli" };
+    saveProviderConfig(config2);
+    return config2;
+  }
+  if (!detection.message.includes("No AI provider")) {
+    printSuccess(`AI: ${detection.message}`);
+    const config2 = { type: detection.provider };
+    saveProviderConfig(config2);
+    return config2;
+  }
+  printHeader("AI Provider");
+  const choice = await askChoice("How would you like to connect AI?", [
+    "Enter Anthropic API key (recommended)",
+    "Enter OpenAI API key",
+    "Enter Google AI API key",
+    "Skip for now (AI features will be disabled)"
+  ]);
+  if (choice === 3) {
+    printWarning("AI features disabled. Configure later with `vibebusiness init`.");
+    const config2 = { type: "claude-cli" };
+    return config2;
+  }
+  const providerMap = {
+    0: { type: "anthropic-api", envVar: "ANTHROPIC_API_KEY" },
+    1: { type: "openai-api", envVar: "OPENAI_API_KEY" },
+    2: { type: "google-api", envVar: "GOOGLE_API_KEY" }
+  };
+  const selected = providerMap[choice];
+  const key = await ask(`Enter your ${selected.envVar}`);
+  if (key) {
+    const envFile = path5.join(rootDir, ".env.local");
+    let envContent = "";
+    if (fs5.existsSync(envFile)) {
+      envContent = fs5.readFileSync(envFile, "utf-8");
+    }
+    if (!envContent.includes(selected.envVar)) {
+      envContent += `
+${selected.envVar}=${key}
+`;
+      fs5.writeFileSync(envFile, envContent);
+      printSuccess(`Saved ${selected.envVar} to .env.local`);
+    }
+    process.env[selected.envVar] = key;
+  }
+  const config = { type: selected.type };
+  saveProviderConfig(config);
+  return config;
+}
+async function stepLicense() {
+  const existing = await validateLicense();
+  if (existing.status === "valid") {
+    printSuccess(`License: ${existing.tier} tier active (${existing.keyMasked})`);
+    return;
+  }
+  if (existing.status === "trial") {
+    printSuccess(`License: ${existing.message}`);
+    return;
+  }
+  const trial = startTrial();
+  printSuccess(`License: ${trial.message}`);
+}
+function buildDefaultContext(productName, summary) {
+  return {
+    product: {
+      name: productName,
+      summary,
+      locale: "en-US",
+      architecture: []
+    },
+    competitors: [],
+    regulatory: [],
+    funnels: [],
+    monetization: {
+      current_mrr: 0,
+      pricing: {},
+      revenue_streams: []
+    },
+    funnel_stages: {
+      description: "Business funnel stages. Customize to match your business.",
+      stages: {
+        acquisition: {
+          question: "Are users finding your product?",
+          current_status: "unknown"
+        },
+        activation: {
+          question: "Are users getting value from your product?",
+          current_status: "unknown"
+        },
+        retention: {
+          question: "Are users coming back?",
+          current_status: "unknown"
+        },
+        revenue: {
+          question: "Are users paying?",
+          current_status: "unknown"
+        },
+        referral: {
+          question: "Are users referring others?",
+          current_status: "unknown"
+        }
+      }
+    },
+    key_constraints: [],
+    kpi_adapters: []
+  };
+}
+async function stepBusinessContext(projectName, dataDir) {
+  const contextFile = path5.join(dataDir, "business-context.json");
+  if (fs5.existsSync(contextFile)) {
+    const overwrite = await askYesNo("Existing business-context.json found. Overwrite?", false);
+    if (!overwrite) {
+      printSuccess("Keeping existing business context.");
+      return JSON.parse(fs5.readFileSync(contextFile, "utf-8"));
+    }
+  }
+  const name = await ask("Product name", projectName);
+  const summary = await ask("One-line description", `${name} \u2014 a software product`);
+  return buildDefaultContext(name, summary);
+}
+async function stepReposExisting(rootDir) {
+  print("\n  Scanning for repositories...");
+  const detected = autoDetectRepos(rootDir);
+  if (detected.length > 0) {
+    print("");
+    detected.forEach((d) => {
+      printSuccess(`Found: ${d.name}/ (${d.type})`);
+    });
+    if (detected.length > 5) {
+      print("");
+      printWarning(`Found ${detected.length} repos. This looks like a general code directory.`);
+      printWarning("Consider pointing to a specific project root instead.");
+    }
+    const confirm = await askYesNo("\n  Use these repositories?");
+    if (confirm) {
+      return buildReposFromDetected(detected);
+    }
+    print("\n  OK, entering manual mode.\n");
+  } else {
+    print("");
+    printWarning("No repositories auto-detected.");
+    print("  Entering manual mode.\n");
+  }
+  return stepReposManual(rootDir);
+}
+async function stepReposManual(rootDir) {
+  const configFile = path5.join(rootDir, "data", "config.json");
+  if (fs5.existsSync(configFile)) {
+    const existing = JSON.parse(fs5.readFileSync(configFile, "utf-8"));
+    if (existing.repos && existing.repos.length > 0) {
+      const overwrite = await askYesNo(
+        `Found ${existing.repos.length} existing repo(s). Overwrite?`,
+        false
+      );
+      if (!overwrite) {
+        printSuccess("Keeping existing repository configuration.");
+        return existing.repos;
+      }
+    }
+  }
+  const repos = [];
+  let addMore = true;
+  print("  Add the repositories you want the analyst to monitor:\n");
+  while (addMore) {
+    const repoPath = await ask(`Repo ${repos.length + 1} path`, rootDir);
+    const repoName = await ask("  Name", path5.basename(repoPath));
+    const repoType = await ask("  Type (nextjs, fastapi, nodejs, rails, django, etc.)", "nodejs");
+    repos.push({
+      name: repoName,
+      path: repoPath,
+      type: repoType,
+      default_branch: "main",
+      test_commands: []
+    });
+    addMore = await askYesNo("Add another repository?", false);
+  }
+  return repos;
+}
+function generateConfigs(context, repos, rootDir) {
+  const dataDir = path5.join(rootDir, "data");
+  if (!fs5.existsSync(dataDir)) {
+    fs5.mkdirSync(dataDir, { recursive: true });
+  }
+  const contextFile = path5.join(dataDir, "business-context.json");
+  const contextData = {
+    last_manual_update: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    ...context
+  };
+  fs5.writeFileSync(contextFile, JSON.stringify(contextData, null, 2));
+  const configFile = path5.join(dataDir, "config.json");
+  const configData = {
+    repos,
+    workspace_dir: path5.join(rootDir, "workspaces"),
+    schedules: {
+      quick: {
+        focus: ["recent_changes", "todos", "errors", "fixme"],
+        max_ideas: 5
+      },
+      deep: {
+        focus: ["architecture", "tech_debt", "security", "patterns", "dependencies"],
+        max_ideas: 15
+      },
+      metrics: {
+        focus: ["funnels", "dropoffs", "conversions", "performance"],
+        max_ideas: 10
+      },
+      research: {
+        focus: ["deep_investigation", "web_research", "competitor_analysis"],
+        max_ideas: 1
+      }
+    },
+    autonomy: {
+      enabled: true,
+      max_sub_task_timeout_ms: 6e5,
+      max_sub_tasks_per_idea: 10,
+      max_retries_per_sub_task: 1
+    }
+  };
+  fs5.writeFileSync(configFile, JSON.stringify(configData, null, 2));
+  const starters = {
+    "goals.json": { goals: [] },
+    "ideas.json": { ideas: [] },
+    "hypotheses.json": { hypotheses: [] },
+    "sessions.json": { sessions: [] }
+  };
+  for (const [file, defaultData] of Object.entries(starters)) {
+    const filePath = path5.join(dataDir, file);
+    if (!fs5.existsSync(filePath)) {
+      fs5.writeFileSync(filePath, JSON.stringify(defaultData, null, 2));
+    }
+  }
+  const biFiles = {
+    "competitors.json": { last_updated: "", competitors: [] },
+    "positioning.json": { last_updated: "", current: null, copy_bank: null },
+    "pages.json": { last_updated: "", pages: [] }
+  };
+  for (const [file, defaultData] of Object.entries(biFiles)) {
+    const filePath = path5.join(dataDir, file);
+    if (!fs5.existsSync(filePath)) {
+      fs5.writeFileSync(filePath, JSON.stringify(defaultData, null, 2));
+    }
+  }
+  scaffoldSlashCommands(rootDir);
+  const statusFile = path5.join(rootDir, "STATUS.md");
+  if (!fs5.existsSync(statusFile)) {
+    fs5.writeFileSync(
+      statusFile,
+      `# VibeBusiness - Status
+
+> Initialized: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Status: Ready
+
+Run \`vibebusiness heartbeat\` to start the first analysis.
+`
+    );
+  }
+  const todoFile = path5.join(rootDir, "TODO.md");
+  if (!fs5.existsSync(todoFile)) {
+    fs5.writeFileSync(
+      todoFile,
+      [
+        "# Analyst TODO",
+        "",
+        "Proactive task queue for the AI analyst. Tasks are worked through autonomously during heartbeat check-ins.",
+        "",
+        "---",
+        "",
+        "## High Priority (Do Now)",
+        "",
+        "- [ ] Run first heartbeat: `vibebusiness heartbeat`",
+        "- [ ] Add business goals via the dashboard",
+        "- [ ] Configure KPI adapters for live data",
+        "",
+        "## Scheduled",
+        "",
+        "- [ ] `quick-analysis` \u2014 Quick analysis (Daily 06:00)",
+        "- [ ] `deep-analysis` \u2014 Deep analysis (Sunday 03:00)",
+        "- [ ] `metrics-analysis` \u2014 Metrics review (Monday 08:00)",
+        "",
+        "## Blocked",
+        "",
+        "## Completed This Week",
+        "",
+        "---",
+        "",
+        "*This file is updated by the heartbeat script and human reviewers.*",
+        ""
+      ].join("\n")
+    );
+  }
+  const memoryFile = path5.join(rootDir, "MEMORY.md");
+  if (!fs5.existsSync(memoryFile)) {
+    fs5.writeFileSync(
+      memoryFile,
+      [
+        "# Analyst Memory",
+        "",
+        "Curated context and learnings distilled from analysis sessions. This file helps the AI maintain continuity between heartbeats.",
+        "",
+        "---",
+        "",
+        "## Project Patterns",
+        "",
+        "## Technical Decisions",
+        "",
+        "| Date | Decision | Rationale |",
+        "|------|----------|-----------|",
+        "",
+        "## Learned Patterns",
+        "",
+        "### Common Issues",
+        "",
+        "### Heartbeat Learnings",
+        "",
+        "---",
+        "",
+        "*This file is updated by the heartbeat script when new patterns are discovered.*",
+        ""
+      ].join("\n")
+    );
+  }
+  printSuccess("Config files generated");
+}
+function printNewProjectSuccess(scaffold) {
+  const line = "\u2500".repeat(60);
+  print(`
+${line}`);
+  print(`  Ready! Project created at ${scaffold.projectDir}`);
+  print(line);
+  print("");
+  print("  Next steps:");
+  let step = 1;
+  print(`    ${step++}. cd ${scaffold.projectName}`);
+  if (scaffold.frontendOk) {
+    print(`    ${step++}. Start frontend:  cd frontend && npm run dev`);
+  }
+  if (scaffold.backendOk) {
+    print(`    ${step++}. Start backend:   cd backend && uvicorn main:app --reload --port 8001`);
+  }
+  print(`    ${step++}. First analysis:  cd ${scaffold.projectName} && vibebusiness heartbeat`);
+  print("");
+  print("  Customize later:");
+  print("    - Add competitors, constraints:  edit data/business-context.json");
+  print("    - Configure KPI adapters:        edit data/business-context.json");
+  print("");
+}
+function printExistingProjectSuccess() {
+  const line = "\u2500".repeat(60);
+  print(`
+${line}`);
+  print("  Ready!");
+  print(line);
+  print("");
+  print("  Next steps:");
+  print("    1. Run first analysis:  vibebusiness heartbeat");
+  print("    2. View dashboard:      vibebusiness start");
+  print("");
+  print("  Customize later:");
+  print("    - Add competitors, constraints:  edit data/business-context.json");
+  print("    - Configure KPI adapters:        edit data/business-context.json");
+  print("");
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const isReset = args.includes("--reset");
+  console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551   VibeBusiness - Setup Wizard                 \u2551
+\u2551   Monitor. Analyze. Ship.                    \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+  if (isReset) {
+    const rootDir = process.cwd();
+    const configFile = path5.join(rootDir, "data", "config.json");
+    if (!fs5.existsSync(configFile)) {
+      printWarning("No config.json found. Running normal init instead.");
+    } else {
+      print("  --reset: Clearing repository configuration...");
+      try {
+        const existing = JSON.parse(fs5.readFileSync(configFile, "utf-8"));
+        existing.repos = [];
+        fs5.writeFileSync(configFile, JSON.stringify(existing, null, 2));
+        printSuccess("Repos cleared from config.json");
+      } catch {
+        printWarning("Could not parse config.json. Running normal init.");
+      }
+      const repos = await stepReposExisting(rootDir);
+      const configData = JSON.parse(fs5.readFileSync(configFile, "utf-8"));
+      configData.repos = repos;
+      fs5.writeFileSync(configFile, JSON.stringify(configData, null, 2));
+      printSuccess("Updated config.json with new repos");
+      printExistingProjectSuccess();
+      rl.close();
+      return;
+    }
+  }
+  try {
+    const mode = await stepProjectMode();
+    if (mode.type === "scaffold") {
+      const { scaffold } = mode;
+      const description = await ask(
+        "One-line product description",
+        `${scaffold.projectName} \u2014 a software product`
+      );
+      print("");
+      await stepAIProvider(scaffold.projectDir);
+      await stepLicense();
+      const repos = buildReposFromScaffold(scaffold);
+      repos.forEach((r) => printSuccess(`Repos: ${r.name} (${r.type})`));
+      const context = buildDefaultContext(scaffold.projectName, description);
+      generateConfigs(context, repos, scaffold.projectDir);
+      printNewProjectSuccess(scaffold);
+    } else {
+      const { rootDir } = mode;
+      const repos = await stepReposExisting(rootDir);
+      const projectName = path5.basename(rootDir);
+      const dataDir = path5.join(rootDir, "data");
+      const context = await stepBusinessContext(projectName, dataDir);
+      print("");
+      await stepAIProvider(rootDir);
+      await stepLicense();
+      generateConfigs(context, repos, rootDir);
+      printExistingProjectSuccess();
+    }
+  } catch (err) {
+    console.error("\n  Error during setup:", err.message);
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}
+main();