@react-grab/cli 0.0.68

package/dist/cli.js

@@ -0,0 +1,927 @@
+#!/usr/bin/env node
+import { select, confirm } from '@inquirer/prompts';
+import pc from 'picocolors';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { writeFileSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { detect } from '@antfu/ni';
+import { execSync } from 'child_process';
+
+var detectPackageManager = async (projectRoot) => {
+  const detected = await detect({ cwd: projectRoot });
+  if (detected && ["npm", "yarn", "pnpm", "bun"].includes(detected)) {
+    return detected;
+  }
+  return "npm";
+};
+var detectFramework = (projectRoot) => {
+  const packageJsonPath = join(projectRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return "unknown";
+  }
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const allDependencies = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  if (allDependencies["next"]) {
+    return "next";
+  }
+  if (allDependencies["vite"]) {
+    return "vite";
+  }
+  if (allDependencies["webpack"]) {
+    return "webpack";
+  }
+  return "unknown";
+};
+var detectNextRouterType = (projectRoot) => {
+  const hasAppDir = existsSync(join(projectRoot, "app"));
+  const hasSrcAppDir = existsSync(join(projectRoot, "src", "app"));
+  const hasPagesDir = existsSync(join(projectRoot, "pages"));
+  const hasSrcPagesDir = existsSync(join(projectRoot, "src", "pages"));
+  if (hasAppDir || hasSrcAppDir) {
+    return "app";
+  }
+  if (hasPagesDir || hasSrcPagesDir) {
+    return "pages";
+  }
+  return "unknown";
+};
+var detectMonorepo = (projectRoot) => {
+  if (existsSync(join(projectRoot, "pnpm-workspace.yaml"))) {
+    return true;
+  }
+  if (existsSync(join(projectRoot, "lerna.json"))) {
+    return true;
+  }
+  const packageJsonPath = join(projectRoot, "package.json");
+  if (existsSync(packageJsonPath)) {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    if (packageJson.workspaces) {
+      return true;
+    }
+  }
+  return false;
+};
+var detectReactGrab = (projectRoot) => {
+  const packageJsonPath = join(projectRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const allDependencies = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  return Boolean(allDependencies["react-grab"]);
+};
+var AGENT_PACKAGES = ["@react-grab/claude-code", "@react-grab/cursor", "@react-grab/opencode"];
+var detectInstalledAgents = (projectRoot) => {
+  const packageJsonPath = join(projectRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return [];
+  }
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const allDependencies = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+  return AGENT_PACKAGES.filter((agent) => Boolean(allDependencies[agent])).map(
+    (agent) => agent.replace("@react-grab/", "")
+  );
+};
+var detectProject = async (projectRoot = process.cwd()) => {
+  const framework = detectFramework(projectRoot);
+  const packageManager = await detectPackageManager(projectRoot);
+  return {
+    packageManager,
+    framework,
+    nextRouterType: framework === "next" ? detectNextRouterType(projectRoot) : "unknown",
+    isMonorepo: detectMonorepo(projectRoot),
+    projectRoot,
+    hasReactGrab: detectReactGrab(projectRoot),
+    installedAgents: detectInstalledAgents(projectRoot)
+  };
+};
+
+// src/diff.ts
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var GRAY = "\x1B[90m";
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var generateDiff = (originalContent, newContent) => {
+  const originalLines = originalContent.split("\n");
+  const newLines = newContent.split("\n");
+  const diff = [];
+  Math.max(originalLines.length, newLines.length);
+  let originalIndex = 0;
+  let newIndex = 0;
+  while (originalIndex < originalLines.length || newIndex < newLines.length) {
+    const originalLine = originalLines[originalIndex];
+    const newLine = newLines[newIndex];
+    if (originalLine === newLine) {
+      diff.push({ type: "unchanged", content: originalLine, lineNumber: newIndex + 1 });
+      originalIndex++;
+      newIndex++;
+    } else if (originalLine === void 0) {
+      diff.push({ type: "added", content: newLine, lineNumber: newIndex + 1 });
+      newIndex++;
+    } else if (newLine === void 0) {
+      diff.push({ type: "removed", content: originalLine });
+      originalIndex++;
+    } else {
+      const originalInNew = newLines.indexOf(originalLine, newIndex);
+      const newInOriginal = originalLines.indexOf(newLine, originalIndex);
+      if (originalInNew !== -1 && (newInOriginal === -1 || originalInNew - newIndex < newInOriginal - originalIndex)) {
+        while (newIndex < originalInNew) {
+          diff.push({ type: "added", content: newLines[newIndex], lineNumber: newIndex + 1 });
+          newIndex++;
+        }
+      } else if (newInOriginal !== -1) {
+        while (originalIndex < newInOriginal) {
+          diff.push({ type: "removed", content: originalLines[originalIndex] });
+          originalIndex++;
+        }
+      } else {
+        diff.push({ type: "removed", content: originalLine });
+        diff.push({ type: "added", content: newLine, lineNumber: newIndex + 1 });
+        originalIndex++;
+        newIndex++;
+      }
+    }
+  }
+  return diff;
+};
+var formatDiff = (diff, contextLines = 3) => {
+  const lines = [];
+  let lastPrintedIndex = -1;
+  let hasChanges = false;
+  const changedIndices = diff.map((line, index) => line.type !== "unchanged" ? index : -1).filter((index) => index !== -1);
+  if (changedIndices.length === 0) {
+    return `${GRAY}No changes${RESET}`;
+  }
+  for (const changedIndex of changedIndices) {
+    const startContext = Math.max(0, changedIndex - contextLines);
+    const endContext = Math.min(diff.length - 1, changedIndex + contextLines);
+    if (startContext > lastPrintedIndex + 1 && lastPrintedIndex !== -1) {
+      lines.push(`${GRAY}  ...${RESET}`);
+    }
+    for (let lineIndex = Math.max(startContext, lastPrintedIndex + 1); lineIndex <= endContext; lineIndex++) {
+      const diffLine = diff[lineIndex];
+      if (diffLine.type === "added") {
+        lines.push(`${GREEN}+ ${diffLine.content}${RESET}`);
+        hasChanges = true;
+      } else if (diffLine.type === "removed") {
+        lines.push(`${RED}- ${diffLine.content}${RESET}`);
+        hasChanges = true;
+      } else {
+        lines.push(`${GRAY}  ${diffLine.content}${RESET}`);
+      }
+      lastPrintedIndex = lineIndex;
+    }
+  }
+  return hasChanges ? lines.join("\n") : `${GRAY}No changes${RESET}`;
+};
+var printDiff = (filePath, originalContent, newContent) => {
+  console.log(`
+${BOLD}File: ${filePath}${RESET}`);
+  console.log("\u2500".repeat(60));
+  const diff = generateDiff(originalContent, newContent);
+  console.log(formatDiff(diff));
+  console.log("\u2500".repeat(60));
+};
+var INSTALL_COMMANDS = {
+  npm: "npm install",
+  yarn: "yarn add",
+  pnpm: "pnpm add",
+  bun: "bun add"
+};
+var installPackages = (packages, packageManager, projectRoot, isDev = true) => {
+  if (packages.length === 0) {
+    return;
+  }
+  const command = INSTALL_COMMANDS[packageManager];
+  const devFlag = isDev ? " -D" : "";
+  const fullCommand = `${command}${devFlag} ${packages.join(" ")}`;
+  console.log(`Running: ${fullCommand}
+`);
+  execSync(fullCommand, {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+};
+var getPackagesToInstall = (agent, includeReactGrab = true) => {
+  const packages = [];
+  if (includeReactGrab) {
+    packages.push("react-grab");
+  }
+  if (agent !== "none") {
+    packages.push(`@react-grab/${agent}`);
+  }
+  return packages;
+};
+
+// src/templates.ts
+var NEXT_APP_ROUTER_SCRIPT = `{process.env.NODE_ENV === "development" && (
+          <Script
+            src="//unpkg.com/react-grab/dist/index.global.js"
+            crossOrigin="anonymous"
+            strategy="beforeInteractive"
+          />
+        )}`;
+var NEXT_APP_ROUTER_SCRIPT_WITH_AGENT = (agent) => {
+  if (agent === "none") return NEXT_APP_ROUTER_SCRIPT;
+  const agentScript = `<Script
+              src="//unpkg.com/@react-grab/${agent}/dist/client.global.js"
+              strategy="lazyOnload"
+            />`;
+  return `{process.env.NODE_ENV === "development" && (
+          <>
+            <Script
+              src="//unpkg.com/react-grab/dist/index.global.js"
+              strategy="beforeInteractive"
+            />
+            ${agentScript}
+          </>
+        )}`;
+};
+var NEXT_PAGES_ROUTER_SCRIPT = `{process.env.NODE_ENV === "development" && (
+          <Script
+            src="//unpkg.com/react-grab/dist/index.global.js"
+            crossOrigin="anonymous"
+            strategy="beforeInteractive"
+          />
+        )}`;
+var NEXT_PAGES_ROUTER_SCRIPT_WITH_AGENT = (agent) => {
+  if (agent === "none") return NEXT_PAGES_ROUTER_SCRIPT;
+  const agentScript = `<Script
+              src="//unpkg.com/@react-grab/${agent}/dist/client.global.js"
+              strategy="lazyOnload"
+            />`;
+  return `{process.env.NODE_ENV === "development" && (
+          <>
+            <Script
+              src="//unpkg.com/react-grab/dist/index.global.js"
+              strategy="beforeInteractive"
+            />
+            ${agentScript}
+          </>
+        )}`;
+};
+var VITE_SCRIPT = `<script type="module">
+      if (import.meta.env.DEV) {
+        import("react-grab");
+      }
+    </script>`;
+var VITE_SCRIPT_WITH_AGENT = (agent) => {
+  if (agent === "none") return VITE_SCRIPT;
+  return `<script type="module">
+      if (import.meta.env.DEV) {
+        import("react-grab");
+        import("@react-grab/${agent}/client");
+      }
+    </script>`;
+};
+var WEBPACK_IMPORT = `if (process.env.NODE_ENV === "development") {
+  import("react-grab");
+}`;
+var WEBPACK_IMPORT_WITH_AGENT = (agent) => {
+  if (agent === "none") return WEBPACK_IMPORT;
+  return `if (process.env.NODE_ENV === "development") {
+  import("react-grab");
+  import("@react-grab/${agent}/client");
+}`;
+};
+var SCRIPT_IMPORT = 'import Script from "next/script";';
+
+// src/transform.ts
+var findLayoutFile = (projectRoot) => {
+  const possiblePaths = [
+    join(projectRoot, "app", "layout.tsx"),
+    join(projectRoot, "app", "layout.jsx"),
+    join(projectRoot, "src", "app", "layout.tsx"),
+    join(projectRoot, "src", "app", "layout.jsx")
+  ];
+  for (const filePath of possiblePaths) {
+    if (existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+};
+var findDocumentFile = (projectRoot) => {
+  const possiblePaths = [
+    join(projectRoot, "pages", "_document.tsx"),
+    join(projectRoot, "pages", "_document.jsx"),
+    join(projectRoot, "src", "pages", "_document.tsx"),
+    join(projectRoot, "src", "pages", "_document.jsx")
+  ];
+  for (const filePath of possiblePaths) {
+    if (existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+};
+var findIndexHtml = (projectRoot) => {
+  const possiblePaths = [
+    join(projectRoot, "index.html"),
+    join(projectRoot, "public", "index.html")
+  ];
+  for (const filePath of possiblePaths) {
+    if (existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+};
+var findEntryFile = (projectRoot) => {
+  const possiblePaths = [
+    join(projectRoot, "src", "index.tsx"),
+    join(projectRoot, "src", "index.jsx"),
+    join(projectRoot, "src", "index.ts"),
+    join(projectRoot, "src", "index.js"),
+    join(projectRoot, "src", "main.tsx"),
+    join(projectRoot, "src", "main.jsx"),
+    join(projectRoot, "src", "main.ts"),
+    join(projectRoot, "src", "main.js")
+  ];
+  for (const filePath of possiblePaths) {
+    if (existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+};
+var addAgentToExistingNextApp = (originalContent, agent, filePath) => {
+  if (agent === "none") {
+    return {
+      success: true,
+      filePath,
+      message: "React Grab is already configured",
+      noChanges: true
+    };
+  }
+  const agentPackage = `@react-grab/${agent}`;
+  if (originalContent.includes(agentPackage)) {
+    return {
+      success: true,
+      filePath,
+      message: `Agent ${agent} is already configured`,
+      noChanges: true
+    };
+  }
+  const agentScript = `<Script
+              src="//unpkg.com/${agentPackage}/dist/client.global.js"
+              strategy="lazyOnload"
+            />`;
+  const reactGrabScriptMatch = originalContent.match(
+    /<Script[^>]*src="[^"]*react-grab[^"]*"[^>]*\/?>/
+  );
+  if (reactGrabScriptMatch) {
+    const newContent = originalContent.replace(
+      reactGrabScriptMatch[0],
+      `${reactGrabScriptMatch[0]}
+            ${agentScript}`
+    );
+    return {
+      success: true,
+      filePath,
+      message: `Add ${agent} agent`,
+      originalContent,
+      newContent
+    };
+  }
+  return {
+    success: false,
+    filePath,
+    message: "Could not find React Grab script to add agent after"
+  };
+};
+var addAgentToExistingVite = (originalContent, agent, filePath) => {
+  if (agent === "none") {
+    return {
+      success: true,
+      filePath,
+      message: "React Grab is already configured",
+      noChanges: true
+    };
+  }
+  const agentPackage = `@react-grab/${agent}`;
+  if (originalContent.includes(agentPackage)) {
+    return {
+      success: true,
+      filePath,
+      message: `Agent ${agent} is already configured`,
+      noChanges: true
+    };
+  }
+  const agentImport = `import("${agentPackage}/client");`;
+  const reactGrabImportMatch = originalContent.match(/import\s*\(\s*["']react-grab["']\s*\)/);
+  if (reactGrabImportMatch) {
+    const newContent = originalContent.replace(
+      reactGrabImportMatch[0],
+      `${reactGrabImportMatch[0]};
+        ${agentImport}`
+    );
+    return {
+      success: true,
+      filePath,
+      message: `Add ${agent} agent`,
+      originalContent,
+      newContent
+    };
+  }
+  return {
+    success: false,
+    filePath,
+    message: "Could not find React Grab import to add agent after"
+  };
+};
+var addAgentToExistingWebpack = (originalContent, agent, filePath) => {
+  if (agent === "none") {
+    return {
+      success: true,
+      filePath,
+      message: "React Grab is already configured",
+      noChanges: true
+    };
+  }
+  const agentPackage = `@react-grab/${agent}`;
+  if (originalContent.includes(agentPackage)) {
+    return {
+      success: true,
+      filePath,
+      message: `Agent ${agent} is already configured`,
+      noChanges: true
+    };
+  }
+  const agentImport = `import("${agentPackage}/client");`;
+  const reactGrabImportMatch = originalContent.match(/import\s*\(\s*["']react-grab["']\s*\)/);
+  if (reactGrabImportMatch) {
+    const newContent = originalContent.replace(
+      reactGrabImportMatch[0],
+      `${reactGrabImportMatch[0]};
+  ${agentImport}`
+    );
+    return {
+      success: true,
+      filePath,
+      message: `Add ${agent} agent`,
+      originalContent,
+      newContent
+    };
+  }
+  return {
+    success: false,
+    filePath,
+    message: "Could not find React Grab import to add agent after"
+  };
+};
+var transformNextAppRouter = (projectRoot, agent, reactGrabAlreadyConfigured) => {
+  const layoutPath = findLayoutFile(projectRoot);
+  if (!layoutPath) {
+    return {
+      success: false,
+      filePath: "",
+      message: "Could not find app/layout.tsx or app/layout.jsx"
+    };
+  }
+  const originalContent = readFileSync(layoutPath, "utf-8");
+  let newContent = originalContent;
+  const hasReactGrabInFile = originalContent.includes("react-grab");
+  if (hasReactGrabInFile && reactGrabAlreadyConfigured) {
+    return addAgentToExistingNextApp(originalContent, agent, layoutPath);
+  }
+  if (hasReactGrabInFile) {
+    return {
+      success: true,
+      filePath: layoutPath,
+      message: "React Grab is already installed in this file",
+      noChanges: true
+    };
+  }
+  if (!newContent.includes('import Script from "next/script"')) {
+    const importMatch = newContent.match(/^import .+ from ['"].+['"];?\s*$/m);
+    if (importMatch) {
+      newContent = newContent.replace(importMatch[0], `${importMatch[0]}
+${SCRIPT_IMPORT}`);
+    } else {
+      newContent = `${SCRIPT_IMPORT}
+
+${newContent}`;
+    }
+  }
+  const scriptBlock = NEXT_APP_ROUTER_SCRIPT_WITH_AGENT(agent);
+  const headMatch = newContent.match(/<head[^>]*>/);
+  if (headMatch) {
+    newContent = newContent.replace(headMatch[0], `${headMatch[0]}
+        ${scriptBlock}`);
+  } else {
+    const htmlMatch = newContent.match(/<html[^>]*>/);
+    if (htmlMatch) {
+      newContent = newContent.replace(
+        htmlMatch[0],
+        `${htmlMatch[0]}
+      <head>
+        ${scriptBlock}
+      </head>`
+      );
+    }
+  }
+  return {
+    success: true,
+    filePath: layoutPath,
+    message: "Add React Grab" + (agent !== "none" ? ` with ${agent} agent` : ""),
+    originalContent,
+    newContent
+  };
+};
+var transformNextPagesRouter = (projectRoot, agent, reactGrabAlreadyConfigured) => {
+  const documentPath = findDocumentFile(projectRoot);
+  if (!documentPath) {
+    return {
+      success: false,
+      filePath: "",
+      message: "Could not find pages/_document.tsx. Please create one or add React Grab manually."
+    };
+  }
+  const originalContent = readFileSync(documentPath, "utf-8");
+  let newContent = originalContent;
+  const hasReactGrabInFile = originalContent.includes("react-grab");
+  if (hasReactGrabInFile && reactGrabAlreadyConfigured) {
+    return addAgentToExistingNextApp(originalContent, agent, documentPath);
+  }
+  if (hasReactGrabInFile) {
+    return {
+      success: true,
+      filePath: documentPath,
+      message: "React Grab is already installed in this file",
+      noChanges: true
+    };
+  }
+  if (!newContent.includes('import Script from "next/script"')) {
+    const importMatch = newContent.match(/^import .+ from ['"].+['"];?\s*$/m);
+    if (importMatch) {
+      newContent = newContent.replace(importMatch[0], `${importMatch[0]}
+${SCRIPT_IMPORT}`);
+    }
+  }
+  const scriptBlock = NEXT_PAGES_ROUTER_SCRIPT_WITH_AGENT(agent);
+  const headMatch = newContent.match(/<Head[^>]*>/);
+  if (headMatch) {
+    newContent = newContent.replace(headMatch[0], `${headMatch[0]}
+        ${scriptBlock}`);
+  }
+  return {
+    success: true,
+    filePath: documentPath,
+    message: "Add React Grab" + (agent !== "none" ? ` with ${agent} agent` : ""),
+    originalContent,
+    newContent
+  };
+};
+var transformVite = (projectRoot, agent, reactGrabAlreadyConfigured) => {
+  const indexPath = findIndexHtml(projectRoot);
+  if (!indexPath) {
+    return {
+      success: false,
+      filePath: "",
+      message: "Could not find index.html"
+    };
+  }
+  const originalContent = readFileSync(indexPath, "utf-8");
+  let newContent = originalContent;
+  const hasReactGrabInFile = originalContent.includes("react-grab");
+  if (hasReactGrabInFile && reactGrabAlreadyConfigured) {
+    return addAgentToExistingVite(originalContent, agent, indexPath);
+  }
+  if (hasReactGrabInFile) {
+    return {
+      success: true,
+      filePath: indexPath,
+      message: "React Grab is already installed in this file",
+      noChanges: true
+    };
+  }
+  const scriptBlock = VITE_SCRIPT_WITH_AGENT(agent);
+  const headMatch = newContent.match(/<head[^>]*>/i);
+  if (headMatch) {
+    newContent = newContent.replace(headMatch[0], `${headMatch[0]}
+    ${scriptBlock}`);
+  }
+  return {
+    success: true,
+    filePath: indexPath,
+    message: "Add React Grab" + (agent !== "none" ? ` with ${agent} agent` : ""),
+    originalContent,
+    newContent
+  };
+};
+var transformWebpack = (projectRoot, agent, reactGrabAlreadyConfigured) => {
+  const entryPath = findEntryFile(projectRoot);
+  if (!entryPath) {
+    return {
+      success: false,
+      filePath: "",
+      message: "Could not find entry file (src/index.tsx, src/main.tsx, etc.)"
+    };
+  }
+  const originalContent = readFileSync(entryPath, "utf-8");
+  const hasReactGrabInFile = originalContent.includes("react-grab");
+  if (hasReactGrabInFile && reactGrabAlreadyConfigured) {
+    return addAgentToExistingWebpack(originalContent, agent, entryPath);
+  }
+  if (hasReactGrabInFile) {
+    return {
+      success: true,
+      filePath: entryPath,
+      message: "React Grab is already installed in this file",
+      noChanges: true
+    };
+  }
+  const importBlock = WEBPACK_IMPORT_WITH_AGENT(agent);
+  const newContent = `${importBlock}
+
+${originalContent}`;
+  return {
+    success: true,
+    filePath: entryPath,
+    message: "Add React Grab" + (agent !== "none" ? ` with ${agent} agent` : ""),
+    originalContent,
+    newContent
+  };
+};
+var previewTransform = (projectRoot, framework, nextRouterType, agent, reactGrabAlreadyConfigured = false) => {
+  switch (framework) {
+    case "next":
+      if (nextRouterType === "app") {
+        return transformNextAppRouter(projectRoot, agent, reactGrabAlreadyConfigured);
+      }
+      return transformNextPagesRouter(projectRoot, agent, reactGrabAlreadyConfigured);
+    case "vite":
+      return transformVite(projectRoot, agent, reactGrabAlreadyConfigured);
+    case "webpack":
+      return transformWebpack(projectRoot, agent, reactGrabAlreadyConfigured);
+    default:
+      return {
+        success: false,
+        filePath: "",
+        message: `Unknown framework: ${framework}. Please add React Grab manually.`
+      };
+  }
+};
+var applyTransform = (result) => {
+  if (result.success && result.newContent && result.filePath) {
+    writeFileSync(result.filePath, result.newContent);
+  }
+};
+
+// src/cli.ts
+var VERSION = "0.0.1";
+var FRAMEWORK_NAMES = {
+  next: "Next.js",
+  vite: "Vite",
+  webpack: "Webpack",
+  unknown: "Unknown"
+};
+var PACKAGE_MANAGER_NAMES = {
+  npm: "npm",
+  yarn: "Yarn",
+  pnpm: "pnpm",
+  bun: "Bun"
+};
+var AGENT_NAMES = {
+  "claude-code": "Claude Code",
+  cursor: "Cursor",
+  opencode: "Opencode"
+};
+var DOCS_URL = "https://react-grab.com/docs";
+var showDocsLink = () => {
+  console.log("\nFor manual installation instructions, visit:");
+  console.log(`  ${DOCS_URL}
+`);
+};
+var parseArgs = async () => {
+  const argv = await yargs(hideBin(process.argv)).usage("Usage: $0 [options]").option("framework", {
+    alias: "f",
+    type: "string",
+    choices: ["next", "vite", "webpack"],
+    description: "Framework to configure (next, vite, webpack)"
+  }).option("package-manager", {
+    alias: "p",
+    type: "string",
+    choices: ["npm", "yarn", "pnpm", "bun"],
+    description: "Package manager to use"
+  }).option("router", {
+    alias: "r",
+    type: "string",
+    choices: ["app", "pages"],
+    description: "Next.js router type (app or pages)"
+  }).option("agent", {
+    alias: "a",
+    type: "string",
+    choices: ["claude-code", "cursor", "opencode", "none"],
+    description: "Agent integration to add"
+  }).option("yes", {
+    alias: "y",
+    type: "boolean",
+    default: false,
+    description: "Skip all confirmation prompts"
+  }).option("skip-install", {
+    type: "boolean",
+    default: false,
+    description: "Skip package installation (only modify files)"
+  }).help().alias("help", "h").version(VERSION).alias("version", "v").example("$0", "Run interactive setup").example("$0 -y", "Auto-detect and install without prompts").example("$0 -f next -r app -a cursor", "Install for Next.js App Router with Cursor agent").example("$0 -p pnpm -a claude-code -y", "Use pnpm and add Claude Code agent").parse();
+  return {
+    framework: argv.framework,
+    packageManager: argv["package-manager"],
+    router: argv.router,
+    agent: argv.agent,
+    yes: argv.yes,
+    skipInstall: argv["skip-install"]
+  };
+};
+var main = async () => {
+  const args = await parseArgs();
+  const isNonInteractive = args.yes;
+  console.log(`
+${pc.magenta("\u269B")} ${pc.bold("React Grab")} ${pc.gray(VERSION)}`);
+  const projectInfo = await detectProject(process.cwd());
+  console.log(`- Framework:       ${pc.cyan(FRAMEWORK_NAMES[projectInfo.framework])}`);
+  console.log(`- Package Manager: ${pc.cyan(PACKAGE_MANAGER_NAMES[projectInfo.packageManager])}`);
+  if (projectInfo.framework === "next") {
+    console.log(`- Router Type:     ${pc.cyan(projectInfo.nextRouterType === "app" ? "App Router" : "Pages Router")}`);
+  }
+  console.log(`- Monorepo:        ${pc.cyan(projectInfo.isMonorepo ? "Yes" : "No")}`);
+  console.log(`- React Grab:      ${projectInfo.hasReactGrab ? pc.green("Installed") : pc.yellow("Not installed")}`);
+  if (projectInfo.installedAgents.length > 0) {
+    console.log(`- Agents:          ${pc.cyan(projectInfo.installedAgents.map((agent) => AGENT_NAMES[agent] || agent).join(", "))}`);
+  }
+  console.log("");
+  let action = "install-all";
+  if (projectInfo.hasReactGrab && !isNonInteractive) {
+    action = await select({
+      message: "React Grab is already installed. What would you like to do?",
+      choices: [
+        { name: "Add an agent integration", value: "add-agent" },
+        { name: "Reconfigure project files", value: "reconfigure" },
+        { name: "Reinstall everything", value: "install-all" }
+      ]
+    });
+  } else if (projectInfo.hasReactGrab && args.agent && args.agent !== "none") {
+    action = "add-agent";
+  }
+  let finalFramework = args.framework || projectInfo.framework;
+  let finalPackageManager = args.packageManager || projectInfo.packageManager;
+  let finalNextRouterType = args.router || projectInfo.nextRouterType;
+  if (!isNonInteractive && !args.framework) {
+    const confirmSettings = await confirm({
+      message: "Are these settings correct?",
+      default: true
+    });
+    if (!confirmSettings) {
+      finalFramework = await select({
+        message: "Select your framework:",
+        choices: [
+          { name: "Next.js", value: "next" },
+          { name: "Vite", value: "vite" },
+          { name: "Webpack", value: "webpack" }
+        ],
+        default: projectInfo.framework
+      });
+      finalPackageManager = await select({
+        message: "Select your package manager:",
+        choices: [
+          { name: "npm", value: "npm" },
+          { name: "Yarn", value: "yarn" },
+          { name: "pnpm", value: "pnpm" },
+          { name: "Bun", value: "bun" }
+        ],
+        default: projectInfo.packageManager
+      });
+      if (finalFramework === "next") {
+        finalNextRouterType = await select({
+          message: "Select your Next.js router type:",
+          choices: [
+            { name: "App Router", value: "app" },
+            { name: "Pages Router", value: "pages" }
+          ],
+          default: projectInfo.nextRouterType === "app" ? "app" : "pages"
+        });
+      }
+    }
+  }
+  let agentIntegration = args.agent || "none";
+  const shouldAskForAgent = (action === "install-all" || action === "add-agent") && !args.agent;
+  if (shouldAskForAgent && !isNonInteractive) {
+    const availableAgents = [
+      { name: "Claude Code", value: "claude-code" },
+      { name: "Cursor", value: "cursor" },
+      { name: "Opencode", value: "opencode" }
+    ].filter((agent) => !projectInfo.installedAgents.includes(agent.value));
+    if (availableAgents.length === 0) {
+      console.log(`
+${pc.green("All agent integrations are already installed.")}
+`);
+    } else if (action === "add-agent") {
+      agentIntegration = await select({
+        message: "Select an agent integration to add:",
+        choices: availableAgents
+      });
+    } else {
+      const wantAgentIntegration = await confirm({
+        message: "Do you want to add an agent integration (Claude Code, Cursor, or Opencode)?",
+        default: false
+      });
+      if (wantAgentIntegration) {
+        agentIntegration = await select({
+          message: "Select an agent integration:",
+          choices: availableAgents
+        });
+      }
+    }
+  }
+  const shouldTransform = action === "reconfigure" || action === "install-all" || action === "add-agent" && agentIntegration !== "none";
+  if (shouldTransform) {
+    console.log(`
+${pc.magenta("\u269B")} Previewing changes...
+`);
+    const result = previewTransform(
+      projectInfo.projectRoot,
+      finalFramework,
+      finalNextRouterType,
+      agentIntegration,
+      projectInfo.hasReactGrab || action === "add-agent"
+    );
+    if (!result.success) {
+      console.error(`${pc.red("Error:")} ${result.message}`);
+      showDocsLink();
+      process.exit(1);
+    }
+    if (result.noChanges) {
+      console.log(`${pc.cyan("Info:")} ${result.message}`);
+    } else if (result.originalContent && result.newContent) {
+      printDiff(result.filePath, result.originalContent, result.newContent);
+      if (!isNonInteractive) {
+        const confirmChanges = await confirm({
+          message: "Apply these changes?",
+          default: true
+        });
+        if (!confirmChanges) {
+          console.log(`
+${pc.yellow("Changes cancelled.")}
+`);
+          process.exit(0);
+        }
+      }
+      const shouldInstallReactGrab = action === "install-all" && !projectInfo.hasReactGrab;
+      const shouldInstallAgent = agentIntegration !== "none" && !projectInfo.installedAgents.includes(agentIntegration);
+      if (!args.skipInstall && (shouldInstallReactGrab || shouldInstallAgent)) {
+        const packages = getPackagesToInstall(agentIntegration, shouldInstallReactGrab);
+        if (packages.length > 0) {
+          console.log(`
+${pc.magenta("\u269B")} Installing: ${pc.cyan(packages.join(", "))}
+`);
+          try {
+            installPackages(packages, finalPackageManager, projectInfo.projectRoot);
+            console.log(`
+${pc.green("Packages installed successfully!")}
+`);
+          } catch (error) {
+            console.error(`
+${pc.red("Failed to install packages:")}`, error);
+            showDocsLink();
+            process.exit(1);
+          }
+        }
+      }
+      applyTransform(result);
+      console.log(`
+${pc.green("Applied:")} ${result.filePath}`);
+    }
+  }
+  console.log(`
+${pc.green("Done!")}`);
+  console.log(`
+Next steps:`);
+  console.log(`  - Start your development server`);
+  console.log(`  - Select an element to copy its context`);
+  console.log(`  - Learn more at ${pc.cyan("https://react-grab.com")}
+`);
+  if (agentIntegration !== "none") {
+    console.log(`${pc.magenta("\u269B")} Agent: ${pc.cyan(AGENT_NAMES[agentIntegration])}`);
+    console.log(`  Make sure to start the agent server before using it.
+`);
+  }
+};
+main().catch((error) => {
+  console.error(`${pc.red("Error:")}`, error);
+  console.log("\nFor manual installation instructions, visit:");
+  console.log(`  ${DOCS_URL}
+`);
+  process.exit(1);
+});