stackpatch 1.0.9 → 1.1.1

package/bin/stackpatch.ts

@@ -44,6 +44,7 @@ interface StackPatchManifest {
       originalContent: string;
     }[];
     backedUp: string[];
+    envFiles?: string[]; // Track .env.local and .env.example if created
   };
   dependencies: string[];
   oauthProviders: string[];
@@ -276,7 +277,7 @@ async function copyFiles(src: string, dest: string): Promise<{ success: boolean;
       }
     } else {
       // For other files/directories (middleware, etc.), check in root
-      const destPath = path.join(dest, entry.name);
+    const destPath = path.join(dest, entry.name);
       if (fs.existsSync(destPath)) {
         conflicts.push(destPath);
       }
@@ -302,53 +303,56 @@ async function copyFiles(src: string, dest: string): Promise<{ success: boolean;
     }
   }
 
+  // Track files from SOURCE (boilerplate) before copying
+  // This ensures we only track files that are actually from StackPatch
+  function trackSourceFiles(srcDir: string, baseDir: string, targetBase: string): void {
+    if (!fs.existsSync(srcDir)) return;
+
+    const files = fs.readdirSync(srcDir, { withFileTypes: true });
+    for (const file of files) {
+      const srcFilePath = path.join(srcDir, file.name);
+      if (file.isDirectory()) {
+        trackSourceFiles(srcFilePath, baseDir, targetBase);
+      } else {
+        const relativePath = path.relative(baseDir, srcFilePath);
+        const targetPath = targetBase
+          ? path.join(targetBase, relativePath).replace(/\\/g, "/")
+          : relativePath.replace(/\\/g, "/");
+        addedFiles.push(targetPath);
+      }
+    }
+  }
+
   // Copy files with smart app directory handling
   for (const entry of entries) {
     const srcPath = path.join(src, entry.name);
 
     if (entry.name === "app") {
+      // Track files from SOURCE boilerplate before copying
+      trackSourceFiles(srcPath, srcPath, appDir);
+
       // Copy app directory contents to the detected app directory location
       await fse.ensureDir(appDirPath);
       await fse.copy(srcPath, appDirPath, { overwrite: true });
-
-      // Track all files in app directory
-      function trackFiles(dir: string, baseDir: string) {
-        const files = fs.readdirSync(dir, { withFileTypes: true });
-        for (const file of files) {
-          const filePath = path.join(dir, file.name);
-          if (file.isDirectory()) {
-            trackFiles(filePath, baseDir);
-          } else {
-            const relativePath = path.relative(baseDir, filePath);
-            addedFiles.push(path.join(appDir, relativePath).replace(/\\/g, "/"));
-          }
-        }
-      }
-      trackFiles(appDirPath, appDirPath);
     } else if (entry.name === "components") {
+      // Track files from SOURCE boilerplate before copying
+      trackSourceFiles(srcPath, srcPath, componentsDir);
+
       // Copy components directory to the detected components directory location
       await fse.ensureDir(componentsDirPath);
       await fse.copy(srcPath, componentsDirPath, { overwrite: true });
-
-      // Track all files in components directory
-      function trackFiles(dir: string, baseDir: string) {
-        const files = fs.readdirSync(dir, { withFileTypes: true });
-        for (const file of files) {
-          const filePath = path.join(dir, file.name);
-          if (file.isDirectory()) {
-            trackFiles(filePath, baseDir);
-          } else {
-            const relativePath = path.relative(baseDir, filePath);
-            addedFiles.push(path.join(componentsDir, relativePath).replace(/\\/g, "/"));
-          }
-        }
-      }
-      trackFiles(componentsDirPath, componentsDirPath);
     } else {
+      // For root-level files/directories, track from source
+      const srcStat = fs.statSync(srcPath);
+      if (srcStat.isDirectory()) {
+        trackSourceFiles(srcPath, srcPath, "");
+      } else {
+        addedFiles.push(entry.name);
+      }
+
       // Copy other files/directories (middleware, etc.) to root
       const destPath = path.join(dest, entry.name);
       await fse.copy(srcPath, destPath, { overwrite: true });
-      addedFiles.push(entry.name);
     }
   }
 
@@ -574,6 +578,91 @@ function installDependencies(target: string, deps: string[]) {
   }
 }
 
