stackpatch 1.1.2 → 1.1.4

package/src/utils/paths.ts

@@ -0,0 +1,217 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Utility functions for detecting project structure and paths
+ */
+
+/**
+ * Detect the app directory location (app/ or src/app/)
+ */
+export function detectAppDirectory(target: string): string {
+  // Check for src/app first (more common in modern Next.js projects)
+  if (fs.existsSync(path.join(target, "src", "app"))) {
+    return "src/app";
+  }
+  // Check for app directory
+  if (fs.existsSync(path.join(target, "app"))) {
+    return "app";
+  }
+  // Check for src/pages (legacy)
+  if (fs.existsSync(path.join(target, "src", "pages"))) {
+    return "src/pages";
+  }
+  // Check for pages (legacy)
+  if (fs.existsSync(path.join(target, "pages"))) {
+    return "pages";
+  }
+  // Default to app if nothing found (will fail gracefully later)
+  return "app";
+}
+
+/**
+ * Detect the components directory location (components/ or src/components/)
+ */
+export function detectComponentsDirectory(target: string): string {
+  const appDir = detectAppDirectory(target);
+
+  // If app is in src/app, components should be in src/components
+  if (appDir.startsWith("src/")) {
+    // Check if src/components exists
+    if (fs.existsSync(path.join(target, "src", "components"))) {
+      return "src/components";
+    }
+    // Even if it doesn't exist yet, return src/components to match app structure
+    return "src/components";
+  }
+
+  // If app is in root, components should be in root
+  if (fs.existsSync(path.join(target, "components"))) {
+    return "components";
+  }
+
+  // Default to components
+  return "components";
+}
+
+/**
+ * Detect path aliases from tsconfig.json
+ */
+export function detectPathAliases(target: string): { alias: string; path: string } | null {
+  const tsconfigPath = path.join(target, "tsconfig.json");
+
+  if (!fs.existsSync(tsconfigPath)) {
+    return null;
+  }
+
+  try {
+    const tsconfigContent = fs.readFileSync(tsconfigPath, "utf-8");
+    const tsconfig = JSON.parse(tsconfigContent);
+
+    const paths = tsconfig.compilerOptions?.paths;
+    if (!paths || typeof paths !== "object") {
+      return null;
+    }
+
+    // Look for common aliases like @/*, ~/*, etc.
+    for (const [alias, pathsArray] of Object.entries(paths)) {
+      if (Array.isArray(pathsArray) && pathsArray.length > 0) {
+        // Remove the /* from alias (e.g., "@/*" -> "@")
+        const cleanAlias = alias.replace(/\/\*$/, "");
+        // Get the first path and remove /* from it
+        const cleanPath = pathsArray[0].replace(/\/\*$/, "");
+        return { alias: cleanAlias, path: cleanPath };
+      }
+    }
+  } catch (error) {
+    // If parsing fails, return null
+  }
+
+  return null;
+}
+
+/**
+ * Generate import path for components
+ */
+export function generateComponentImportPath(
+  target: string,
+  componentName: string,
+  fromFile: string
+): string {
+  const pathAlias = detectPathAliases(target);
+  const componentsDir = detectComponentsDirectory(target);
+
+  // If we have a path alias, use it
+  if (pathAlias) {
+    // Check if the alias path matches components directory
+    const aliasPath = pathAlias.path.replace(/^\.\//, ""); // Remove leading ./
+
+    // If alias points to root and components is in root, use alias
+    if (aliasPath === "" && componentsDir === "components") {
+      return `${pathAlias.alias}/components/${componentName}`;
+    }
+
+    // If alias points to src and components is in src/components, use alias
+    if (aliasPath === "src" && componentsDir === "src/components") {
+      return `${pathAlias.alias}/components/${componentName}`;
+    }
+
+    // Try to match the alias path structure
+    if (componentsDir.startsWith(aliasPath)) {
+      const relativeFromAlias = componentsDir.replace(new RegExp(`^${aliasPath}/?`), "");
+      return `${pathAlias.alias}/${relativeFromAlias}/${componentName}`;
+    }
+
+    // If alias path is "./" (root), components should be accessible via alias
+    if (aliasPath === "" || aliasPath === ".") {
+      return `${pathAlias.alias}/components/${componentName}`;
+    }
+  }
+
+  // Fallback: calculate relative path
+  // fromFile is the full path to the file we're importing into
+  const fromDir = path.dirname(fromFile);
+  const toComponents = path.join(target, componentsDir);
+
+  // Calculate relative path from the file's directory to components directory
+  const relativePath = path.relative(fromDir, toComponents).replace(/\\/g, "/");
+  const normalizedPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+
+  return `${normalizedPath}/${componentName}`;
+}
+
+/**
+ * Get all parent directories of a file path
+ */
+export 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;
+}
+
+/**
+ * Auto-detect target directory for Next.js app
+ */
+export function detectTargetDirectory(startDir: string = process.cwd()): string {
+  let target = startDir;
+
+  // Check if we're in a Next.js app (has app/, src/app/, pages/, or src/pages/ directory)
+  const hasAppDir =
+    fs.existsSync(path.join(target, "app")) || fs.existsSync(path.join(target, "src", "app"));
+  const hasPagesDir =
+    fs.existsSync(path.join(target, "pages")) || fs.existsSync(path.join(target, "src", "pages"));
+
+  if (!hasAppDir && !hasPagesDir) {
+    // Try parent directory
+    const parent = path.resolve(target, "..");
+    if (
+      fs.existsSync(path.join(parent, "app")) ||
+      fs.existsSync(path.join(parent, "src", "app")) ||
+      fs.existsSync(path.join(parent, "pages")) ||
+      fs.existsSync(path.join(parent, "src", "pages"))
+    ) {
+      target = parent;
+    } else {
+      // Try common monorepo locations: apps/, packages/, or root
+      const possiblePaths = [
+        path.join(target, "apps"),
+        path.join(parent, "apps"),
+        path.join(target, "packages"),
+        path.join(parent, "packages"),
+      ];
+
+      let foundApp = false;
+      for (const possiblePath of possiblePaths) {
+        if (fs.existsSync(possiblePath)) {
+          // Look for Next.js apps in this directory
+          const entries = fs.readdirSync(possiblePath, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              const appPath = path.join(possiblePath, entry.name);
+              if (
+                fs.existsSync(path.join(appPath, "app")) ||
+                fs.existsSync(path.join(appPath, "src", "app")) ||
+                fs.existsSync(path.join(appPath, "pages")) ||
+                fs.existsSync(path.join(appPath, "src", "pages"))
+              ) {
+                target = appPath;
+                foundApp = true;
+                break;
+              }
+            }
+          }
+          if (foundApp) break;
+        }
+      }
+    }
+  }
+
+  return target;
+}

