vite-on-github 1.0.0

package/dist/cli.js

@@ -0,0 +1,795 @@
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+import { join as join4 } from "path";
+
+// src/utils/detect.ts
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { join as join2 } from "path";
+
+// src/utils/fs.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+function readText(filePath) {
+  if (!existsSync(filePath)) return null;
+  return readFileSync(filePath, "utf-8");
+}
+function writeText(filePath, content) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, content, "utf-8");
+}
+function fileExists(filePath) {
+  return existsSync(filePath);
+}
+function findFirstExisting(cwd, candidates) {
+  for (const candidate of candidates) {
+    const full = join(cwd, candidate);
+    if (existsSync(full)) return full;
+  }
+  return null;
+}
+
+// src/utils/detect.ts
+var VITE_CONFIG_CANDIDATES = [
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mts",
+  "vite.config.mjs",
+  "vite.config.cjs"
+];
+function detectPackageManager(cwd) {
+  if (existsSync2(join2(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join2(cwd, "bun.lockb")) || existsSync2(join2(cwd, "bun.lock"))) return "bun";
+  if (existsSync2(join2(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function readPackageJson(cwd) {
+  const path = join2(cwd, "package.json");
+  const text = readText(path);
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function getDeps(pkg) {
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  return deps;
+}
+function detectFramework(deps) {
+  if (deps["react"] || deps["@vitejs/plugin-react"] || deps["@vitejs/plugin-react-swc"]) {
+    return "react";
+  }
+  if (deps["vue"] || deps["@vitejs/plugin-vue"]) return "vue";
+  if (deps["svelte"] || deps["@sveltejs/vite-plugin-svelte"]) return "svelte";
+  if (deps["solid-js"] || deps["vite-plugin-solid"]) return "solid";
+  return "unknown";
+}
+function detectProject(cwd) {
+  const packageJsonPath = join2(cwd, "package.json");
+  if (!existsSync2(packageJsonPath)) return null;
+  const pkg = readPackageJson(cwd);
+  if (!pkg) return null;
+  const deps = getDeps(pkg);
+  const hasVite = Boolean(deps.vite) || existsSync2(join2(cwd, "node_modules", "vite"));
+  if (!hasVite) return null;
+  const viteConfigPath = findFirstExisting(cwd, VITE_CONFIG_CANDIDATES);
+  const framework = detectFramework(deps);
+  return {
+    cwd,
+    packageManager: detectPackageManager(cwd),
+    viteConfigPath,
+    framework,
+    hasReactRouter: Boolean(deps["react-router-dom"] || deps["react-router"]),
+    hasVueRouter: Boolean(deps["vue-router"]),
+    packageJsonPath
+  };
+}
+function findRouterEntryFiles(cwd, framework) {
+  const found = [];
+  if (framework === "react") {
+    const candidates = [
+      "src/main.tsx",
+      "src/main.ts",
+      "src/main.jsx",
+      "src/main.js",
+      "src/index.tsx",
+      "src/index.jsx",
+      "src/App.tsx",
+      "src/App.jsx"
+    ];
+    for (const c of candidates) {
+      const full = join2(cwd, c);
+      if (!existsSync2(full)) continue;
+      const text = readText(full);
+      if (text && /<BrowserRouter|createBrowserRouter/.test(text)) {
+        found.push(full);
+      } else if (/main\.(tsx|ts|jsx|js)$/.test(c)) {
+        found.push(full);
+      }
+    }
+  }
+  if (framework === "vue") {
+    const routerDirs = ["src/router", "src/routers"];
+    for (const dir of routerDirs) {
+      const fullDir = join2(cwd, dir);
+      if (!existsSync2(fullDir)) continue;
+      for (const file of readdirSync(fullDir)) {
+        if (/\.(ts|js|mts|mjs)$/.test(file)) {
+          found.push(join2(fullDir, file));
+        }
+      }
+    }
+    const rootCandidates = ["src/router.ts", "src/router.js", "src/router/index.ts", "src/router/index.js"];
+    for (const c of rootCandidates) {
+      const full = join2(cwd, c);
+      if (existsSync2(full)) found.push(full);
+    }
+  }
+  return found;
+}
+function installCommand(pm, packages, dev = true) {
+  const flag = dev ? "--save-dev" : "--save";
+  switch (pm) {
+    case "pnpm":
+      return `pnpm add ${flag} ${packages.join(" ")}`;
+    case "yarn":
+      return `yarn add ${dev ? "-D" : ""} ${packages.join(" ")}`.replace(/\s+/g, " ").trim();
+    case "bun":
+      return `bun add ${dev ? "-d" : ""} ${packages.join(" ")}`;
+    default:
+      return `npm install ${flag} ${packages.join(" ")}`;
+  }
+}
+function buildCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm run build";
+    case "yarn":
+      return "yarn build";
+    case "bun":
+      return "bun run build";
+    default:
+      return "npm run build";
+  }
+}
+
+// src/utils/git.ts
+import { execSync } from "child_process";
+function detectGitRemote(cwd) {
+  try {
+    const url = execSync("git remote get-url origin", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = url.match(/github\.com[:/]([^/]+)\/(.+?)(?:\.git)?$/i) ?? url.match(/([^/]+)\/([^/]+?)(?:\.git)?$/);
+    if (!match) return null;
+    const owner = match[1];
+    const repo = match[2].replace(/\.git$/, "");
+    const isUserSite = repo === `${owner}.github.io`;
+    return { owner, repo, isUserSite };
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/package-json.ts
+function readPackageJson2(path) {
+  const text = readText(path);
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function writePackageJson(path, pkg) {
+  writeText(path, `${JSON.stringify(pkg, null, 2)}
+`);
+}
+function ensureBuildScript(pkg) {
+  if (!pkg.scripts) pkg.scripts = {};
+  if (pkg.scripts.build) return false;
+  pkg.scripts.build = "vite build";
+  return true;
+}
+function hasDevDependency(pkg, name) {
+  return Boolean(pkg.devDependencies?.[name] || pkg.dependencies?.[name]);
+}
+
+// src/utils/vite-config.ts
+function hasViteBasepathImport(content) {
+  return /from\s+['"]vite-basepath['"]/.test(content) || /require\s*\(\s*['"]vite-basepath['"]\s*\)/.test(content);
+}
+function hasViteBasepathPlugin(content) {
+  return /viteBasepath\s*\(/.test(content);
+}
+function isCommonJsConfig(path) {
+  return /\.cjs$/.test(path);
+}
+function addImport(content, configPath) {
+  if (hasViteBasepathImport(content)) return content;
+  const importLine = isCommonJsConfig(configPath) ? "const viteBasepath = require('vite-basepath');\n" : "import viteBasepath from 'vite-basepath';\n";
+  const importMatch = content.match(/^import .+?;[\r\n]/m) ?? content.match(/^const .+ = require\(.+?\);[\r\n]/m);
+  if (importMatch && importMatch.index !== void 0) {
+    const lastImportEnd = findLastImportEnd(content);
+    return content.slice(0, lastImportEnd) + importLine + content.slice(lastImportEnd);
+  }
+  return importLine + content;
+}
+function findLastImportEnd(content) {
+  const importBlock = /^(?:import\s[\s\S]*?from\s+['"][^'"]+['"];|const\s+\w+\s*=\s*require\(['"][^'"]+['"]\);)/gm;
+  let lastEnd = 0;
+  let match;
+  while ((match = importBlock.exec(content)) !== null) {
+    lastEnd = match.index + match[0].length;
+  }
+  if (lastEnd > 0) {
+    const after = content.slice(lastEnd).match(/^[\r\n]+/);
+    return lastEnd + (after ? after[0].length : 0);
+  }
+  return 0;
+}
+function addPluginToArray(content) {
+  const pluginsArrayMatch = content.match(/plugins\s*:\s*\[/);
+  if (pluginsArrayMatch && pluginsArrayMatch.index !== void 0) {
+    const bracketIndex = content.indexOf("[", pluginsArrayMatch.index);
+    const insertAt = bracketIndex + 1;
+    const afterBracket = content.slice(insertAt).match(/^\s*\n?/);
+    const gap = afterBracket ? afterBracket[0] : "\n    ";
+    return content.slice(0, insertAt) + `${gap}viteBasepath(), ` + content.slice(insertAt);
+  }
+  const defineConfigMatch = content.match(/defineConfig\s*\(\s*\{/);
+  if (defineConfigMatch && defineConfigMatch.index !== void 0) {
+    const braceIndex = content.indexOf("{", defineConfigMatch.index);
+    const insertAt = braceIndex + 1;
+    return content.slice(0, insertAt) + "\n  plugins: [viteBasepath()]," + content.slice(insertAt);
+  }
+  const exportDefaultMatch = content.match(/export\s+default\s*\{/);
+  if (exportDefaultMatch && exportDefaultMatch.index !== void 0) {
+    const braceIndex = content.indexOf("{", exportDefaultMatch.index);
+    const insertAt = braceIndex + 1;
+    return content.slice(0, insertAt) + "\n  plugins: [viteBasepath()]," + content.slice(insertAt);
+  }
+  return content;
+}
+function patchViteConfig(configPath) {
+  const content = readText(configPath);
+  if (!content) {
+    return { changed: false, message: `Could not read ${configPath}` };
+  }
+  if (hasViteBasepathPlugin(content)) {
+    return { changed: false, message: "vite-basepath already configured in vite config" };
+  }
+  let updated = addImport(content, configPath);
+  updated = addPluginToArray(updated);
+  if (updated === content) {
+    return {
+      changed: false,
+      message: "Could not auto-patch vite config \u2014 add viteBasepath() to plugins manually"
+    };
+  }
+  writeText(configPath, updated);
+  return { changed: true, message: `Updated ${configPath}` };
+}
+function frameworkPluginImport(framework) {
+  switch (framework) {
+    case "react":
+      return {
+        importLine: "import react from '@vitejs/plugin-react';\n",
+        pluginCall: "react()"
+      };
+    case "vue":
+      return {
+        importLine: "import vue from '@vitejs/plugin-vue';\n",
+        pluginCall: "vue()"
+      };
+    case "svelte":
+      return {
+        importLine: "import { svelte } from '@sveltejs/vite-plugin-svelte';\n",
+        pluginCall: "svelte()"
+      };
+    case "solid":
+      return {
+        importLine: "import solid from 'vite-plugin-solid';\n",
+        pluginCall: "solid()"
+      };
+    default:
+      return null;
+  }
+}
+function createDefaultViteConfig(cwd, isTs, framework = "unknown") {
+  const filename = isTs ? "vite.config.ts" : "vite.config.js";
+  const path = `${cwd}/${filename}`.replace(/\\/g, "/");
+  const fw = frameworkPluginImport(framework);
+  const plugins = fw ? `viteBasepath(), ${fw.pluginCall}` : "viteBasepath()";
+  const content = `import { defineConfig } from 'vite';
+import viteBasepath from 'vite-basepath';
+${fw?.importLine ?? ""}
+export default defineConfig({
+  plugins: [${plugins}],
+});
+`;
+  writeText(path, content);
+  return path;
+}
+
+// src/utils/router.ts
+function hasRuntimeImport(content) {
+  return /from\s+['"]vite-basepath\/runtime['"]/.test(content);
+}
+function patchReactRouter(content) {
+  if (content.includes("getBase()") || hasRuntimeImport(content)) {
+    return null;
+  }
+  if (!/<BrowserRouter[\s>/]/.test(content) && !/BrowserRouter\s*\(/.test(content)) {
+    return null;
+  }
+  let updated = content;
+  if (!hasRuntimeImport(updated)) {
+    const runtimeImport = "import { getBase } from 'vite-basepath/runtime';\n";
+    const lastImportEnd = findLastImportEnd2(updated);
+    updated = updated.slice(0, lastImportEnd) + runtimeImport + updated.slice(lastImportEnd);
+  }
+  updated = updated.replace(
+    /<BrowserRouter([^>]*)\s+basename=\{[^}]+\}/g,
+    "<BrowserRouter$1 basename={getBase()}"
+  );
+  updated = updated.replace(
+    /<BrowserRouter([^>]*)\s+basename=["'][^"']*["']/g,
+    "<BrowserRouter$1 basename={getBase()}"
+  );
+  updated = updated.replace(
+    /<BrowserRouter(?![^>]*\bbasename=)([\s/>])/g,
+    "<BrowserRouter basename={getBase()}$1"
+  );
+  updated = updated.replace(
+    /BrowserRouter\s*\(\s*\{/g,
+    "BrowserRouter({ basename: getBase(), "
+  );
+  return updated !== content ? updated : null;
+}
+function patchVueRouter(content) {
+  if (content.includes("getBase()") || hasRuntimeImport(content)) {
+    return null;
+  }
+  if (!/createWebHistory\s*\(/.test(content)) {
+    return null;
+  }
+  let updated = content;
+  if (!hasRuntimeImport(updated)) {
+    const runtimeImport = "import { getBase } from 'vite-basepath/runtime';\n";
+    const lastImportEnd = findLastImportEnd2(updated);
+    updated = updated.slice(0, lastImportEnd) + runtimeImport + updated.slice(lastImportEnd);
+  }
+  updated = updated.replace(
+    /createWebHistory\s*\(\s*[^)]*\)/g,
+    "createWebHistory(getBase())"
+  );
+  return updated !== content ? updated : null;
+}
+function findLastImportEnd2(content) {
+  const importBlock = /^(?:import\s[\s\S]*?from\s+['"][^'"]+['"];|const\s+\w+\s*=\s*require\(['"][^'"]+['"]\);)/gm;
+  let lastEnd = 0;
+  let match;
+  while ((match = importBlock.exec(content)) !== null) {
+    lastEnd = match.index + match[0].length;
+  }
+  if (lastEnd > 0) {
+    const after = content.slice(lastEnd).match(/^[\r\n]+/);
+    return lastEnd + (after ? after[0].length : 0);
+  }
+  return 0;
+}
+function patchRouterFiles(files, framework) {
+  const results = [];
+  for (const file of files) {
+    const content = readText(file);
+    if (!content) continue;
+    let patched = null;
+    if (framework === "react") {
+      patched = patchReactRouter(content);
+    } else if (framework === "vue") {
+      patched = patchVueRouter(content);
+    }
+    if (patched) {
+      writeText(file, patched);
+      results.push({ file, changed: true, message: `Updated router in ${file}` });
+    } else if (framework === "react" && /<BrowserRouter/.test(content) || framework === "vue" && /createWebHistory/.test(content)) {
+      results.push({
+        file,
+        changed: false,
+        message: `Router in ${file} already configured or needs manual update`
+      });
+    }
+  }
+  return results;
+}
+
+// src/utils/ci.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var DEFAULT_NODE_VERSION = "22";
+function getSetupAction(pm, cwd) {
+  switch (pm) {
+    case "pnpm":
+      return { install: "pnpm install --frozen-lockfile", cache: "pnpm" };
+    case "yarn":
+      return { install: "yarn install --frozen-lockfile", cache: "yarn" };
+    case "bun":
+      return { install: "bun install --frozen-lockfile" };
+    default:
+      return {
+        install: existsSync3(join3(cwd, "package-lock.json")) ? "npm ci" : "npm install"
+      };
+  }
+}
+function getSetupNodeCache(pm, cwd) {
+  const { cache } = getSetupAction(pm, cwd);
+  if (!cache) return "";
+  return `
+          cache: '${cache}'`;
+}
+function getPnpmSetupStep(pm) {
+  if (pm !== "pnpm") return "";
+  return `
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 9
+`;
+}
+function generateWorkflow(options) {
+  const nodeVersion = options.nodeVersion ?? DEFAULT_NODE_VERSION;
+  const outDir = options.buildOutputDir ?? "dist";
+  const { install } = getSetupAction(options.packageManager, options.cwd);
+  const cacheLine = getSetupNodeCache(options.packageManager, options.cwd);
+  const build = buildCommand(options.packageManager);
+  return `# Generated by vite-on-github \u2014 deploys Vite app to GitHub Pages
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [main, master]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+${getPnpmSetupStep(options.packageManager)}
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '${nodeVersion}'${cacheLine}
+
+      - name: Install dependencies
+        run: ${install}
+
+      - name: Build
+        run: ${build}
+
+      - name: SPA fallback for client-side routing
+        run: cp ${outDir}/index.html ${outDir}/404.html
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ${outDir}
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: \${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
+`;
+}
+function writeWorkflow(options) {
+  const workflowPath = join3(options.cwd, ".github", "workflows", "deploy.yml");
+  const exists = fileExists(workflowPath);
+  writeText(workflowPath, generateWorkflow(options));
+  return { path: workflowPath, created: !exists };
+}
+
+// src/utils/exec.ts
+import { execSync as execSync2 } from "child_process";
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var log = {
+  info: (msg) => console.log(pc.cyan("\u2139"), msg),
+  success: (msg) => console.log(pc.green("\u2714"), msg),
+  warn: (msg) => console.log(pc.yellow("\u26A0"), msg),
+  error: (msg) => console.error(pc.red("\u2716"), msg),
+  step: (msg) => console.log(pc.bold(pc.blue("\u2192")), msg),
+  dim: (msg) => console.log(pc.dim(msg))
+};
+
+// src/utils/exec.ts
+function runCommand(command, cwd, silent = false) {
+  log.dim(`  $ ${command}`);
+  execSync2(command, {
+    cwd,
+    stdio: silent ? "pipe" : "inherit",
+    encoding: "utf-8"
+  });
+}
+
+// src/commands/init.ts
+function getPagesUrl(owner, repo, isUserSite) {
+  if (isUserSite) return `https://${owner}.github.io/`;
+  return `https://${owner}.github.io/${repo}/`;
+}
+async function init(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const steps = [];
+  const warnings = [];
+  const project = detectProject(cwd);
+  if (!project) {
+    return {
+      success: false,
+      steps,
+      warnings: ["Not a Vite project \u2014 run this inside a folder with vite in package.json"]
+    };
+  }
+  const gitRemote = detectGitRemote(cwd);
+  let pagesUrl;
+  if (!options.yes) {
+    p.intro(pc2.bgCyan(pc2.black(" vite-on-github ")));
+    const confirm2 = await p.confirm({
+      message: `Prepare ${pc2.bold(project.cwd)} for GitHub Pages?`,
+      initialValue: true
+    });
+    if (p.isCancel(confirm2) || !confirm2) {
+      p.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+  }
+  const spinner2 = p.spinner();
+  let installOk = options.skipInstall;
+  if (!options.skipInstall) {
+    spinner2.start("Installing vite-basepath\u2026");
+    const pkg2 = readPackageJson2(project.packageJsonPath);
+    const alreadyInstalled = pkg2 ? hasDevDependency(pkg2, "vite-basepath") : false;
+    if (alreadyInstalled) {
+      spinner2.stop("vite-basepath already installed");
+      steps.push("vite-basepath already present");
+      installOk = true;
+    } else {
+      try {
+        const cmd = installCommand(project.packageManager, ["vite-basepath"]);
+        runCommand(cmd, cwd, true);
+        spinner2.stop("Installed vite-basepath");
+        steps.push("Installed vite-basepath");
+        installOk = true;
+      } catch {
+        spinner2.stop("Failed to install vite-basepath");
+        warnings.push(
+          "Could not install vite-basepath \u2014 install it manually, then run init again"
+        );
+      }
+    }
+  }
+  spinner2.start("Checking package.json\u2026");
+  const pkg = readPackageJson2(project.packageJsonPath);
+  if (pkg) {
+    const addedBuild = ensureBuildScript(pkg);
+    if (addedBuild) {
+      writePackageJson(project.packageJsonPath, pkg);
+      steps.push("Added build script to package.json");
+    }
+  }
+  spinner2.stop("package.json ready");
+  if (!options.skipViteConfig && installOk) {
+    spinner2.start("Configuring Vite\u2026");
+    if (project.viteConfigPath) {
+      const result = patchViteConfig(project.viteConfigPath);
+      if (result.changed) {
+        steps.push(result.message);
+      } else if (!result.message.includes("already")) {
+        warnings.push(result.message);
+      } else {
+        steps.push(result.message);
+      }
+    } else {
+      const useTs = fileExists(join4(cwd, "tsconfig.json"));
+      const created = createDefaultViteConfig(cwd, useTs, project.framework);
+      steps.push(`Created ${created}`);
+    }
+    spinner2.stop("Vite configured with vite-basepath");
+  } else if (!options.skipViteConfig && !installOk) {
+    warnings.push("Skipped vite config \u2014 install vite-basepath first");
+  }
+  if (!options.skipRouter) {
+    const needsRouter = project.framework === "react" && project.hasReactRouter || project.framework === "vue" && project.hasVueRouter;
+    if (needsRouter) {
+      spinner2.start("Configuring client-side router\u2026");
+      const routerFiles = findRouterEntryFiles(cwd, project.framework);
+      const results = patchRouterFiles(routerFiles, project.framework);
+      for (const r of results) {
+        if (r.changed) steps.push(r.message);
+        else warnings.push(r.message);
+      }
+      if (results.length === 0) {
+        warnings.push(
+          `Found ${project.framework} router dependency but could not locate entry file \u2014 add basename={getBase()} manually`
+        );
+      }
+      spinner2.stop("Router setup complete");
+    }
+  }
+  if (!options.skipCi) {
+    spinner2.start("Creating GitHub Actions workflow\u2026");
+    const { path, created } = writeWorkflow({
+      cwd,
+      packageManager: project.packageManager,
+      nodeVersion: options.nodeVersion,
+      buildOutputDir: options.outDir
+    });
+    steps.push(created ? `Created ${path}` : `Updated ${path}`);
+    spinner2.stop("CI workflow ready");
+  }
+  if (gitRemote) {
+    pagesUrl = getPagesUrl(gitRemote.owner, gitRemote.repo, gitRemote.isUserSite);
+  }
+  return { success: true, steps, warnings, pagesUrl };
+}
+function printSummary(result, packageManager) {
+  if (!result.success) {
+    p.log.error(result.warnings[0] ?? "Setup failed");
+    return;
+  }
+  p.note(
+    [
+      "Push your code to GitHub",
+      "Go to repo \u2192 Settings \u2192 Pages",
+      'Set Source to "GitHub Actions"',
+      `Run ${pc2.cyan(buildCommand(packageManager))} locally to verify`
+    ].join("\n"),
+    "Next steps"
+  );
+  if (result.pagesUrl) {
+    p.log.success(`Your site will be live at: ${pc2.cyan(pc2.underline(result.pagesUrl))}`);
+  }
+  if (result.warnings.length > 0) {
+    p.log.warn("Notes:");
+    for (const w of result.warnings) {
+      p.log.message(`  \u2022 ${w}`);
+    }
+  }
+  p.outro(pc2.green("Done! Your Vite app is ready for GitHub Pages."));
+}
+
+// src/cli.ts
+var HELP = `
+${"\x1B[1m"}vite-on-github\x1B[0m \u2014 Prepare any Vite project for GitHub Pages
+
+\x1B[1mUsage:\x1B[0m
+  npx vite-on-github [command] [options]
+
+\x1B[1mCommands:\x1B[0m
+  init          Set up vite config, base paths, router, and CI (default)
+  help          Show this help
+
+\x1B[1mOptions:\x1B[0m
+  -y, --yes           Skip prompts, use defaults
+  --skip-install      Do not install vite-basepath
+  --skip-vite-config  Do not patch vite.config
+  --skip-router       Do not patch React/Vue router
+  --skip-ci           Do not create GitHub Actions workflow
+  --node <version>    Node.js version for CI (default: 22)
+  --out-dir <dir>     Build output directory (default: dist)
+
+\x1B[1mExamples:\x1B[0m
+  npx vite-on-github
+  npx vite-on-github init
+  npx vite-on-github init -y
+  npx vite-on-github init --node 20 --out-dir dist
+`;
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  let command = "init";
+  const options = {
+    yes: false,
+    skipInstall: false,
+    skipViteConfig: false,
+    skipRouter: false,
+    skipCi: false,
+    nodeVersion: void 0,
+    outDir: void 0
+  };
+  let i = 0;
+  if (args[0] && !args[0].startsWith("-")) {
+    command = args[0];
+    i = 1;
+  }
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "-y":
+      case "--yes":
+        options.yes = true;
+        break;
+      case "--skip-install":
+        options.skipInstall = true;
+        break;
+      case "--skip-vite-config":
+        options.skipViteConfig = true;
+        break;
+      case "--skip-router":
+        options.skipRouter = true;
+        break;
+      case "--skip-ci":
+        options.skipCi = true;
+        break;
+      case "--node":
+        options.nodeVersion = args[++i];
+        break;
+      case "--out-dir":
+        options.outDir = args[++i];
+        break;
+      default:
+        break;
+    }
+  }
+  return { command, options };
+}
+async function main() {
+  const { command, options } = parseArgs(process.argv);
+  if (command === "help" || command === "--help" || command === "-h") {
+    console.log(HELP);
+    return;
+  }
+  if (command !== "init") {
+    console.error(`Unknown command: ${command}
+Run "vite-on-github help" for usage.`);
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const project = detectProject(cwd);
+  const pm = project?.packageManager ?? detectPackageManager(cwd);
+  const result = await init({
+    cwd,
+    yes: options.yes,
+    skipInstall: options.skipInstall,
+    skipViteConfig: options.skipViteConfig,
+    skipRouter: options.skipRouter,
+    skipCi: options.skipCi,
+    nodeVersion: options.nodeVersion,
+    outDir: options.outDir
+  });
+  if (!result.success) {
+    console.error(result.warnings[0] ?? "Setup failed");
+    process.exit(1);
+  }
+  printSummary(result, pm);
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map