+// Remove dependencies from package.json
+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;
+  }
+}
+
+// Remove empty directories recursively
+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
+  }
+}
+
+// Get all parent directories of a file path
+function getParentDirectories(filePath: string, rootPath: string): string[] {
+  const dirs: string[] = [];
+  let current = path.dirname(filePath);
+  const root = path.resolve(rootPath);
+
+  while (current !== root && current !== path.dirname(current)) {
+    dirs.push(current);
+    current = path.dirname(current);
+  }
+
+  return dirs;
+}
+
 // Update layout.tsx to include Toaster
 function updateLayoutForToaster(target: string): { success: boolean; modified: boolean; filePath: string; originalContent?: string } {
   const appDir = detectAppDirectory(target);
@@ -797,10 +886,10 @@ async function setupAuth(target: string, selectedProviders: string[]): Promise<b
     await updateNextAuthWithProviders(nextAuthRoutePath, selectedProviders);
     tracker.completeStep(2);
 
-    // Step 3: Update UI components
-    tracker.startStep(3);
+      // Step 3: Update UI components
+      tracker.startStep(3);
     await updateAuthButtonWithProviders(target, selectedProviders);
-    tracker.completeStep(3);
+      tracker.completeStep(3);
 
     tracker.completeStep(0);
 
@@ -871,12 +960,12 @@ async function showOAuthSetupInstructions(target: string, selectedProviders: str
     }
 
     if (selectedProviders.includes("google") || selectedProviders.includes("github")) {
-      console.log(chalk.blue.bold("📝 Required Redirect URIs:"));
+    console.log(chalk.blue.bold("📝 Required Redirect URIs:"));
       if (selectedProviders.includes("google")) {
-        console.log(chalk.white("   For Google: ") + chalk.bold("http://localhost:3000/api/auth/callback/google"));
+    console.log(chalk.white("   For Google: ") + chalk.bold("http://localhost:3000/api/auth/callback/google"));
       }
       if (selectedProviders.includes("github")) {
-        console.log(chalk.white("   For GitHub: ") + chalk.bold("http://localhost:3000/api/auth/callback/github"));
+    console.log(chalk.white("   For GitHub: ") + chalk.bold("http://localhost:3000/api/auth/callback/github"));
       }
       console.log(chalk.gray("\n   For production, also add your production domain URLs\n"));
     }
@@ -1538,17 +1627,17 @@ async function createProject(projectName: string, showWelcomeScreen: boolean = t
 
   console.log(chalk.green(`\n✅ Project "${projectName}" created successfully!`));
 
-    // Automatically add auth-ui after creating the project
-    console.log(chalk.blue.bold(`\n🔐 Adding authentication to your project...\n`));
+  // Automatically add auth-ui after creating the project
+  console.log(chalk.blue.bold(`\n🔐 Adding authentication to your project...\n`));
 
-    const authSrc = path.join(BOILERPLATE_ROOT, PATCHES["auth-ui"].path);
+  const authSrc = path.join(BOILERPLATE_ROOT, PATCHES["auth-ui"].path);
     const authCopyResult = await copyFiles(authSrc, targetPath);
 
     if (authCopyResult.success) {
       const addedFiles = authCopyResult.addedFiles;
       const modifiedFiles: Array<{ path: string; originalContent: string }> = [];
-      // Install auth dependencies (only if missing)
-      installDependencies(targetPath, PATCHES["auth-ui"].dependencies);
+    // Install auth dependencies (only if missing)
+    installDependencies(targetPath, PATCHES["auth-ui"].dependencies);
 
       // Ask which OAuth providers to configure
       const selectedProviders = await askOAuthProviders();
@@ -1556,22 +1645,22 @@ async function createProject(projectName: string, showWelcomeScreen: boolean = t
       // Setup authentication with selected providers
       const success = await setupAuth(targetPath, selectedProviders);
 
-      if (success) {
-        await withSpinner("Updating layout with AuthSessionProvider", () => {
+    if (success) {
+      await withSpinner("Updating layout with AuthSessionProvider", () => {
           const result = updateLayoutForAuth(targetPath);
           if (result.modified && result.originalContent) {
             modifiedFiles.push({ path: result.filePath, originalContent: result.originalContent });
           }
-          return true;
-        });
+        return true;
+      });
 
-        await withSpinner("Adding Toaster component", () => {
+      await withSpinner("Adding Toaster component", () => {
           const result = updateLayoutForToaster(targetPath);
           if (result.modified && result.originalContent) {
             modifiedFiles.push({ path: result.filePath, originalContent: result.originalContent });
           }
-          return true;
-        });
+        return true;
+      });
 
       await withSpinner("Setting up protected routes", () => {
         copyProtectedRouteFiles(targetPath);
@@ -1643,57 +1732,6 @@ async function main() {
     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"].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 showWelcome();
-    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) {
-      showWelcome();
-      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 revert
   if (command === "revert") {
     let target = process.cwd();
@@ -1725,11 +1763,19 @@ async function main() {
     console.log(chalk.white(`   Patch: ${chalk.cyan(manifest.patchName)}`));
     console.log(chalk.white(`   Installed: ${chalk.gray(new Date(manifest.timestamp).toLocaleString())}\n`));
 
+    // Show what will be reverted
+    console.log(chalk.white("   Files to remove: ") + chalk.cyan(`${manifest.files.added.length}`));
+    console.log(chalk.white("   Files to restore: ") + chalk.cyan(`${manifest.files.modified.length}`));
+    if (manifest.dependencies.length > 0) {
+      console.log(chalk.white("   Dependencies to remove: ") + chalk.cyan(`${manifest.dependencies.join(", ")}`));
+    }
+    console.log();
+
     const { confirm } = await inquirer.prompt([
       {
         type: "confirm",
         name: "confirm",
-        message: "Are you sure you want to revert this installation? This will remove all added files and restore modified files.",
+        message: "Are you sure you want to revert this installation? This will remove all added files, restore modified files, and remove dependencies.",
         default: false,
       },
     ]);
@@ -1739,20 +1785,134 @@ async function main() {
       return;
     }
 
-    // Remove added files
+    console.log(chalk.blue("\n🔄 Starting revert process...\n"));
+
+    let removedCount = 0;
+    let restoredCount = 0;
+    let failedRemovals: string[] = [];
+    let failedRestorations: string[] = [];
+    const directoriesToCheck: Set<string> = new Set();
+
+    // Step 1: Get list of valid StackPatch files from boilerplate
+    // This ensures we only remove files that are actually from StackPatch
+    const boilerplatePath = path.join(BOILERPLATE_ROOT, manifest.patchName === "auth-ui" ? "auth" : manifest.patchName);
+    const validStackPatchFiles = new Set<string>();
+
+    function collectBoilerplateFiles(srcDir: string, baseDir: string, targetBase: string): void {
+      if (!fs.existsSync(srcDir)) return;
+
+      const files = fs.readdirSync(srcDir, { withFileTypes: true });
+      for (const file of files) {
+        const srcFilePath = path.join(srcDir, file.name);
+        if (file.isDirectory()) {
+          collectBoilerplateFiles(srcFilePath, baseDir, targetBase);
+        } else {
+          const relativePath = path.relative(baseDir, srcFilePath);
+          const targetPath = targetBase
+            ? path.join(targetBase, relativePath).replace(/\\/g, "/")
+            : relativePath.replace(/\\/g, "/");
+          validStackPatchFiles.add(targetPath);
+        }
+      }
+    }
+
+    // Collect files from boilerplate app directory
+    const appDir = detectAppDirectory(target);
+    const componentsDir = detectComponentsDirectory(target);
+    const boilerplateAppPath = path.join(boilerplatePath, "app");
+    const boilerplateComponentsPath = path.join(boilerplatePath, "components");
+
+    if (fs.existsSync(boilerplateAppPath)) {
+      collectBoilerplateFiles(boilerplateAppPath, boilerplateAppPath, appDir);
+    }
+    if (fs.existsSync(boilerplateComponentsPath)) {
+      collectBoilerplateFiles(boilerplateComponentsPath, boilerplateComponentsPath, componentsDir);
+    }
+
+    // Collect root-level files
+    if (fs.existsSync(boilerplatePath)) {
+      const entries = fs.readdirSync(boilerplatePath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name !== "app" && entry.name !== "components") {
+          const srcPath = path.join(boilerplatePath, entry.name);
+          if (entry.isDirectory()) {
+            collectBoilerplateFiles(srcPath, srcPath, "");
+          } else {
+            validStackPatchFiles.add(entry.name);
+          }
+        }
+      }
+    }
+
+    // Step 1: Remove added files (only if they're actually from StackPatch boilerplate)
+    console.log(chalk.white("📁 Removing added files..."));
     for (const filePath of manifest.files.added) {
+      // Only remove if this file is actually in the boilerplate
+      if (!validStackPatchFiles.has(filePath)) {
+        console.log(chalk.gray(`   ⊘ Skipped (not in boilerplate): ${filePath}`));
+        continue;
+      }
+
       const fullPath = path.join(target, filePath);
       if (fs.existsSync(fullPath)) {
         try {
           fs.unlinkSync(fullPath);
-          console.log(chalk.green(`✓ Removed: ${filePath}`));
+          console.log(chalk.green(`   ✓ Removed: ${filePath}`));
+          removedCount++;
+
+          // Track parent directories for cleanup
+          const parentDirs = getParentDirectories(fullPath, target);
+          parentDirs.forEach(dir => directoriesToCheck.add(dir));
         } catch (error) {
-          console.log(chalk.yellow(`⚠ Could not remove: ${filePath}`));
+          console.log(chalk.yellow(`   ⚠ Could not remove: ${filePath}`));
+          failedRemovals.push(filePath);
         }
+      } else {
+        console.log(chalk.gray(`   ⊘ Already removed: ${filePath}`));
       }
     }
 
-    // Restore modified files from backups
+    // Step 2: Remove .env.local and .env.example if they were created by StackPatch
+    console.log(chalk.white("\n🔐 Removing environment files..."));
+    const envFilesToRemove = manifest.files.envFiles || [];
+
+    // Fallback: check for common env files if not tracked in manifest (for older manifests)
+    if (envFilesToRemove.length === 0) {
+      const commonEnvFiles = [".env.local", ".env.example"];
+      for (const envFile of commonEnvFiles) {
+        const envPath = path.join(target, envFile);
+        if (fs.existsSync(envPath)) {
+          try {
+            // Check if this file was created by StackPatch (contains NEXTAUTH_SECRET)
+            const content = fs.readFileSync(envPath, "utf-8");
+            if (content.includes("NEXTAUTH_SECRET") || content.includes("NEXTAUTH_URL")) {
+              envFilesToRemove.push(envFile);
+            }
+          } catch {
+            // Ignore errors
+          }
+        }
+      }
+    }
+
+    for (const envFile of envFilesToRemove) {
+      const envPath = path.join(target, envFile);
+      if (fs.existsSync(envPath)) {
+        try {
+          fs.unlinkSync(envPath);
+          console.log(chalk.green(`   ✓ Removed: ${envFile}`));
+          removedCount++;
+        } catch (error) {
+          console.log(chalk.yellow(`   ⚠ Could not remove: ${envFile}`));
+          failedRemovals.push(envFile);
+        }
+      } else {
+        console.log(chalk.gray(`   ⊘ Already removed: ${envFile}`));
+      }
+    }
+
+    // Step 3: Restore modified files from backups
+    console.log(chalk.white("\n📝 Restoring modified files..."));
     for (const modified of manifest.files.modified) {
       const backupPath = path.join(target, ".stackpatch", "backups", modified.path.replace(/\//g, "_").replace(/\\/g, "_"));
       const originalPath = path.join(target, modified.path);
@@ -1760,20 +1920,151 @@ async function main() {
       if (fs.existsSync(backupPath)) {
         try {
           restoreFile(backupPath, originalPath);
-          console.log(chalk.green(`✓ Restored: ${modified.path}`));
+          console.log(chalk.green(`   ✓ Restored: ${modified.path}`));
+          restoredCount++;
         } catch (error) {
-          console.log(chalk.yellow(`⚠ Could not restore: ${modified.path}`));
+          console.log(chalk.yellow(`   ⚠ Could not restore: ${modified.path}`));
+          failedRestorations.push(modified.path);
         }
+      } else {
+        console.log(chalk.yellow(`   ⚠ Backup not found: ${modified.path}`));
+        failedRestorations.push(modified.path);
       }
     }
 
-    // Remove manifest and backups
+    // Step 4: Remove dependencies from package.json
+    if (manifest.dependencies.length > 0) {
+      console.log(chalk.white("\n📦 Removing dependencies from package.json..."));
+      const removed = removeDependencies(target, manifest.dependencies);
+      if (removed) {
+        console.log(chalk.green(`   ✓ Removed dependencies: ${manifest.dependencies.join(", ")}`));
+        console.log(chalk.yellow("   ⚠ Run 'pnpm install' to update node_modules"));
+      } else {
+        console.log(chalk.gray("   ⊘ Dependencies not found in package.json"));
+      }
+    }
+
+    // Step 5: Clean up empty directories (only if they only contained StackPatch files)
+    console.log(chalk.white("\n🧹 Cleaning up empty directories..."));
+    const sortedDirs = Array.from(directoriesToCheck).sort((a, b) => b.length - a.length); // Sort by depth (deepest first)
+    let removedDirCount = 0;
+
+    for (const dir of sortedDirs) {
+      if (fs.existsSync(dir)) {
+        try {
+          const entries = fs.readdirSync(dir);
+          if (entries.length === 0) {
+            // Only remove if directory is empty
+            // We know it was created by StackPatch because we're tracking it
+            fs.rmdirSync(dir);
+            removedDirCount++;
+            console.log(chalk.green(`   ✓ Removed empty directory: ${path.relative(target, dir)}`));
+          }
+          // If directory has other files, we don't remove it (silently skip)
+        } catch {
+          // Ignore errors
+        }
+      }
+    }
+
+    if (removedDirCount === 0) {
+      console.log(chalk.gray("   ⊘ No empty directories to remove"));
+    }
+
+    // Step 6: Remove manifest and backups
+    console.log(chalk.white("\n🗑️  Removing StackPatch tracking files..."));
     const stackpatchDir = path.join(target, ".stackpatch");
     if (fs.existsSync(stackpatchDir)) {
-      fs.rmSync(stackpatchDir, { recursive: true, force: true });
+      try {
+        fs.rmSync(stackpatchDir, { recursive: true, force: true });
+        console.log(chalk.green("   ✓ Removed .stackpatch directory"));
+      } catch (error) {
+        console.log(chalk.yellow("   ⚠ Could not remove .stackpatch directory"));
+      }
+    }
+
+    // Step 7: Verification
+    console.log(chalk.white("\n✅ Verification..."));
+    const remainingManifest = readManifest(target);
+    if (remainingManifest) {
+      console.log(chalk.red("   ❌ Warning: Manifest still exists. Revert may be incomplete."));
+    } else {
+      console.log(chalk.green("   ✓ Manifest removed successfully"));
+    }
+
+    // Summary
+    console.log(chalk.blue.bold("\n📊 Revert Summary:"));
+    console.log(chalk.white(`   Files removed: ${chalk.green(removedCount)}`));
+    console.log(chalk.white(`   Files restored: ${chalk.green(restoredCount)}`));
+    if (failedRemovals.length > 0) {
+      console.log(chalk.yellow(`   Failed removals: ${failedRemovals.length}`));
+      failedRemovals.forEach(file => console.log(chalk.gray(`      - ${file}`)));
+    }
+    if (failedRestorations.length > 0) {
+      console.log(chalk.yellow(`   Failed restorations: ${failedRestorations.length}`));
+      failedRestorations.forEach(file => console.log(chalk.gray(`      - ${file}`)));
     }
 
-    console.log(chalk.green("\n✅ Revert complete! Your project has been restored to its original state."));
+    if (failedRemovals.length === 0 && failedRestorations.length === 0 && !remainingManifest) {
+      console.log(chalk.green("\n✅ Revert complete! Your project has been fully restored to its original state."));
+      if (manifest.dependencies.length > 0) {
+        console.log(chalk.yellow("\n⚠️  Remember to run 'pnpm install' to update your node_modules."));
+      }
+    } else {
+      console.log(chalk.yellow("\n⚠️  Revert completed with some warnings. Please review the output above."));
+    }
+
+    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 showWelcome();
+    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) {
+      showWelcome();
+      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;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackpatch",
-  "version": "1.0.9",
+  "version": "1.1.1",
   "description": "Composable frontend features for modern React & Next.js apps - Add authentication, UI components, and more with zero configuration",
   "main": "bin/stackpatch.ts",
   "type": "module",