package/src/utils/scanner.ts

@@ -0,0 +1,109 @@
+import fs from "fs";
+import path from "path";
+
+/**
+ * Project scanner to detect project configuration
+ */
+
+export interface ProjectScan {
+  framework: "nextjs" | "unknown";
+  router: "app" | "pages" | "unknown";
+  typescript: boolean;
+  packageManager: "pnpm" | "npm" | "yarn" | "bun" | "unknown";
+  runtime: "node" | "bun" | "unknown";
+  hasSrcDir: boolean;
+  existingAuth: "better-auth" | "next-auth" | "none";
+}
+
+/**
+ * Scan project to detect configuration
+ */
+export function scanProject(target: string): ProjectScan {
+  const scan: ProjectScan = {
+    framework: "unknown",
+    router: "unknown",
+    typescript: false,
+    packageManager: "unknown",
+    runtime: "node",
+    hasSrcDir: false,
+    existingAuth: "none",
+  };
+
+  // Check for Next.js
+  const packageJsonPath = path.join(target, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+      };
+
+      if (deps.next || deps["next"]) {
+        scan.framework = "nextjs";
+      }
+
+      // Detect package manager from lock files
+      if (fs.existsSync(path.join(target, "pnpm-lock.yaml"))) {
+        scan.packageManager = "pnpm";
+      } else if (fs.existsSync(path.join(target, "yarn.lock"))) {
+        scan.packageManager = "yarn";
+      } else if (fs.existsSync(path.join(target, "package-lock.json"))) {
+        scan.packageManager = "npm";
+      } else if (fs.existsSync(path.join(target, "bun.lockb"))) {
+        scan.packageManager = "bun";
+        scan.runtime = "bun";
+      }
+
+      // Check for existing auth
+      if (deps["better-auth"]) {
+        scan.existingAuth = "better-auth";
+      } else if (deps["next-auth"]) {
+        scan.existingAuth = "next-auth";
+      }
+    } catch {
+      // Ignore errors
+    }
+  }
+
+  // Check for TypeScript
+  if (
+    fs.existsSync(path.join(target, "tsconfig.json")) ||
+    fs.existsSync(path.join(target, "src", "tsconfig.json"))
+  ) {
+    scan.typescript = true;
+  }
+
+  // Check for src directory
+  if (fs.existsSync(path.join(target, "src"))) {
+    scan.hasSrcDir = true;
+  }
+
+  // Detect router type
+  if (fs.existsSync(path.join(target, "app")) || fs.existsSync(path.join(target, "src", "app"))) {
+    scan.router = "app";
+  } else if (
+    fs.existsSync(path.join(target, "pages")) ||
+    fs.existsSync(path.join(target, "src", "pages"))
+  ) {
+    scan.router = "pages";
+  }
+
+  return scan;
+}
+
+/**
+ * Format scan results for display
+ */
+export function formatScanResults(scan: ProjectScan): string[] {
+  const results: string[] = [];
+
+  results.push(`✔ Framework: ${scan.framework === "nextjs" ? "Next.js" : "Unknown"} ${scan.router !== "unknown" ? `(${scan.router === "app" ? "App Router" : "Pages Router"})` : ""}`);
+  results.push(`✔ TypeScript: ${scan.typescript ? "Yes" : "No"}`);
+  results.push(`✔ Package Manager: ${scan.packageManager !== "unknown" ? scan.packageManager : "Unknown"}`);
+  results.push(`✔ Runtime: ${scan.runtime === "bun" ? "Bun" : "Node"}`);
+  results.push(`✔ src directory: ${scan.hasSrcDir ? "Yes" : "No"}`);
+  results.push(`✔ Existing auth: ${scan.existingAuth === "none" ? "None" : scan.existingAuth === "better-auth" ? "Better Auth" : "NextAuth"}`);
+
+  return results;
+}

