stackpatch 1.1.2 → 1.1.4

package/src/index.ts

@@ -0,0 +1,215 @@
+#!/usr/bin/env bun
+
+// Try to import dependencies and show helpful error if they're missing
+let chalk: typeof import("chalk").default;
+let inquirer: any;
+
+try {
+  const chalkModule = await import("chalk");
+  const inquirerModule = await import("inquirer");
+  chalk = chalkModule.default;
+  // Inquirer v13 uses default export
+  inquirer = inquirerModule.default || inquirerModule;
+} catch (error: any) {
+  if (error?.code === "ENOENT" || error?.message?.includes("Cannot find module")) {
+    console.error("\n❌ Missing Dependencies\n");
+    console.error("Required dependencies are not installed.");
+    console.error("\nTo fix this, run:");
+    console.error("  cd packages/cli");
+    console.error("  pnpm install");
+    console.error("\nOr from the project root:");
+    console.error("  pnpm install");
+    console.error();
+    process.exit(1);
+  }
+  throw error;
+}
+import { PATCHES } from "./config.js";
+import { showLogo } from "./ui/logo.js";
+import { createProject } from "./commands/create.js";
+import { addPatch } from "./commands/add.js";
+import { revertPatch } from "./commands/revert.js";
+
+/**
+ * Main CLI entry point
+ */
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const projectName = args[1];
+  const skipPrompts = args.includes("--yes") || args.includes("-y");
+
+  // Show logo on startup
+  showLogo();
+
+  // Handle: bun create stackpatch@latest (no project name)
+  // Show welcome and prompt for project name
+  if (!command || command.startsWith("-")) {
+    const { name } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: chalk.white("Enter your project name or path (relative to current directory)"),
+        default: "my-stackpatch-app",
+        validate: (input: string) => {
+          if (!input.trim()) {
+            return "Project name cannot be empty";
+          }
+          return true;
+        },
+      },
+    ]);
+    await createProject(name.trim(), false, skipPrompts); // Don't show welcome again
+    return;
+  }
+
+  // Handle: npx stackpatch revert
+  if (command === "revert") {
+    await revertPatch();
+    return;
+  }
+
+  // Handle: bun create stackpatch@latest my-app
+  // When bun runs create, it passes project name as first arg (not "create")
+  // Check if first arg looks like a project name (not a known command)
+  // Always ask for project name first, even if provided
+  if (
+    command &&
+    !["add", "create", "revert"].includes(command) &&
+    !PATCHES[command] &&
+    !command.startsWith("-")
+  ) {
+    // Likely called as: bun create stackpatch@latest my-app
+    // But we'll ask for project name anyway to be consistent
+    await showLogo();
+    const { name } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: chalk.white("Enter your project name or path (relative to current directory)"),
+        default: command || "my-stackpatch-app", // Use provided name as default
+        validate: (input: string) => {
+          if (!input.trim()) {
+            return "Project name cannot be empty";
+          }
+          return true;
+        },
+      },
+    ]);
+    await createProject(name.trim(), false, skipPrompts); // Welcome already shown
+    return;
+  }
+
+  // Handle: npx stackpatch create my-app
+  if (command === "create") {
+    if (!projectName) {
+      showLogo();
+      const { name } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: chalk.white("Enter your project name or path (relative to current directory)"),
+          default: "my-stackpatch-app",
+          validate: (input: string) => {
+            if (!input.trim()) {
+              return "Project name cannot be empty";
+            }
+            return true;
+          },
+        },
+      ]);
+      await createProject(name.trim(), false); // Logo already shown
+      return;
+    }
+    await createProject(projectName, false, skipPrompts); // Logo already shown
+    return;
+  }
+
+  // Handle: npx stackpatch add auth-ui
+  const patchName = args[1];
+  if (command === "add" && patchName) {
+    await addPatch(patchName);
+    return;
+  }
+
+  // If no command, show help or interactive mode
+  if (!command) {
+    await showLogo();
+    console.log(chalk.yellow("Usage:"));
+    console.log(chalk.white("  ") + chalk.cyan("npm create stackpatch@latest") + chalk.gray(" [project-name]"));
+    console.log(chalk.white("  ") + chalk.cyan("npx create-stackpatch@latest") + chalk.gray(" [project-name]"));
+    console.log(chalk.white("  ") + chalk.cyan("bunx create-stackpatch@latest") + chalk.gray(" [project-name]"));
+    console.log(chalk.white("  ") + chalk.cyan("npx stackpatch create") + chalk.gray(" [project-name]"));
+    console.log(chalk.white("  ") + chalk.cyan("npx stackpatch add") + chalk.white(" <patch-name>"));
+    console.log(
+      chalk.white("  ") + chalk.cyan("npx stackpatch revert") + chalk.gray(" - Revert a patch installation")
+    );
+    console.log(chalk.white("\nExamples:"));
+    console.log(chalk.gray("  npm create stackpatch@latest my-app"));
+    console.log(chalk.gray("  npx create-stackpatch@latest my-app"));
+    console.log(chalk.gray("  bunx create-stackpatch@latest my-app"));
+    console.log(chalk.gray("  npx stackpatch create my-app"));
+    console.log(chalk.gray("  npx stackpatch add auth-ui"));
+    console.log(chalk.gray("\n"));
+    process.exit(0);
+  }
+
+  // Interactive mode (fallback)
+  console.log(chalk.blue.bold("\n🚀 Welcome to StackPatch CLI\n"));
+
+  let selectedPatch: string | null = null;
+  let goBack = false;
+
+  // 1️⃣ Select patch with back option
+  do {
+    const response = await inquirer.prompt([
+      {
+        type: "list",
+        name: "patch",
+        message: "Which patch do you want to add?",
+        choices: [
+          ...Object.keys(PATCHES)
+            .filter((p) => p !== "auth-ui") // Don't show duplicate
+            .map((p) => ({ name: p, value: p })),
+          new inquirer.Separator(),
+          {
+            name: chalk.gray("← Go back / Cancel"),
+            value: "back",
+          },
+        ],
+      },
+    ]);
+
+    if (response.patch === "back") {
+      goBack = true;
+      break;
+    }
+
+    selectedPatch = response.patch;
+  } while (!selectedPatch);
+
+  if (goBack || !selectedPatch) {
+    console.log(chalk.yellow("\n← Cancelled"));
+    return;
+  }
+
+  const patch = selectedPatch;
+
+  // 2️⃣ Enter target Next.js app folder
+  const { target } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "target",
+      message:
+        "Enter the relative path to your Next.js app folder (e.g., ../../apps/stackpatch-frontend):",
+      default: process.cwd(),
+    },
+  ]);
+
+  await addPatch(patch, target);
+}
+
+main().catch((error) => {
+  console.error(chalk.red("❌ Error:"), error);
+  process.exit(1);
+});

