vibe-weaver 1.0.0

package/dist/index.js

@@ -0,0 +1,2018 @@
+import envPaths from 'env-paths';
+import fs from 'fs';
+import path2 from 'path';
+import chalk8 from 'chalk';
+import inquirer from 'inquirer';
+import open from 'open';
+import { execaCommand } from 'execa';
+import 'ora';
+import simpleGit from 'simple-git';
+import { Command } from 'commander';
+import fs2 from 'fs/promises';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function getConfigDir() {
+  const paths = envPaths("vibe-weaver", { suffix: "" });
+  if (!fs.existsSync(paths.config)) {
+    fs.mkdirSync(paths.config, { recursive: true });
+  }
+  fs.chmodSync(paths.config, 448);
+  return paths.config;
+}
+function getConfigPath() {
+  return path2.join(getConfigDir(), CONFIG_FILE_NAME);
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  try {
+    if (fs.existsSync(configPath)) {
+      const data = fs.readFileSync(configPath, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    console.warn("Warning: Failed to load config:", error);
+  }
+  return {};
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), {
+      mode: 384
+    });
+  } catch (error) {
+    throw new Error(`Failed to save config: ${error}`);
+  }
+}
+function getDefaultSupabaseUrl() {
+  return process.env.VW_SUPABASE_URL || "https://mmtsoqelnsjleusqyknc.supabase.co";
+}
+function getSupabaseUrl() {
+  const config = loadConfig();
+  return config.supabaseUrl || getDefaultSupabaseUrl();
+}
+var CONFIG_FILE_NAME;
+var init_config = __esm({
+  "src/config/index.ts"() {
+    CONFIG_FILE_NAME = "config.json";
+  }
+});
+async function getSecret(account) {
+  if (keytar) {
+    try {
+      const value = await keytar.getPassword(SERVICE_NAME, account);
+      if (value) return value;
+    } catch {
+    }
+  }
+  const config = loadConfig();
+  if (account === API_KEY_ACCOUNT) return config.apiKey || null;
+  if (account === GITHUB_TOKEN_ACCOUNT) return config.githubToken || null;
+  return null;
+}
+async function setSecret(account, value) {
+  if (keytar) {
+    try {
+      await keytar.setPassword(SERVICE_NAME, account, value);
+      const config2 = loadConfig();
+      if (account === API_KEY_ACCOUNT) config2.apiKey = value;
+      if (account === GITHUB_TOKEN_ACCOUNT) config2.githubToken = value;
+      saveConfig(config2);
+      return;
+    } catch {
+    }
+  }
+  const config = loadConfig();
+  if (account === API_KEY_ACCOUNT) config.apiKey = value;
+  if (account === GITHUB_TOKEN_ACCOUNT) config.githubToken = value;
+  saveConfig(config);
+}
+async function deleteSecret(account) {
+  if (keytar) {
+    try {
+      await keytar.deletePassword(SERVICE_NAME, account);
+    } catch {
+    }
+  }
+  const config = loadConfig();
+  if (account === API_KEY_ACCOUNT) {
+    config.apiKey = void 0;
+  }
+  if (account === GITHUB_TOKEN_ACCOUNT) {
+    config.githubToken = void 0;
+  }
+  saveConfig(config);
+}
+async function isLoggedIn() {
+  const apiKey = await getSecret(API_KEY_ACCOUNT);
+  return !!apiKey;
+}
+async function getApiKey() {
+  return getSecret(API_KEY_ACCOUNT);
+}
+async function getGithubToken() {
+  return getSecret(GITHUB_TOKEN_ACCOUNT);
+}
+async function login(options = {}) {
+  const supabaseUrl = getSupabaseUrl();
+  if (options.apiKey) {
+    await setSecret(API_KEY_ACCOUNT, options.apiKey);
+    console.log(chalk8.green("\u2713 API key saved securely"));
+    const userInfo2 = await getUserInfo();
+    if (userInfo2) {
+      console.log(chalk8.green(`\u2713 Logged in as ${userInfo2.email} (${userInfo2.plan} plan)`));
+    }
+    return;
+  }
+  if (options.openBrowser) {
+    const apiPageUrl = `${supabaseUrl}/dashboard/api`;
+    console.log(chalk8.blue("Opening browser to create API key..."));
+    await open(apiPageUrl);
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "apiKey",
+      message: "Enter your Vibe-Weaver API key (vw_...):",
+      validate: (input) => {
+        if (!input.startsWith("vw_") && input.length < 10) {
+          return "Please enter a valid API key (starts with vw_)";
+        }
+        return true;
+      }
+    }
+  ]);
+  await setSecret(API_KEY_ACCOUNT, answers.apiKey);
+  console.log(chalk8.green("\u2713 API key saved securely"));
+  const userInfo = await getUserInfo();
+  if (userInfo) {
+    console.log(chalk8.green(`\u2713 Logged in as ${userInfo.email} (${userInfo.plan} plan)`));
+  }
+}
+async function loginGithub(token) {
+  if (!token) {
+    const answers = await inquirer.prompt([
+      {
+        type: "password",
+        name: "token",
+        message: "Enter your GitHub Personal Access Token:",
+        validate: (input) => {
+          if (input.length < 10) {
+            return "Please enter a valid GitHub token";
+          }
+          return true;
+        }
+      }
+    ]);
+    token = answers.token;
+  }
+  await setSecret(GITHUB_TOKEN_ACCOUNT, token);
+  console.log(chalk8.green("\u2713 GitHub token saved securely"));
+}
+async function logout() {
+  await deleteSecret(API_KEY_ACCOUNT);
+  await deleteSecret(GITHUB_TOKEN_ACCOUNT);
+  console.log(chalk8.green("\u2713 Logged out successfully"));
+}
+async function getUserInfo() {
+  const apiKey = await getApiKey();
+  if (!apiKey) return null;
+  const supabaseUrl = getSupabaseUrl();
+  try {
+    const response = await fetch(`${supabaseUrl}/rest/v1/profiles?select=email,plan,credits`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "apikey": `${supabaseUrl}/rest/v1/apikey`
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (Array.isArray(data) && data.length > 0) {
+        return {
+          email: data[0].email || "Unknown",
+          plan: data[0].plan || "free",
+          credits: data[0].credits || 0
+        };
+      }
+    }
+  } catch (error) {
+    console.warn("Warning: Could not fetch user info:", error);
+  }
+  return null;
+}
+async function whoami() {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    console.log(chalk8.yellow('Not logged in. Run "vibe-weaver login" first.'));
+    return;
+  }
+  const userInfo = await getUserInfo();
+  if (userInfo) {
+    console.log(chalk8.bold("Logged in as:"));
+    console.log(`  Email: ${userInfo.email}`);
+    console.log(`  Plan: ${chalk8.cyan(userInfo.plan)}`);
+    console.log(`  Credits: ${chalk8.green(userInfo.credits.toString())}`);
+  } else {
+    console.log(chalk8.yellow("API key is set but could not fetch user info."));
+    console.log(`  API Key: ${chalk8.grey(apiKey.substring(0, 10))}...`);
+  }
+  const githubToken = await getGithubToken();
+  if (githubToken) {
+    console.log(chalk8.green("\u2713 GitHub token configured"));
+  } else {
+    console.log(chalk8.grey('  GitHub: Not configured (run "vibe-weaver login --github" to add)'));
+  }
+}
+var SERVICE_NAME, API_KEY_ACCOUNT, GITHUB_TOKEN_ACCOUNT, keytar;
+var init_auth = __esm({
+  "src/auth/index.ts"() {
+    init_config();
+    SERVICE_NAME = "vibe-weaver";
+    API_KEY_ACCOUNT = "api-key";
+    GITHUB_TOKEN_ACCOUNT = "github-token";
+    keytar = null;
+    try {
+      keytar = __require("keytar");
+    } catch {
+    }
+  }
+});
+
+// src/lib/code-parser.ts
+function parseCodeBlocks(response) {
+  const blocks = [];
+  const codeBlockRegex = /```(\w+)?\s+(.+?)\n([\s\S]*?)```/g;
+  let match;
+  while ((match = codeBlockRegex.exec(response)) !== null) {
+    const language = match[1] || "text";
+    const path4 = match[2].trim();
+    const content = match[3];
+    const beforeBlock = response.substring(0, match.index);
+    const startLine = (beforeBlock.match(/\n/g) || []).length + 1;
+    const endLine = startLine + (content.match(/\n/g) || []).length;
+    blocks.push({
+      language,
+      path: path4,
+      content,
+      startLine,
+      endLine
+    });
+  }
+  let explanation;
+  const firstCodeBlockIndex = response.indexOf("```");
+  if (firstCodeBlockIndex > 0) {
+    explanation = response.substring(0, firstCodeBlockIndex).trim();
+  }
+  return { blocks, explanation };
+}
+async function writeCodeBlocks(blocks, baseDir, options = {}) {
+  const fs3 = await import('fs/promises');
+  const path4 = await import('path');
+  const success = [];
+  const failed = [];
+  for (const block of blocks) {
+    try {
+      const fullPath = path4.join(baseDir, block.path);
+      const dir = path4.dirname(fullPath);
+      if (!options.dryRun) {
+        await fs3.mkdir(dir, { recursive: true });
+        await fs3.writeFile(fullPath, block.content, "utf-8");
+      }
+      success.push(block.path);
+    } catch (error) {
+      failed.push({
+        path: block.path,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { success, failed };
+}
+function generateDiff(oldContent, newContent, filePath) {
+  const diff = __require("diff");
+  const changes = diff.diffLines(oldContent, newContent);
+  let result = `--- ${filePath}
++++ ${filePath}
+`;
+  for (const change of changes) {
+    const prefix = change.added ? "+" : change.removed ? "-" : " ";
+    const lines = change.value.split("\n").filter((l) => l.length > 0);
+    for (const line of lines) {
+      result += `${prefix}${line}
+`;
+    }
+  }
+  return result;
+}
+var init_code_parser = __esm({
+  "src/lib/code-parser.ts"() {
+  }
+});
+
+// src/lib/vibe-api.ts
+function getCreditCost(modelId) {
+  const costs = {
+    "fast": 0.2,
+    "balanced": 0.5,
+    "deep_reasoning": 1,
+    "refactor": 1
+  };
+  return costs[modelId] || 0.5;
+}
+async function generateCode(options) {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+  const supabaseUrl = getSupabaseUrl();
+  const endpoint = `${supabaseUrl}/functions/v1/vibe-ai-api`;
+  const payload = {
+    goal: options.goal,
+    platform: options.platform || "web",
+    language: options.language || "typescript",
+    modelId: options.modelId || "balanced"
+  };
+  console.log(`
+${"[Vibe-Weaver]".padEnd(20)} Calling ${payload.modelId.toUpperCase()} model for: ${options.goal.substring(0, 50)}...`);
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    if (response.status === 401) {
+      throw new Error('Authentication failed. Please run "vibe-weaver login" again.');
+    }
+    if (response.status === 402) {
+      throw new Error(`Insufficient credits: ${error.message}`);
+    }
+    throw new Error(`API error: ${error.error || error.message}`);
+  }
+  const result = await response.json();
+  const parsed = parseCodeBlocks(result.code);
+  return {
+    code: result.code,
+    explanation: result.explanation || "",
+    quality: result.quality || { score: 0, issues: [], suggestions: [] },
+    stats: result.stats || { mode: payload.modelId, parameters: "N/A", architecture: "N/A", inferenceTimeMs: 0 },
+    parsed
+  };
+}
+var init_vibe_api = __esm({
+  "src/lib/vibe-api.ts"() {
+    init_auth();
+    init_config();
+    init_code_parser();
+  }
+});
+async function runShell(command, options = {}) {
+  const startTime = Date.now();
+  if (options.dryRun) {
+    console.log(chalk8.grey(`[DRY-RUN] Would execute: ${command}`));
+    return {
+      success: true,
+      command,
+      exitCode: 0,
+      stdout: "",
+      stderr: "",
+      duration: 0
+    };
+  }
+  try {
+    const result = await execaCommand(command, {
+      cwd: options.cwd || process.cwd(),
+      env: { ...process.env, ...options.env },
+      timeout: options.timeout || 12e4,
+      // 2 minute default timeout
+      shell: options.shell || true,
+      reject: false,
+      cleanup: true
+    });
+    const duration = Date.now() - startTime;
+    return {
+      success: result.exitCode === 0,
+      command,
+      exitCode: result.exitCode || 0,
+      stdout: result.stdout || "",
+      stderr: result.stderr || "",
+      duration
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    return {
+      success: false,
+      command,
+      exitCode: 1,
+      stdout: "",
+      stderr: error instanceof Error ? error.message : String(error),
+      timedOut: error instanceof Error && error.message.includes("timeout"),
+      duration
+    };
+  }
+}
+function detectPackageManager(cwd = process.cwd()) {
+  const fs3 = __require("fs");
+  if (fs3.existsSync(`${cwd}/pnpm-lock.yaml`)) return "pnpm";
+  if (fs3.existsSync(`${cwd}/yarn.lock`)) return "yarn";
+  if (fs3.existsSync(`${cwd}/bun.lockb`)) return "bun";
+  return "npm";
+}
+function getInstallCommand(cwd = process.cwd()) {
+  const pm = detectPackageManager(cwd);
+  switch (pm) {
+    case "pnpm":
+      return buildCommands.pnpmInstall;
+    case "yarn":
+      return buildCommands.yarnInstall;
+    case "bun":
+      return buildCommands.bunInstall;
+    default:
+      return buildCommands.npmInstall;
+  }
+}
+function getBuildCommand(cwd = process.cwd()) {
+  const pm = detectPackageManager(cwd);
+  switch (pm) {
+    case "pnpm":
+      return buildCommands.pnpmBuild;
+    case "yarn":
+      return buildCommands.yarnBuild;
+    case "bun":
+      return buildCommands.bunBuild;
+    default:
+      return buildCommands.npmBuild;
+  }
+}
+var buildCommands;
+var init_shell = __esm({
+  "src/tools/shell.ts"() {
+    buildCommands = {
+      npmInstall: "npm install",
+      npmBuild: "npm run build",
+      npmTest: "npm test",
+      npmLint: "npm run lint",
+      npmTypecheck: "npm run typecheck",
+      pnpmInstall: "pnpm install",
+      pnpmBuild: "pnpm run build",
+      bunInstall: "bun install",
+      bunBuild: "bun run build",
+      yarnInstall: "yarn install",
+      yarnBuild: "yarn run build"
+    };
+  }
+});
+
+// src/tools/git.ts
+var git_exports = {};
+__export(git_exports, {
+  checkout: () => checkout,
+  commit: () => commit,
+  commitAll: () => commitAll,
+  commitFilesToGithub: () => commitFilesToGithub,
+  createBranch: () => createBranch,
+  createBranchOnGithub: () => createBranchOnGithub,
+  createPullRequestOnGithub: () => createPullRequestOnGithub,
+  default: () => git_default,
+  fullPRWorkflow: () => fullPRWorkflow,
+  getBranch: () => getBranch,
+  getDiff: () => getDiff,
+  getGit: () => getGit,
+  getLog: () => getLog,
+  getRemote: () => getRemote,
+  getStatus: () => getStatus,
+  init: () => init,
+  isRepo: () => isRepo,
+  pull: () => pull,
+  push: () => push,
+  stage: () => stage,
+  stageAll: () => stageAll
+});
+function getGit(cwd = process.cwd()) {
+  return simpleGit(cwd);
+}
+async function getStatus(cwd = process.cwd()) {
+  const git = getGit(cwd);
+  const status = await git.status();
+  return {
+    current: status.current,
+    tracking: status.tracking,
+    ahead: status.ahead,
+    behind: status.behind,
+    staged: status.staged,
+    modified: status.modified,
+    untracked: status.not_added,
+    conflicted: status.conflicted
+  };
+}
+async function getBranch(cwd = process.cwd()) {
+  const git = getGit(cwd);
+  const branchSummary = await git.branch();
+  return branchSummary.current;
+}
+async function getLog(cwd = process.cwd(), maxCount = 10) {
+  const git = getGit(cwd);
+  const log = await git.log({ maxCount });
+  return log.all.map((entry) => ({
+    hash: entry.hash,
+    date: entry.date,
+    message: entry.message,
+    author_name: entry.author_name,
+    author_email: entry.author_email
+  }));
+}
+async function stage(files, cwd = process.cwd()) {
+  const git = getGit(cwd);
+  await git.add(files);
+}
+async function stageAll(cwd = process.cwd()) {
+  const git = getGit(cwd);
+  await git.add(".");
+}
+async function commit(message, cwd = process.cwd()) {
+  const git = getGit(cwd);
+  try {
+    const result = await git.commit(message);
+    return {
+      success: true,
+      commitSha: result.commit,
+      message: result.summary.changes + " file(s) changed"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function commitAll(message, cwd = process.cwd()) {
+  await stageAll(cwd);
+  return commit(message, cwd);
+}
+async function push(options = {}, cwd = process.cwd()) {
+  const git = getGit(cwd);
+  try {
+    const result = await git.push(options.remote || "origin", options.branch || "HEAD", {
+      "--force": options.force || false
+    });
+    return {
+      success: true,
+      commitSha: result.pushed[0]?.hash,
+      message: "Push successful"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function pull(options = {}, cwd = process.cwd()) {
+  const git = getGit(cwd);
+  try {
+    const result = await git.pull(options.remote || "origin", options.branch || "HEAD");
+    return {
+      success: true,
+      message: "Pull successful"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function createBranch(branchName, options = {}, cwd = process.cwd()) {
+  const git = getGit(cwd);
+  try {
+    if (options.checkout) {
+      await git.checkoutLocalBranch(branchName);
+    } else {
+      await git.branch([branchName]);
+    }
+    return {
+      success: true,
+      message: `Branch ${branchName} created`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function checkout(branchName, cwd = process.cwd()) {
+  const git = getGit(cwd);
+  try {
+    await git.checkout(branchName);
+    return {
+      success: true,
+      message: `Switched to branch ${branchName}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function getDiff(options = {}, cwd = process.cwd()) {
+  const git = getGit(cwd);
+  if (options.staged) {
+    return git.diff(["--staged"]);
+  }
+  if (options.from && options.to) {
+    return git.diff([options.from, options.to]);
+  }
+  return git.diff();
+}
+async function isRepo(cwd = process.cwd()) {
+  const git = getGit(cwd);
+  return git.checkIsRepo();
+}
+async function init(cwd = process.cwd()) {
+  const git = getGit(cwd);
+  try {
+    await git.init();
+    return {
+      success: true,
+      message: "Git repository initialized"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function getRemote(cwd = process.cwd()) {
+  const git = getGit(cwd);
+  const remotes = await git.getRemotes(true);
+  const origin = remotes.find((r) => r.name === "origin");
+  return origin?.refs.fetch || null;
+}
+async function callGithubSync(action, params) {
+  const apiKey = await getGithubToken();
+  if (!apiKey) {
+    throw new Error('GitHub token not configured. Run "vibe-weaver login --github" first.');
+  }
+  const supabaseUrl = getSupabaseUrl();
+  const endpoint = `${supabaseUrl}/functions/v1/github-ai-sync`;
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      action,
+      token: apiKey,
+      ...params
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(`GitHub API error: ${error.error || error.message}`);
+  }
+  return response.json();
+}
+async function commitFilesToGithub(options) {
+  try {
+    const result = await callGithubSync("commit_files", options);
+    return {
+      success: true,
+      commitSha: result.commitSha,
+      message: `Committed ${result.files?.length || 0} file(s) to ${options.branch}`,
+      files: result.files
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function createBranchOnGithub(options) {
+  try {
+    const result = await callGithubSync("create_branch", options);
+    return {
+      success: true,
+      commitSha: result.sha,
+      message: `Created branch ${options.newBranch} from ${options.fromBranch}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function createPullRequestOnGithub(options) {
+  try {
+    const result = await callGithubSync("create_pr", options);
+    return {
+      success: true,
+      prNumber: result.prNumber,
+      prUrl: result.prUrl
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function fullPRWorkflow(options) {
+  console.log(chalk8.blue("\n=== GitHub PR Workflow ==="));
+  console.log(chalk8.gray("1. Creating branch..."));
+  const branchResult = await createBranchOnGithub({
+    owner: options.owner,
+    repo: options.repo,
+    newBranch: options.branchName,
+    fromBranch: options.baseBranch
+  });
+  if (!branchResult.success) {
+    return { success: false, error: `Failed to create branch: ${branchResult.error}` };
+  }
+  console.log(chalk8.green(`   \u2713 Branch ${options.branchName} created`));
+  console.log(chalk8.gray("2. Committing files..."));
+  const commitResult = await commitFilesToGithub({
+    owner: options.owner,
+    repo: options.repo,
+    branch: options.branchName,
+    files: options.files,
+    commitMessage: options.commitMessage
+  });
+  if (!commitResult.success) {
+    return { success: false, error: `Failed to commit: ${commitResult.error}` };
+  }
+  console.log(chalk8.green(`   \u2713 Committed ${commitResult.files?.length || 0} file(s)`));
+  console.log(chalk8.gray("3. Creating pull request..."));
+  const prResult = await createPullRequestOnGithub({
+    owner: options.owner,
+    repo: options.repo,
+    title: options.prTitle,
+    body: options.prBody,
+    head: options.branchName,
+    base: options.baseBranch
+  });
+  if (!prResult.success) {
+    return { success: false, error: `Failed to create PR: ${prResult.error}` };
+  }
+  console.log(chalk8.green(`   \u2713 PR created: ${prResult.prUrl}`));
+  console.log(chalk8.blue("===========================\n"));
+  return {
+    success: true,
+    branch: options.branchName,
+    commitSha: commitResult.commitSha,
+    prUrl: prResult.prUrl,
+    prNumber: prResult.prNumber
+  };
+}
+var git_default;
+var init_git = __esm({
+  "src/tools/git.ts"() {
+    init_auth();
+    init_config();
+    git_default = {
+      getGit,
+      getStatus,
+      getBranch,
+      getLog,
+      stage,
+      stageAll,
+      commit,
+      commitAll,
+      push,
+      pull,
+      createBranch,
+      checkout,
+      getDiff,
+      isRepo,
+      init,
+      getRemote,
+      commitFilesToGithub,
+      createBranchOnGithub,
+      createPullRequestOnGithub,
+      fullPRWorkflow
+    };
+  }
+});
+
+// src/mcp/index.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  MCPClient: () => MCPClient,
+  MCPManager: () => MCPManager,
+  default: () => mcp_default,
+  getDefaultMCPServers: () => getDefaultMCPServers
+});
+function getDefaultMCPServers() {
+  const supabaseUrl = getSupabaseUrl();
+  return [
+    { name: "github-mcp", url: `${supabaseUrl}/functions/v1/github-mcp`, enabled: true },
+    { name: "filesystem-mcp", url: `${supabaseUrl}/functions/v1/filesystem-mcp`, enabled: true },
+    { name: "supabase-mcp", url: `${supabaseUrl}/functions/v1/supabase-mcp`, enabled: true },
+    { name: "roblox-mcp", url: `${supabaseUrl}/functions/v1/roblox-mcp`, enabled: true },
+    { name: "linear-mcp", url: `${supabaseUrl}/functions/v1/linear-mcp`, enabled: false },
+    { name: "notion-mcp", url: `${supabaseUrl}/functions/v1/notion-mcp`, enabled: false },
+    { name: "slack-mcp", url: `${supabaseUrl}/functions/v1/slack-mcp`, enabled: false },
+    { name: "discord-mcp", url: `${supabaseUrl}/functions/v1/discord-mcp`, enabled: false },
+    { name: "vercel-mcp", url: `${supabaseUrl}/functions/v1/vercel-mcp`, enabled: false },
+    { name: "stripe-mcp", url: `${supabaseUrl}/functions/v1/stripe-mcp`, enabled: false }
+  ];
+}
+var MCPClient, MCPManager, mcp_default;
+var init_mcp = __esm({
+  "src/mcp/index.ts"() {
+    init_config();
+    MCPClient = class {
+      url;
+      initialized = false;
+      serverInfo = null;
+      capabilities = {};
+      requestId = 0;
+      constructor(url) {
+        this.url = url;
+      }
+      /**
+       * Send a JSON-RPC request
+       */
+      async request(method, params) {
+        const id = ++this.requestId;
+        const response = await fetch(this.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id,
+            method,
+            params: params || {}
+          })
+        });
+        if (!response.ok) {
+          throw new Error(`MCP request failed: ${response.status} ${response.statusText}`);
+        }
+        const result = await response.json();
+        if (result.error) {
+          throw new Error(`MCP error: ${result.error.message}`);
+        }
+        return result.result;
+      }
+      /**
+       * Initialize the MCP connection
+       */
+      async initialize() {
+        try {
+          const result = await this.request("initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: {
+              name: "vibe-weaver-cli",
+              version: "1.0.0"
+            }
+          });
+          this.initialized = true;
+          this.serverInfo = result.serverInfo;
+          this.capabilities = result.capabilities;
+          return result;
+        } catch (error) {
+          throw new Error(`Failed to initialize MCP server: ${error instanceof Error ? error.message : error}`);
+        }
+      }
+      /**
+       * List available tools
+       */
+      async listTools() {
+        if (!this.initialized) {
+          await this.initialize();
+        }
+        return this.request("tools/list");
+      }
+      /**
+       * Call a tool
+       */
+      async callTool(name, args) {
+        if (!this.initialized) {
+          await this.initialize();
+        }
+        return this.request("tools/call", {
+          name,
+          arguments: args
+        });
+      }
+      /**
+       * Check if server is alive
+       */
+      async ping() {
+        try {
+          await this.request("ping");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      getServerInfo() {
+        return this.serverInfo;
+      }
+      isInitialized() {
+        return this.initialized;
+      }
+    };
+    MCPManager = class {
+      clients = /* @__PURE__ */ new Map();
+      servers = [];
+      constructor(servers) {
+        this.servers = servers || getDefaultMCPServers();
+      }
+      /**
+       * Initialize all enabled MCP servers
+       */
+      async initializeAll() {
+        const success = [];
+        const failed = [];
+        for (const server of this.servers) {
+          if (!server.enabled) continue;
+          const client = new MCPClient(server.url);
+          try {
+            const result = await client.initialize();
+            this.clients.set(server.name, client);
+            success.push(`${server.name} (${result.serverInfo.version})`);
+            console.log(chalk8.green(`\u2713 Connected to ${server.name}`));
+          } catch (error) {
+            failed.push({
+              name: server.name,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            console.log(chalk8.red(`\u2717 Failed to connect to ${server.name}`));
+          }
+        }
+        return { success, failed };
+      }
+      /**
+       * List all available tools from connected servers
+       */
+      async listAllTools() {
+        const results = [];
+        for (const [name, client] of this.clients) {
+          try {
+            const result = await client.listTools();
+            results.push({ server: name, tools: result.tools });
+          } catch (error) {
+            console.warn(chalk8.yellow(`Warning: Failed to list tools from ${name}: ${error}`));
+          }
+        }
+        return results;
+      }
+      /**
+       * Call a tool on a specific server
+       */
+      async callTool(serverName, toolName, args) {
+        const client = this.clients.get(serverName);
+        if (!client) {
+          throw new Error(`MCP server "${serverName}" not connected`);
+        }
+        return client.callTool(toolName, args);
+      }
+      /**
+       * Get status of all servers
+       */
+      getStatus() {
+        const status = [];
+        for (const server of this.servers) {
+          const client = this.clients.get(server.name);
+          status.push({
+            name: server.name,
+            connected: !!client && client.isInitialized(),
+            tools: 0
+            // Would need to cache tool list
+          });
+        }
+        return status;
+      }
+      /**
+       * Enable/disable a server
+       */
+      setServerEnabled(name, enabled) {
+        const server = this.servers.find((s) => s.name === name);
+        if (server) {
+          server.enabled = enabled;
+        }
+      }
+    };
+    mcp_default = {
+      MCPClient,
+      MCPManager,
+      getDefaultMCPServers
+    };
+  }
+});
+
+// src/agent/swarm.ts
+var swarm_exports = {};
+__export(swarm_exports, {
+  default: () => swarm_default,
+  planSubTasks: () => planSubTasks,
+  runSwarm: () => runSwarm
+});
+async function planSubTasks(goal) {
+  const result = await generateCode({
+    goal: `Break down this complex goal into 3-5 independent subtasks that can run in parallel. List only the subtask descriptions, one per line:
+
+${goal}`,
+    modelId: "balanced"
+  });
+  const lines = result.explanation.split("\n").filter((line) => line.trim().length > 0);
+  return lines.slice(0, 5);
+}
+async function executeSubTask(task, baseDir) {
+  task.status = "running";
+  try {
+    console.log(chalk8.gray(`[${task.id}] Starting: ${task.name}`));
+    const result = await generateCode({
+      goal: task.goal,
+      modelId: "balanced"
+    });
+    if (result.parsed.blocks.length > 0) {
+      const writeResult = await writeCodeBlocks(result.parsed.blocks, baseDir);
+      if (writeResult.failed.length > 0) {
+        task.status = "failed";
+        task.error = `Failed to write files: ${writeResult.failed.map((f) => f.path).join(", ")}`;
+      } else {
+        task.status = "completed";
+        task.result = `Generated ${writeResult.success.length} files: ${writeResult.success.join(", ")}`;
+      }
+    } else {
+      task.status = "completed";
+      task.result = result.explanation;
+    }
+    console.log(chalk8.green(`[${task.id}] Completed: ${task.name}`));
+  } catch (error) {
+    task.status = "failed";
+    task.error = error instanceof Error ? error.message : String(error);
+    console.log(chalk8.red(`[${task.id}] Failed: ${task.name} - ${task.error}`));
+  }
+  return task;
+}
+async function runSwarm(goal, options = {}) {
+  const maxParallel = options.maxParallel || 3;
+  const baseDir = options.baseDir || process.cwd();
+  console.log(chalk8.cyan("\n\u{1F3AF} Vibe-Weaver Agent Swarm"));
+  console.log(chalk8.gray(`Planning subtasks for: ${goal.substring(0, 50)}...
+`));
+  const subtaskGoals = await planSubTasks(goal);
+  if (subtaskGoals.length === 0) {
+    console.log(chalk8.yellow("Could not generate subtasks. Running as single task."));
+    subtaskGoals.push(goal);
+  }
+  console.log(chalk8.gray(`Found ${subtaskGoals.length} subtasks:
+`));
+  for (let i = 0; i < subtaskGoals.length; i++) {
+    console.log(chalk8.gray(`  ${i + 1}. ${subtaskGoals[i].substring(0, 60)}...`));
+  }
+  console.log();
+  const tasks = subtaskGoals.map((subGoal, i) => ({
+    id: `agent-${i + 1}`,
+    name: `Agent ${i + 1}`,
+    goal: subGoal,
+    status: "pending"
+  }));
+  const results = [];
+  for (let i = 0; i < tasks.length; i += maxParallel) {
+    const batch = tasks.slice(i, i + maxParallel);
+    console.log(chalk8.cyan(`
+--- Running batch ${Math.floor(i / maxParallel) + 1} (${batch.length} agents) ---
+`));
+    const batchResults = await Promise.all(
+      batch.map((task) => executeSubTask(task, baseDir))
+    );
+    results.push(...batchResults);
+    const completed2 = results.filter((t) => t.status === "completed").length;
+    const failed2 = results.filter((t) => t.status === "failed").length;
+    console.log(chalk8.gray(`
+Progress: ${completed2} completed, ${failed2} failed
+`));
+  }
+  const completed = results.filter((t) => t.status === "completed").length;
+  const failed = results.filter((t) => t.status === "failed").length;
+  console.log(chalk8.cyan("\n=== Swarm Results ==="));
+  console.log(chalk8.green(`Completed: ${completed}`));
+  if (failed > 0) {
+    console.log(chalk8.red(`Failed: ${failed}`));
+  }
+  for (const task of results) {
+    if (task.status === "completed") {
+      console.log(chalk8.green(`  \u2713 ${task.name}: ${task.result?.substring(0, 50)}...`));
+    } else if (task.status === "failed") {
+      console.log(chalk8.red(`  \u2717 ${task.name}: ${task.error}`));
+    }
+  }
+  return {
+    success: failed === 0,
+    completed,
+    failed,
+    results
+  };
+}
+var swarm_default;
+var init_swarm = __esm({
+  "src/agent/swarm.ts"() {
+    init_vibe_api();
+    init_code_parser();
+    swarm_default = {
+      runSwarm,
+      planSubTasks
+    };
+  }
+});
+
+// src/agent/tasks.ts
+var tasks_exports = {};
+__export(tasks_exports, {
+  default: () => tasks_default,
+  displayTaskStatus: () => displayTaskStatus,
+  getTaskStatus: () => getTaskStatus,
+  streamTaskLogs: () => streamTaskLogs,
+  submitTask: () => submitTask,
+  waitForTask: () => waitForTask
+});
+async function submitTask(options) {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+  const supabaseUrl = getSupabaseUrl();
+  console.log(chalk8.gray(`
+Submitting background task: ${options.goal.substring(0, 50)}...`));
+  const response = await fetch(`${supabaseUrl}/functions/v1/automation-executor`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      goal: options.goal,
+      platform: options.platform || "web",
+      language: options.language || "typescript",
+      modelId: options.modelId || "balanced"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(`Failed to submit task: ${error.error || error.message}`);
+  }
+  const result = await response.json();
+  console.log(chalk8.green(`\u2713 Task submitted: ${result.id}`));
+  console.log(chalk8.gray(`  Use "vibe-weaver task status ${result.id}" to check progress
+`));
+  return {
+    id: result.id,
+    status: result.status || "pending"
+  };
+}
+async function getTaskStatus(taskId) {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+  const supabaseUrl = getSupabaseUrl();
+  const response = await fetch(`${supabaseUrl}/functions/v1/automation-executor?id=${taskId}`, {
+    method: "GET",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(`Failed to get task status: ${error.error || error.message}`);
+  }
+  return response.json();
+}
+async function* streamTaskLogs(taskId) {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+  const supabaseUrl = getSupabaseUrl();
+  const response = await fetch(`${supabaseUrl}/functions/v1/automation-executor/logs?id=${taskId}`, {
+    method: "GET",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to get task logs: ${response.status}`);
+  }
+  const reader = response.body?.getReader();
+  const decoder = new TextDecoder();
+  if (!reader) {
+    throw new Error("Could not read response body");
+  }
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      yield decoder.decode(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function waitForTask(taskId, options = {}) {
+  const pollInterval = options.pollInterval || 5e3;
+  while (true) {
+    const status = await getTaskStatus(taskId);
+    if (options.onProgress) {
+      options.onProgress(status);
+    }
+    if (status.status === "completed") {
+      return status;
+    }
+    if (status.status === "failed") {
+      throw new Error(`Task failed: ${status.error}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+}
+function displayTaskStatus(status) {
+  const statusColor = {
+    pending: chalk8.yellow,
+    running: chalk8.blue,
+    completed: chalk8.green,
+    failed: chalk8.red
+  };
+  console.log(chalk8.bold(`
+Task: ${status.id}`));
+  console.log(chalk8.gray(`Status: ${statusColor[status.status] ? statusColor[status.status](status.status) : chalk8.gray(status.status)}`));
+  if (status.progress !== void 0) {
+    console.log(chalk8.gray(`Progress: ${status.progress}%`));
+  }
+  if (status.result) {
+    console.log(chalk8.gray(`
+Result:`));
+    console.log(status.result);
+  }
+  if (status.error) {
+    console.log(chalk8.red(`
+Error: ${status.error}`));
+  }
+  console.log(chalk8.gray(`
+Created: ${new Date(status.createdAt).toLocaleString()}`));
+  console.log(chalk8.gray(`Updated: ${new Date(status.updatedAt).toLocaleString()}`));
+}
+var tasks_default;
+var init_tasks = __esm({
+  "src/agent/tasks.ts"() {
+    init_auth();
+    init_config();
+    tasks_default = {
+      submitTask,
+      getTaskStatus,
+      streamTaskLogs,
+      waitForTask,
+      displayTaskStatus
+    };
+  }
+});
+
+// src/agent/deploy.ts
+var deploy_exports = {};
+__export(deploy_exports, {
+  default: () => deploy_default,
+  deploy: () => deploy,
+  submitDeploy: () => submitDeploy,
+  verifyDeploy: () => verifyDeploy
+});
+async function submitDeploy(options) {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    throw new Error('Not logged in. Run "vibe-weaver login" first.');
+  }
+  const supabaseUrl = getSupabaseUrl();
+  console.log(chalk8.cyan("\n\u{1F680} Submitting deployment..."));
+  const response = await fetch(`${supabaseUrl}/functions/v1/deploy-bridge`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      projectId: options.projectId,
+      platform: options.platform || "web"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: "Unknown error" }));
+    return {
+      success: false,
+      error: error.error || error.message
+    };
+  }
+  const result = await response.json();
+  console.log(chalk8.green(`\u2713 Deployment submitted`));
+  console.log(chalk8.gray(`  URL: ${result.url}`));
+  return {
+    success: true,
+    url: result.url,
+    projectId: result.projectId
+  };
+}
+async function verifyDeploy(url, options = {}) {
+  const timeout = options.timeout || 6e4;
+  const expectedStatus = options.expectedStatus || 200;
+  console.log(chalk8.gray(`
+Verifying deployment at ${url}...`));
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    try {
+      const response = await fetch(url, { method: "HEAD" });
+      if (response.status === expectedStatus) {
+        console.log(chalk8.green(`\u2713 Deployment verified (${response.status})`));
+        return { success: true, status: response.status };
+      }
+      if (response.status === 404) {
+        console.log(chalk8.yellow(`  Still deploying... (${response.status})`));
+      } else {
+        console.log(chalk8.yellow(`  Unexpected status: ${response.status}`));
+      }
+    } catch (error) {
+      console.log(chalk8.yellow(`  Waiting for deployment...`));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 5e3));
+  }
+  console.log(chalk8.red(`\u2717 Deployment verification timed out`));
+  return {
+    success: false,
+    error: "Deployment verification timed out"
+  };
+}
+async function deploy(options = {}) {
+  const verify = options.verify !== false;
+  console.log(chalk8.cyan("\n\u{1F680} Vibe-Weaver Deploy"));
+  if (options.cwd) {
+    console.log(chalk8.gray("\nBuilding project locally..."));
+    const buildResult = await runShell("npm run build", { cwd: options.cwd });
+    if (!buildResult.success) {
+      return {
+        success: false,
+        error: `Build failed: ${buildResult.stderr}`
+      };
+    }
+    console.log(chalk8.green("\u2713 Build successful"));
+  }
+  console.log(chalk8.gray("\nSubmitting to Vibe-Weaver..."));
+  const deployResult = await submitDeploy({
+    projectId: options.projectId,
+    platform: options.platform
+  });
+  if (!deployResult.success) {
+    return deployResult;
+  }
+  if (verify && deployResult.url) {
+    const verifyResult = await verifyDeploy(deployResult.url);
+    if (!verifyResult.success) {
+      return {
+        success: false,
+        url: deployResult.url,
+        error: verifyResult.error
+      };
+    }
+  }
+  return deployResult;
+}
+var deploy_default;
+var init_deploy = __esm({
+  "src/agent/deploy.ts"() {
+    init_auth();
+    init_config();
+    init_shell();
+    deploy_default = {
+      submitDeploy,
+      verifyDeploy,
+      deploy
+    };
+  }
+});
+
+// src/index.ts
+init_auth();
+init_vibe_api();
+init_code_parser();
+
+// src/tools/files.ts
+init_code_parser();
+async function readFile(filePath, baseDir = process.cwd()) {
+  try {
+    const fullPath = path2.isAbsolute(filePath) ? filePath : path2.join(baseDir, filePath);
+    const content = await fs2.readFile(fullPath, "utf-8");
+    return { success: true, path: filePath, content };
+  } catch (error) {
+    return {
+      success: false,
+      path: filePath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function writeFile(filePath, content, baseDir = process.cwd(), options = {}) {
+  try {
+    const fullPath = path2.isAbsolute(filePath) ? filePath : path2.join(baseDir, filePath);
+    const dir = path2.dirname(fullPath);
+    let oldContent = "";
+    try {
+      oldContent = await fs2.readFile(fullPath, "utf-8");
+    } catch {
+    }
+    const diff = options.showDiff && oldContent ? generateDiff(oldContent, content, filePath) : void 0;
+    if (options.dryRun) {
+      return { success: true, path: filePath, diff };
+    }
+    await fs2.mkdir(dir, { recursive: true });
+    await fs2.writeFile(fullPath, content, "utf-8");
+    return { success: true, path: filePath, diff };
+  } catch (error) {
+    return {
+      success: false,
+      path: filePath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function listDir(dirPath = ".", baseDir = process.cwd()) {
+  const fullPath = path2.isAbsolute(dirPath) ? dirPath : path2.join(baseDir, dirPath);
+  try {
+    const entries = await fs2.readdir(fullPath, { withFileTypes: true });
+    return entries.map((entry) => ({
+      path: entry.name,
+      isDirectory: entry.isDirectory()
+    }));
+  } catch (error) {
+    throw new Error(`Failed to list directory: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function grep(pattern, baseDir = process.cwd(), options = {}) {
+  const results = [];
+  const fs3 = await import('fs/promises');
+  async function searchDir(dir) {
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.name === "node_modules" || entry.name === ".git" || entry.name.startsWith(".")) {
+        continue;
+      }
+      if (entry.isDirectory() && options.recursive !== false) {
+        await searchDir(fullPath);
+      } else if (entry.isFile()) {
+        if (options.filePattern && !new RegExp(options.filePattern).test(entry.name)) {
+          continue;
+        }
+        try {
+          const content = await fs3.readFile(fullPath, "utf-8");
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(pattern)) {
+              results.push({
+                file: path2.relative(baseDir, fullPath),
+                line: i + 1,
+                content: lines[i].trim()
+              });
+            }
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  await searchDir(baseDir);
+  return results;
+}
+
+// src/index.ts
+init_shell();
+init_git();
+var program = new Command();
+program.name("vibe-weaver").description("Vibe-Weaver CLI - Production-ready terminal agent that beats Claude Code").version("1.0.0");
+program.command("login").description("Log in with your Vibe-Weaver API key").option("-k, --api-key <key>", "API key (vw_...)").option("-o, --open", "Open browser to create API key").option("-g, --github", "Also configure GitHub token").action(async (options) => {
+  try {
+    await login({ apiKey: options.apiKey, openBrowser: options.open });
+    if (options.github) {
+      await loginGithub();
+    }
+  } catch (error) {
+    console.error(chalk8.red("Login failed:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("logout").description("Log out and clear stored credentials").action(async () => {
+  try {
+    await logout();
+  } catch (error) {
+    console.error(chalk8.red("Logout failed:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("whoami").description("Show current user info and credits").action(async () => {
+  try {
+    await whoami();
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("generate").description("Generate code using Vibe-Weaver AI").option("-g, --goal <text>", "Goal/prompt for code generation").option("-p, --platform <type>", "Platform: web, roblox, mobile, desktop, api", "web").option("-l, --language <lang>", "Language: typescript, javascript, python, lua, rust", "typescript").option("-m, --mode <mode>", "Model: fast, balanced, deep_reasoning, refactor", "balanced").option("-o, --out <dir>", "Output directory", ".").option("-y, --yes", "Auto-approve file writes").option("-d, --dry-run", "Show what would be generated without writing").action(async (options) => {
+  if (!options.goal) {
+    console.error(chalk8.red("Error: --goal is required"));
+    process.exit(1);
+  }
+  try {
+    const loggedIn = await isLoggedIn();
+    if (!loggedIn) {
+      console.error(chalk8.red('Not logged in. Run "vibe-weaver login" first.'));
+      process.exit(1);
+    }
+    console.log(chalk8.cyan("\n\u{1F3A8} Vibe-Weaver Code Generation"));
+    console.log(chalk8.gray(`Mode: ${options.mode} | Platform: ${options.platform} | Language: ${options.language}`));
+    console.log(chalk8.gray(`Cost: ~${getCreditCost(options.mode)} credits
+`));
+    const result = await generateCode({
+      goal: options.goal,
+      platform: options.platform,
+      language: options.language,
+      modelId: options.mode
+    });
+    console.log(chalk8.gray("Explanation:"));
+    console.log(result.explanation);
+    console.log(chalk8.gray("\nQuality Score:"), `${result.quality.score}/100`);
+    if (result.parsed.blocks.length > 0) {
+      console.log(chalk8.gray("\nGenerated Files:"));
+      for (const block of result.parsed.blocks) {
+        console.log(`  - ${chalk8.green(block.path)} (${block.language})`);
+      }
+      if (!options.dryRun) {
+        const writeResult = await writeCodeBlocks(result.parsed.blocks, path2.resolve(options.out));
+        console.log(chalk8.gray("\nWritten:"));
+        for (const file of writeResult.success) {
+          console.log(`  \u2713 ${file}`);
+        }
+        if (writeResult.failed.length > 0) {
+          console.log(chalk8.red("\nFailed:"));
+          for (const file of writeResult.failed) {
+            console.log(`  \u2717 ${file.path}: ${file.error}`);
+          }
+        }
+      } else {
+        console.log(chalk8.yellow("\n[DRY-RUN] Files not written"));
+      }
+    }
+    console.log(chalk8.green("\n\u2713 Generation complete"));
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("run").description("Run the interactive agent loop (REPL)").option("-c, --cwd <dir>", "Working directory", process.cwd()).option("-y, --yes", "Auto-approve all operations").option("-d, --dry-run", "Preview changes without applying").action(async (options) => {
+  const loggedIn = await isLoggedIn();
+  if (!loggedIn) {
+    console.error(chalk8.red('Not logged in. Run "vibe-weaver login" first.'));
+    process.exit(1);
+  }
+  console.log(chalk8.cyan("\u{1F3AF} Vibe-Weaver Interactive Agent"));
+  console.log(chalk8.gray("Type your goal or task. Press Ctrl+C to exit.\n"));
+  const readline = await import('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const askQuestion = () => {
+    rl.question(chalk8.green("\n> "), async (input) => {
+      if (!input.trim()) {
+        askQuestion();
+        return;
+      }
+      if (input.toLowerCase() === "exit" || input.toLowerCase() === "quit") {
+        rl.close();
+        return;
+      }
+      try {
+        console.log(chalk8.gray("\nGenerating code..."));
+        const result = await generateCode({ goal: input });
+        if (result.parsed.blocks.length > 0) {
+          const writeResult = await writeCodeBlocks(result.parsed.blocks, options.cwd);
+          console.log(chalk8.green("\n\u2713 Generated files:"));
+          for (const file of writeResult.success) {
+            console.log(`  \u2713 ${file}`);
+          }
+          if (writeResult.failed.length > 0) {
+            console.log(chalk8.red("\n\u2717 Failed:"));
+            for (const file of writeResult.failed) {
+              console.log(`  \u2717 ${file.path}: ${file.error}`);
+            }
+          }
+        }
+      } catch (error) {
+        console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+      }
+      askQuestion();
+    });
+  };
+  askQuestion();
+});
+program.command("read").description("Read a file").argument("<file>", "File path to read").option("-c, --cwd <dir>", "Working directory", process.cwd()).action(async (file, options) => {
+  try {
+    const result = await readFile(file, options.cwd);
+    if (result.success && result.content) {
+      console.log(result.content);
+    } else {
+      console.error(chalk8.red(`Error: ${result.error}`));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("write").description("Write content to a file").argument("<file>", "File path to write").argument("<content>", "Content to write").option("-c, --cwd <dir>", "Working directory", process.cwd()).option("-d, --dry-run", "Preview without writing").action(async (file, content, options) => {
+  try {
+    const result = await writeFile(file, content, options.cwd, { dryRun: options.dryRun });
+    if (result.success) {
+      console.log(chalk8.green(`\u2713 Written to ${file}`));
+    } else {
+      console.error(chalk8.red(`Error: ${result.error}`));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("ls").description("List files in a directory").argument("[dir]", "Directory to list", ".").option("-c, --cwd <dir>", "Working directory", process.cwd()).action(async (dir, options) => {
+  try {
+    const entries = await listDir(dir, options.cwd);
+    for (const entry of entries) {
+      const prefix = entry.isDirectory ? chalk8.blue("\u{1F4C1}") : chalk8.gray("\u{1F4C4}");
+      console.log(`${prefix} ${entry.path}`);
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("grep").description("Search for a pattern in files").argument("<pattern>", "Pattern to search for").option("-c, --cwd <dir>", "Working directory", process.cwd()).option("-r, --recursive", "Search recursively", true).action(async (pattern, options) => {
+  try {
+    const results = await grep(pattern, options.cwd, { recursive: options.recursive });
+    if (results.length === 0) {
+      console.log(chalk8.yellow("No matches found"));
+      return;
+    }
+    for (const result of results) {
+      console.log(`${chalk8.gray(`${result.file}:${result.line}`)} ${result.content}`);
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("exec").description("Execute a shell command").argument("<command>", "Command to execute").option("-c, --cwd <dir>", "Working directory", process.cwd()).option("-d, --dry-run", "Preview without executing").action(async (command, options) => {
+  try {
+    if (options.dryRun) {
+      console.log(chalk8.yellow(`[DRY-RUN] Would execute: ${command}`));
+      return;
+    }
+    console.log(chalk8.gray(`$ ${command}`));
+    const result = await runShell(command, { cwd: options.cwd });
+    if (result.stdout) console.log(result.stdout);
+    if (result.stderr) console.error(chalk8.red(result.stderr));
+    process.exit(result.exitCode);
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("status").description("Show git status").option("-c, --cwd <dir>", "Working directory", process.cwd()).action(async (options) => {
+  try {
+    const status = await getStatus(options.cwd);
+    console.log(chalk8.gray(`Branch: ${status.current || "(none)"}`));
+    if (status.tracking) {
+      console.log(chalk8.gray(`Tracking: ${status.tracking}`));
+    }
+    if (status.staged.length > 0) {
+      console.log(chalk8.green("\nStaged:"));
+      for (const file of status.staged) {
+        console.log(`  ${chalk8.green("+")} ${file}`);
+      }
+    }
+    if (status.modified.length > 0) {
+      console.log(chalk8.yellow("\nModified:"));
+      for (const file of status.modified) {
+        console.log(`  ${chalk8.yellow("M")} ${file}`);
+      }
+    }
+    if (status.untracked.length > 0) {
+      console.log(chalk8.gray("\nUntracked:"));
+      for (const file of status.untracked) {
+        console.log(`  ${chalk8.gray("?")} ${file}`);
+      }
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("commit").description("Commit changes with a message").argument("<message>", "Commit message").option("-c, --cwd <dir>", "Working directory", process.cwd()).option("-a, --all", "Stage all changes", false).action(async (message, options) => {
+  try {
+    if (options.all) {
+      const result = await commitAll(message, options.cwd);
+      if (result.success) {
+        console.log(chalk8.green(`\u2713 Committed: ${result.message}`));
+      } else {
+        console.error(chalk8.red(`Error: ${result.error}`));
+        process.exit(1);
+      }
+    } else {
+      const result = await commit(message, options.cwd);
+      if (result.success) {
+        console.log(chalk8.green(`\u2713 Committed: ${result.message}`));
+      } else {
+        console.error(chalk8.red(`Error: ${result.error}`));
+        process.exit(1);
+      }
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("push").description("Push to remote").option("-c, --cwd <dir>", "Working directory", process.cwd()).option("-f, --force", "Force push", false).action(async (options) => {
+  try {
+    const result = await push({ force: options.force }, options.cwd);
+    if (result.success) {
+      console.log(chalk8.green("\u2713 Pushed successfully"));
+    } else {
+      console.error(chalk8.red(`Error: ${result.error}`));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("pull").description("Pull from remote").option("-c, --cwd <dir>", "Working directory", process.cwd()).action(async (options) => {
+  try {
+    const result = await pull({}, options.cwd);
+    if (result.success) {
+      console.log(chalk8.green("\u2713 Pulled successfully"));
+    } else {
+      console.error(chalk8.red(`Error: ${result.error}`));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("pr").description("Create a pull request with AI-generated summary").option("-t, --title <title>", "PR title").option("-b, --body <body>", "PR body").option("-o, --owner <owner>", "Repository owner").option("-r, --repo <repo>", "Repository name").option("-B, --base <branch>", "Base branch", "main").option("-c, --cwd <dir>", "Working directory", process.cwd()).action(async (options) => {
+  try {
+    const isGitRepo = await isRepo(options.cwd);
+    if (!isGitRepo) {
+      console.error(chalk8.red("Not a git repository"));
+      process.exit(1);
+    }
+    const currentBranch = await getBranch(options.cwd);
+    let prTitle = options.title;
+    let prBody = options.body;
+    if (!prTitle || !prBody) {
+      console.log(chalk8.gray("Generating PR description with AI..."));
+      const result2 = await generateCode({
+        goal: `Create a descriptive pull request title and body for the changes in branch ${currentBranch}. Focus on what changed and why.`,
+        modelId: "balanced"
+      });
+      const lines = result2.explanation.split("\n").filter((l) => l.trim());
+      if (!prTitle) prTitle = lines[0] || `Update ${currentBranch}`;
+      if (!prBody) prBody = lines.slice(1).join("\n") || result2.explanation;
+    }
+    if (!options.owner || !options.repo) {
+      const remote = await Promise.resolve().then(() => (init_git(), git_exports)).then((m) => m.getRemote(options.cwd));
+      if (remote) {
+        const match = remote.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+        if (match) {
+          options.owner = options.owner || match[1];
+          options.repo = options.repo || match[2];
+        }
+      }
+    }
+    if (!options.owner || !options.repo) {
+      const answers = await inquirer.prompt([
+        { type: "input", name: "owner", message: "Repository owner:", when: !options.owner },
+        { type: "input", name: "repo", message: "Repository name:", when: !options.repo }
+      ]);
+      options.owner = options.owner || answers.owner;
+      options.repo = options.repo || answers.repo;
+    }
+    const diff = await getDiff({ from: options.base, to: currentBranch }, options.cwd);
+    console.log(chalk8.gray(`Diff: ${diff.length} characters`));
+    const result = await fullPRWorkflow({
+      owner: options.owner,
+      repo: options.repo,
+      branchName: currentBranch,
+      baseBranch: options.base,
+      files: [],
+      // Would need to parse diff into files
+      commitMessage: prTitle,
+      prTitle,
+      prBody
+    });
+    if (result.success) {
+      console.log(chalk8.green(`
+\u2713 PR created: ${result.prUrl}`));
+    } else {
+      console.error(chalk8.red(`Error: ${result.error}`));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("build").description("Run build command").option("-c, --cwd <dir>", "Working directory", process.cwd()).option("-d, --dry-run", "Preview without executing").action(async (options) => {
+  try {
+    const buildCmd = getBuildCommand(options.cwd);
+    if (options.dryRun) {
+      console.log(chalk8.yellow(`[DRY-RUN] Would execute: ${buildCmd}`));
+      return;
+    }
+    console.log(chalk8.gray(`$ ${buildCmd}`));
+    const result = await runShell(buildCmd, { cwd: options.cwd });
+    if (result.stdout) console.log(result.stdout);
+    if (result.stderr) console.error(chalk8.red(result.stderr));
+    if (result.success) {
+      console.log(chalk8.green("\n\u2713 Build successful"));
+    } else {
+      console.log(chalk8.red(`
+\u2717 Build failed (exit code ${result.exitCode})`));
+      process.exit(result.exitCode);
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("install").description("Run install command").option("-c, --cwd <dir>", "Working directory", process.cwd()).option("-d, --dry-run", "Preview without executing").action(async (options) => {
+  try {
+    const installCmd = getInstallCommand(options.cwd);
+    if (options.dryRun) {
+      console.log(chalk8.yellow(`[DRY-RUN] Would execute: ${installCmd}`));
+      return;
+    }
+    console.log(chalk8.gray(`$ ${installCmd}`));
+    const result = await runShell(installCmd, { cwd: options.cwd, timeout: 3e5 });
+    if (result.stdout) console.log(result.stdout);
+    if (result.stderr) console.error(chalk8.red(result.stderr));
+    if (result.success) {
+      console.log(chalk8.green("\n\u2713 Install successful"));
+    } else {
+      console.log(chalk8.red(`
+\u2717 Install failed (exit code ${result.exitCode})`));
+      process.exit(result.exitCode);
+    }
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("mcp").description("Manage MCP server connections").option("-l, --list", "List available MCP servers").option("-c, --connect", "Connect to all enabled MCP servers").option("-s, --status", "Show MCP server status").action(async (options) => {
+  const { MCPManager: MCPManager2, getDefaultMCPServers: getDefaultMCPServers2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+  if (options.list) {
+    const servers = getDefaultMCPServers2();
+    console.log(chalk8.cyan("\n\u{1F4E1} Available MCP Servers\n"));
+    for (const server of servers) {
+      const status = server.enabled ? chalk8.green("enabled") : chalk8.gray("disabled");
+      console.log(`  ${server.name.padEnd(20)} ${status}`);
+    }
+    return;
+  }
+  if (options.connect) {
+    const manager = new MCPManager2();
+    console.log(chalk8.cyan("\n\u{1F50C} Connecting to MCP servers...\n"));
+    const result = await manager.initializeAll();
+    console.log(chalk8.green(`
+\u2713 Connected to ${result.success.length} servers`));
+    if (result.failed.length > 0) {
+      console.log(chalk8.red(`\u2717 Failed to connect to ${result.failed.length} servers`));
+    }
+    return;
+  }
+  if (options.status) {
+    const manager = new MCPManager2();
+    await manager.initializeAll();
+    const status = manager.getStatus();
+    console.log(chalk8.cyan("\n\u{1F4E1} MCP Server Status\n"));
+    for (const s of status) {
+      const icon = s.connected ? chalk8.green("\u2713") : chalk8.red("\u2717");
+      console.log(`  ${icon} ${s.name}`);
+    }
+    return;
+  }
+  console.log(chalk8.gray("Use --list, --connect, or --status"));
+});
+program.command("swarm").description("Run multiple agents in parallel for complex tasks").option("-g, --goal <text>", "Goal for the swarm").option("-p, --parallel <num>", "Max parallel agents", "3").option("-c, --cwd <dir>", "Working directory", process.cwd()).action(async (options) => {
+  if (!options.goal) {
+    console.error(chalk8.red("Error: --goal is required"));
+    process.exit(1);
+  }
+  const loggedIn = await isLoggedIn();
+  if (!loggedIn) {
+    console.error(chalk8.red('Not logged in. Run "vibe-weaver login" first.'));
+    process.exit(1);
+  }
+  const { runSwarm: runSwarm2 } = await Promise.resolve().then(() => (init_swarm(), swarm_exports));
+  await runSwarm2(options.goal, {
+    maxParallel: parseInt(options.parallel),
+    baseDir: options.cwd
+  });
+});
+var taskCmd = program.command("task").description("Manage background tasks");
+taskCmd.command("submit").description("Submit a background task").option("-g, --goal <text>", "Task goal").option("-p, --platform <type>", "Platform", "web").option("-m, --mode <mode>", "Model mode", "balanced").action(async (options) => {
+  if (!options.goal) {
+    console.error(chalk8.red("Error: --goal is required"));
+    process.exit(1);
+  }
+  const { submitTask: submitTask2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  await submitTask2({
+    goal: options.goal,
+    platform: options.platform,
+    modelId: options.mode
+  });
+});
+taskCmd.command("status").description("Check task status").argument("<id>", "Task ID").action(async (taskId) => {
+  const { getTaskStatus: getTaskStatus2, displayTaskStatus: displayTaskStatus2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  const status = await getTaskStatus2(taskId);
+  displayTaskStatus2(status);
+});
+taskCmd.command("logs").description("Stream task logs").argument("<id>", "Task ID").action(async (taskId) => {
+  const { streamTaskLogs: streamTaskLogs2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  console.log(chalk8.gray(`Streaming logs for task ${taskId}...
+`));
+  for await (const log of streamTaskLogs2(taskId)) {
+    process.stdout.write(log);
+  }
+});
+taskCmd.command("wait").description("Wait for task to complete").argument("<id>", "Task ID").option("-t, --timeout <seconds>", "Timeout in seconds", "300").action(async (taskId, options) => {
+  const { waitForTask: waitForTask2, displayTaskStatus: displayTaskStatus2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  try {
+    const status = await waitForTask2(taskId, {
+      pollInterval: 5e3,
+      onProgress: (s) => {
+        process.stdout.write(chalk8.gray(`\rStatus: ${s.status}`));
+      }
+    });
+    console.log();
+    displayTaskStatus2(status);
+  } catch (error) {
+    console.error(chalk8.red("Error:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("deploy").description("Deploy project and verify").option("-i, --project-id <id>", "Project ID").option("-t, --platform <type>", "Platform", "web").option("-v, --verify", "Verify deployment", true).option("--no-verify", "Skip verification").option("-c, --cwd <dir>", "Working directory", process.cwd()).action(async (options) => {
+  const loggedIn = await isLoggedIn();
+  if (!loggedIn) {
+    console.error(chalk8.red('Not logged in. Run "vibe-weaver login" first.'));
+    process.exit(1);
+  }
+  const { deploy: deploy2 } = await Promise.resolve().then(() => (init_deploy(), deploy_exports));
+  const result = await deploy2({
+    projectId: options.projectId,
+    platform: options.platform,
+    verify: options.verify,
+    cwd: options.cwd
+  });
+  if (result.success) {
+    console.log(chalk8.green(`
+\u2713 Deployed to ${result.url}`));
+  } else {
+    console.error(chalk8.red(`
+\u2717 Deployment failed: ${result.error}`));
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map