package/boilerplate/auth/app/api/auth/[...nextauth]/route.ts

@@ -1,124 +0,0 @@
-import NextAuth from "next-auth";
-import type { NextAuthOptions } from "next-auth";
-import GoogleProvider from "next-auth/providers/google";
-import GitHubProvider from "next-auth/providers/github";
-import CredentialsProvider from "next-auth/providers/credentials";
-
-export const authOptions: NextAuthOptions = {
-  providers: [
-    CredentialsProvider({
-      name: "Credentials",
-      credentials: {
-        email: { label: "Email", type: "email" },
-        password: { label: "Password", type: "password" },
-      },
-      async authorize(credentials) {
-        // ⚠️ DEMO MODE: This is a placeholder implementation
-        //
-        // TO IMPLEMENT REAL AUTHENTICATION:
-        // 1. Set up a database (PostgreSQL, MongoDB, Prisma, etc.)
-        // 2. Install bcrypt: npm install bcryptjs @types/bcryptjs
-        // 3. Replace this function with database lookup:
-        //
-        // Example implementation:
-        // ```ts
-        // import bcrypt from "bcryptjs";
-        // import { db } from "@/lib/db"; // Your database connection
-        //
-        // async authorize(credentials) {
-        //   if (!credentials?.email || !credentials?.password) {
-        //     return null;
-        //   }
-        //
-        //   // Find user in database
-        //   const user = await db.user.findUnique({
-        //     where: { email: credentials.email },
-        //   });
-        //
-        //   if (!user) {
-        //     return null;
-        //   }
-        //
-        //   // Verify password
-        //   const isValid = await bcrypt.compare(
-        //     credentials.password,
-        //     user.password
-        //   );
-        //
-        //   if (!isValid) {
-        //     return null;
-        //   }
-        //
-        //   return {
-        //     id: user.id,
-        //     email: user.email,
-        //     name: user.name,
-        //   };
-        // }
-        // ```
-        //
-        // Current demo credentials (REMOVE IN PRODUCTION):
-        // Email: demo@example.com
-        // Password: demo123
-
-        if (!credentials?.email || !credentials?.password) {
-          return null;
-        }
-
-        // Demo check - REMOVE THIS IN PRODUCTION
-        if (
-          credentials.email === "demo@example.com" &&
-          credentials.password === "demo123"
-        ) {
-          return {
-            id: "1",
-            email: credentials.email,
-            name: "Demo User",
-          };
-        }
-
-        return null;
-      },
-    }),
-    GoogleProvider({
-      clientId: process.env.GOOGLE_CLIENT_ID!,
-      clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
-    }),
-    GitHubProvider({
-      clientId: process.env.GITHUB_CLIENT_ID!,
-      clientSecret: process.env.GITHUB_CLIENT_SECRET!,
-    }),
-  ],
-  pages: {
-    signIn: "/auth/login",
-    error: "/auth/error",
-  },
-  session: {
-    strategy: "jwt",
-  },
-  callbacks: {
-    async jwt({ token, user, account }) {
-      if (user) {
-        token.id = user.id;
-        token.email = user.email;
-        token.name = user.name;
-      }
-      if (account) {
-        token.accessToken = account.access_token;
-        token.provider = account.provider;
-      }
-      return token;
-    },
-    async session({ session, token }) {
-      if (session.user) {
-        session.user.id = token.id as string;
-        session.accessToken = token.accessToken as string;
-      }
-      return session;
-    },
-  },
-};
-
-const handler = NextAuth(authOptions);
-
-export { handler as GET, handler as POST };

