stackpatch 1.1.4 → 1.1.6

package/src/index.ts

@@ -1,215 +0,0 @@
-#!/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

@@ -1,87 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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;
-}