package/src/manifest.ts

@@ -0,0 +1,87 @@
+import fs from "fs";
+import path from "path";
+import type { StackPatchManifest } from "./config.js";
+
+/**
+ * Manifest management for tracking StackPatch installations
+ */
+
+/**
+ * Get manifest path for a target directory
+ */
+export function getManifestPath(target: string): string {
+  return path.join(target, ".stackpatch", "manifest.json");
+}
+
+/**
+ * Read manifest if it exists
+ */
+export function readManifest(target: string): StackPatchManifest | null {
+  const manifestPath = getManifestPath(target);
+  if (!fs.existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(manifestPath, "utf-8");
+    return JSON.parse(content) as StackPatchManifest;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write manifest
+ */
+export function writeManifest(target: string, manifest: StackPatchManifest): void {
+  const manifestDir = path.join(target, ".stackpatch");
+  const manifestPath = getManifestPath(target);
+
+  if (!fs.existsSync(manifestDir)) {
+    fs.mkdirSync(manifestDir, { recursive: true });
+  }
+
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+}
+
+/**
+ * Backup a file before modifying it
+ */
+export function backupFile(filePath: string, target: string): string | null {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  const backupDir = path.join(target, ".stackpatch", "backups");
+  if (!fs.existsSync(backupDir)) {
+    fs.mkdirSync(backupDir, { recursive: true });
+  }
+
+  const relativePath = path.relative(target, filePath);
+  const backupPath = path.join(backupDir, relativePath.replace(/\//g, "_").replace(/\\/g, "_"));
+
+  // Create directory structure in backup
+  const backupFileDir = path.dirname(backupPath);
+  if (!fs.existsSync(backupFileDir)) {
+    fs.mkdirSync(backupFileDir, { recursive: true });
+  }
+
+  fs.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+
+/**
+ * Restore a file from backup
+ */
+export function restoreFile(backupPath: string, originalPath: string): boolean {
+  if (!fs.existsSync(backupPath)) {
+    return false;
+  }
+
+  const originalDir = path.dirname(originalPath);
+  if (!fs.existsSync(originalDir)) {
+    fs.mkdirSync(originalDir, { recursive: true });
+  }
+
+  fs.copyFileSync(backupPath, originalPath);
+  return true;
+}

package/src/ui/logo.ts

@@ -0,0 +1,24 @@
+import chalk from "chalk";
+
+/**
+ * Display StackPatch logo
+ */
+export function showLogo(): void {
+  console.log("\n");
+
+  // StackPatch logo ASCII art
+  const logo = [
+    chalk.magentaBright("  _________ __                 __     __________         __         .__"),
+    chalk.magentaBright(" /   _____//  |______    ____ |  | __ \\\\______   \\_____ _/  |_  ____ |  |__"),
+    chalk.magentaBright(" \\_____  \\\\   __\\__  \\ _/ ___\\|  |/ /  |     ___/\\__  \\\\   __\\/ ___\\|  |  \\"),
+    chalk.magentaBright(" /        \\|  |  / __ \\\\  \\___|    <   |    |     / __ \\|  | \\  \\___|   Y  \\"),
+    chalk.magentaBright("/_______  /|__| (____  /\\___  >__|_ \\  |____|    (____  /__|  \\___  >___|  /"),
+    chalk.magentaBright("        \\/           \\/     \\/     \\/                 \\/          \\/     \\/"),
+    "",
+    chalk.white("  Composable frontend features for modern React & Next.js"),
+    chalk.gray("  Add authentication, UI components, and more with zero configuration"),
+    "",
+  ];
+
+  logo.forEach((line) => console.log(line));
+}

package/src/ui/progress.ts

@@ -0,0 +1,82 @@
+import chalk from "chalk";
+
+/**
+ * Progress tracker with checkmarks
+ */
+export class ProgressTracker {
+  private steps: Array<{
+    name: string;
+    status: "pending" | "processing" | "completed" | "failed";
+    interval?: NodeJS.Timeout;
+  }> = [];
+
+  addStep(name: string): void {
+    this.steps.push({ name, status: "pending" });
+  }
+
+  startStep(index: number): void {
+    if (index >= 0 && index < this.steps.length) {
+      this.steps[index].status = "processing";
+      const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+      let frameIndex = 0;
+      const step = this.steps[index];
+
+      const interval = setInterval(() => {
+        process.stdout.write(`\r${chalk.yellow(frames[frameIndex])} ${step.name}`);
+        frameIndex = (frameIndex + 1) % frames.length;
+      }, 100);
+
+      this.steps[index].interval = interval;
+    }
+  }
+
+  completeStep(index: number): void {
+    if (index >= 0 && index < this.steps.length) {
+      if (this.steps[index].interval) {
+        clearInterval(this.steps[index].interval);
+        this.steps[index].interval = undefined;
+      }
+      process.stdout.write(`\r${chalk.green("✓")} ${this.steps[index].name}\n`);
+      this.steps[index].status = "completed";
+    }
+  }
+
+  failStep(index: number): void {
+    if (index >= 0 && index < this.steps.length) {
+      if (this.steps[index].interval) {
+        clearInterval(this.steps[index].interval);
+        this.steps[index].interval = undefined;
+      }
+      process.stdout.write(`\r${chalk.red("✗")} ${this.steps[index].name}\n`);
+      this.steps[index].status = "failed";
+    }
+  }
+
+  getSteps() {
+    return this.steps;
+  }
+}
+
+/**
+ * Helper function with spinner and checkmark
+ */
+export async function withSpinner<T>(text: string, fn: () => Promise<T> | T): Promise<T> {
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let frameIndex = 0;
+
+  const interval = setInterval(() => {
+    process.stdout.write(`\r${chalk.yellow(frames[frameIndex])} ${text}`);
+    frameIndex = (frameIndex + 1) % frames.length;
+  }, 100);
+
+  try {
+    const result = await fn();
+    clearInterval(interval);
+    process.stdout.write(`\r${chalk.green("✓")} ${text}\n`);
+    return result;
+  } catch (error) {
+    clearInterval(interval);
+    process.stdout.write(`\r${chalk.red("✗")} ${text}\n`);
+    throw error;
+  }
+}

package/src/utils/dependencies.ts

@@ -0,0 +1,114 @@
+import fs from "fs";
+import path from "path";
+import { spawnSync } from "child_process";
+
+/**
+ * Utility functions for managing dependencies
+ */
+
+/**
+ * Check if dependency exists in package.json
+ */
+export function hasDependency(target: string, depName: string): boolean {
+  const packageJsonPath = path.join(target, "package.json");
+  if (!fs.existsSync(packageJsonPath)) return false;
+
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    return !!deps[depName];
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Install dependencies (only missing ones)
+ */
+export function installDependencies(target: string, deps: string[]): void {
+  if (deps.length === 0) return;
+
+  // Check if target directory and package.json exist
+  const packageJsonPath = path.join(target, "package.json");
+  if (!fs.existsSync(target)) {
+    throw new Error(`Target directory does not exist: ${target}`);
+  }
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new Error(`package.json not found in ${target}. Make sure you're in a valid project directory.`);
+  }
+
+  const missingDeps = deps.filter((dep) => !hasDependency(target, dep));
+
+  if (missingDeps.length === 0) {
+    return; // Already installed, spinner will show completion
+  }
+
+  // Use non-interactive flags to prevent credential prompts
+  const result = spawnSync("pnpm", ["add", ...missingDeps], {
+    cwd: target,
+    stdio: "pipe",
+    env: {
+      ...process.env,
+      // Prevent Git credential prompts
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_ASKPASS: "",
+      // Prevent npm/pnpm credential prompts
+      NPM_CONFIG_PROGRESS: "false",
+    },
+  });
+
+  if (result.status !== 0) {
+    const errorOutput = result.stderr?.toString() || result.stdout?.toString() || "Unknown error";
+    // Extract the actual error message if available
+    const errorLines = errorOutput.split("\n").filter((line: string) =>
+      line.trim() && (line.includes("error") || line.includes("Error") || line.includes("ERR"))
+    );
+    const errorMessage = errorLines.length > 0 ? errorLines.join("\n") : errorOutput;
+    throw new Error(`Failed to install dependencies: ${missingDeps.join(", ")}\n${errorMessage}`);
+  }
+}
+
+/**
+ * Remove dependencies from package.json
+ */
+export function removeDependencies(target: string, deps: string[]): boolean {
+  if (deps.length === 0) return true;
+
+  const packageJsonPath = path.join(target, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return false;
+  }
+
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    let modified = false;
+
+    // Remove from dependencies
+    if (packageJson.dependencies) {
+      for (const dep of deps) {
+        if (packageJson.dependencies[dep]) {
+          delete packageJson.dependencies[dep];
+          modified = true;
+        }
+      }
+    }
+
+    // Remove from devDependencies
+    if (packageJson.devDependencies) {
+      for (const dep of deps) {
+        if (packageJson.devDependencies[dep]) {
+          delete packageJson.devDependencies[dep];
+          modified = true;
+        }
+      }
+    }
+
+    if (modified) {
+      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+    }
+
+    return modified;
+  } catch {
+    return false;
+  }
+}

package/src/utils/deps-check.ts

@@ -0,0 +1,45 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Check if required dependencies are installed
+ */
+export function checkDependencies(): { missing: string[]; allInstalled: boolean } {
+  const requiredDeps = ["inquirer", "chalk", "fs-extra"];
+  const missing: string[] = [];
+
+  // Get the CLI directory
+  // @ts-expect-error - Bun-specific API
+  const CLI_DIR = import.meta.dir || path.dirname(new URL(import.meta.url).pathname);
+  const nodeModulesPath = path.resolve(CLI_DIR, "../node_modules");
+
+  for (const dep of requiredDeps) {
+    const depPath = path.join(nodeModulesPath, dep);
+    // Check if it exists (could be a symlink or directory)
+    if (!fs.existsSync(depPath)) {
+      missing.push(dep);
+    }
+  }
+
+  return {
+    missing,
+    allInstalled: missing.length === 0,
+  };
+}
+
+/**
+ * Show helpful error message if dependencies are missing
+ * Uses plain console.error to avoid importing chalk (which might not be installed)
+ */
+export function showDependencyError(missing: string[]): void {
+  console.error("\n❌ Missing Dependencies\n");
+  console.error("The following dependencies are not installed:");
+  missing.forEach((dep) => console.error(`  - ${dep}`));
+  console.error("\nTo fix this, run:");
+  console.error("  cd packages/cli");
+  console.error("  pnpm install");
+  console.error("\nOr from the project root:");
+  console.error("  pnpm install");
+  console.error();
+  process.exit(1);
+}

package/src/utils/files.ts

@@ -0,0 +1,58 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Utility functions for file operations
+ */
+
+/**
+ * Remove empty directories recursively
+ */
+export function removeEmptyDirectories(dirPath: string, rootPath: string): void {
+  if (!fs.existsSync(dirPath)) return;
+
+  // Don't remove the root directory or .stackpatch
+  if (dirPath === rootPath || dirPath.includes(".stackpatch")) return;
+
+  try {
+    const entries = fs.readdirSync(dirPath);
+
+    // Recursively remove empty subdirectories
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry);
+      if (fs.statSync(fullPath).isDirectory()) {
+        removeEmptyDirectories(fullPath, rootPath);
+      }
+    }
+
+    // Check if directory is now empty (after removing subdirectories)
+    const remainingEntries = fs.readdirSync(dirPath);
+    if (remainingEntries.length === 0) {
+      fs.rmdirSync(dirPath);
+    }
+  } catch {
+    // Ignore errors when removing directories
+  }
+}
+
+/**
+ * Find all TypeScript/TSX files in a directory recursively
+ */
+export function findTypeScriptFiles(dir: string, fileList: string[] = []): string[] {
+  if (!fs.existsSync(dir)) return fileList;
+
+  const files = fs.readdirSync(dir);
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+
+    if (stat.isDirectory()) {
+      findTypeScriptFiles(filePath, fileList);
+    } else if (file.endsWith(".tsx") || file.endsWith(".ts")) {
+      fileList.push(filePath);
+    }
+  }
+
+  return fileList;
+}