package/boilerplate/auth/app/api/auth/signup/route.ts

@@ -1,45 +0,0 @@
-import { NextResponse } from "next/server";
-
-export async function POST(request: Request) {
-  try {
-    const { email, password, name } = await request.json();
-
-    // TODO: Replace with your actual signup logic
-    // This is a placeholder - you should:
-    // 1. Validate input
-    // 2. Check if user already exists
-    // 3. Hash password (use bcrypt or similar)
-    // 4. Save user to database
-    // 5. Return success or error
-
-    // Example validation
-    if (!email || !password || !name) {
-      return NextResponse.json(
-        { error: "Missing required fields" },
-        { status: 400 }
-      );
-    }
-
-    if (password.length < 6) {
-      return NextResponse.json(
-        { error: "Password must be at least 6 characters" },
-        { status: 400 }
-      );
-    }
-
-    // Placeholder: In production, save to database here
-    // const hashedPassword = await bcrypt.hash(password, 10);
-    // const user = await db.user.create({ email, password: hashedPassword, name });
-
-    return NextResponse.json(
-      { message: "Account created successfully" },
-      { status: 201 }
-    );
-  } catch (error) {
-    console.error("Signup error:", error);
-    return NextResponse.json(
-      { error: "Failed to create account" },
-      { status: 500 }
-    );
-  }
-}

package/boilerplate/auth/app/dashboard/page.tsx

@@ -1,82 +0,0 @@
-"use client";
-
-import React from "react";
-import { useSession } from "next-auth/react";
-import { ProtectedRoute } from "@/components/protected-route";
-import { AuthNavbar } from "@/components/auth-navbar";
-
-/**
- * Dashboard Page Example
- *
- * This is an example protected dashboard page.
- *
- * To use this:
- * 1. Copy this file to your app/dashboard/page.tsx
- * 2. The page is automatically protected using ProtectedRoute
- * 3. The AuthNavbar shows session status and sign out button
- *
- * You can customize this page to show your dashboard content.
- * If you have an existing navbar, replace AuthNavbar with your own.
- */
-export default function DashboardPage() {
-  const { data: session } = useSession();
-
-  return (
-    <ProtectedRoute>
-      <div className="min-h-screen bg-zinc-50 dark:bg-black">
-        <AuthNavbar />
-        <main className="mx-auto max-w-7xl px-4 py-8 sm:px-6 lg:px-8">
-          <div className="rounded-lg bg-white p-8 shadow dark:bg-zinc-900">
-            <h1 className="text-3xl font-bold text-zinc-900 dark:text-zinc-50">
-              Dashboard
-            </h1>
-            <p className="mt-2 text-zinc-600 dark:text-zinc-400">
-              Welcome to your protected dashboard!
-            </p>
-
-            {session && (
-              <div className="mt-6 rounded-md bg-zinc-100 p-4 dark:bg-zinc-800">
-                <h2 className="text-lg font-semibold text-zinc-900 dark:text-zinc-50">
-                  Session Information
-                </h2>
-                <div className="mt-2 space-y-1 text-sm text-zinc-600 dark:text-zinc-400">
-                  <p>
-                    <span className="font-medium">Name:</span>{" "}
-                    {session.user?.name || "Not provided"}
-                  </p>
-                  <p>
-                    <span className="font-medium">Email:</span>{" "}
-                    {session.user?.email || "Not provided"}
-                  </p>
-                  {session.user?.image && (
-                    <p>
-                      <span className="font-medium">Image:</span>{" "}
-                      <img
-                        src={session.user.image}
-                        alt={session.user.name || "User"}
-                        className="mt-2 h-16 w-16 rounded-full"
-                      />
-                    </p>
-                  )}
-                </div>
-              </div>
-            )}
-
-            <div className="mt-8">
-              <h2 className="text-xl font-semibold text-zinc-900 dark:text-zinc-50">
-                Getting Started
-              </h2>
-              <p className="mt-2 text-zinc-600 dark:text-zinc-400">
-                This is a protected page. Only authenticated users can see this
-                content.
-              </p>
-              <p className="mt-2 text-zinc-600 dark:text-zinc-400">
-                Customize this page to add your dashboard features.
-              </p>
-            </div>
-          </div>
-        </main>
-      </div>
-    </ProtectedRoute>
-  );
-}