stackkit 0.1.0

package/dist/lib/git-utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initGit = initGit;
+const child_process_1 = require("child_process");
+async function initGit(cwd) {
+    (0, child_process_1.execSync)("git init", { cwd, stdio: "pipe" });
+    (0, child_process_1.execSync)("git add .", { cwd, stdio: "pipe" });
+    (0, child_process_1.execSync)('git commit -m "Initial commit"', { cwd, stdio: "pipe" });
+}

package/dist/lib/pm/package-manager.d.ts

@@ -0,0 +1,5 @@
+export type PackageManager = "npm" | "yarn" | "pnpm" | "bun";
+export declare function detectPackageManager(cwd: string): Promise<PackageManager>;
+export declare function installDependencies(cwd: string, pm: PackageManager): Promise<void>;
+export declare function addDependencies(cwd: string, pm: PackageManager, packages: string[], dev?: boolean): Promise<void>;
+export declare function initGit(cwd: string): Promise<void>;

package/dist/lib/pm/package-manager.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPackageManager = detectPackageManager;
+exports.installDependencies = installDependencies;
+exports.addDependencies = addDependencies;
+exports.initGit = initGit;
+const detect_package_manager_1 = require("detect-package-manager");
+const execa_1 = __importDefault(require("execa"));
+const logger_1 = require("../ui/logger");
+async function detectPackageManager(cwd) {
+    try {
+        const pm = await (0, detect_package_manager_1.detect)({ cwd });
+        return pm;
+    }
+    catch {
+        return "npm";
+    }
+}
+async function installDependencies(cwd, pm) {
+    const args = [];
+    if (pm === "npm") {
+        args.push("install");
+    }
+    else if (pm === "yarn") {
+        args.push("install");
+    }
+    else if (pm === "pnpm") {
+        args.push("install");
+    }
+    else if (pm === "bun") {
+        args.push("install");
+    }
+    await (0, execa_1.default)(pm, args, { cwd, stdio: "pipe" });
+}
+async function addDependencies(cwd, pm, packages, dev = false) {
+    if (packages.length === 0)
+        return;
+    const spinner = logger_1.logger.startSpinner(`Adding ${dev ? "dev " : ""}dependencies: ${packages.join(", ")}...`);
+    try {
+        const args = [];
+        if (pm === "npm") {
+            args.push("install", dev ? "--save-dev" : "--save", ...packages);
+        }
+        else if (pm === "yarn") {
+            args.push("add", dev ? "--dev" : "", ...packages);
+        }
+        else if (pm === "pnpm") {
+            args.push("add", dev ? "-D" : "", ...packages);
+        }
+        else if (pm === "bun") {
+            // bun uses `bun add` and `-d` for dev dependencies
+            args.push("add", ...(dev ? ["-d"] : []), ...packages);
+        }
+        await (0, execa_1.default)(pm, args.filter(Boolean), { cwd, stdio: "pipe" });
+        spinner.succeed(`Dependencies added successfully`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to add dependencies`);
+        throw new Error(`Failed to add dependencies: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function initGit(cwd) {
+    await (0, execa_1.default)("git", ["init"], { cwd });
+    await (0, execa_1.default)("git", ["add", "."], { cwd });
+    await (0, execa_1.default)("git", ["commit", "-m", "Initial commit from StackKit"], { cwd });
+}

package/dist/lib/project/detect.d.ts

@@ -0,0 +1,4 @@
+import { ProjectInfo } from "../../types";
+export declare function detectProjectInfo(targetDir: string): Promise<ProjectInfo>;
+export declare function getRouterBasePath(projectInfo: ProjectInfo): string;
+export declare function getLibPath(projectInfo: ProjectInfo): string;

package/dist/lib/project/detect.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProjectInfo = detectProjectInfo;
+exports.getRouterBasePath = getRouterBasePath;
+exports.getLibPath = getLibPath;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+async function detectProjectInfo(targetDir) {
+    const packageJsonPath = path_1.default.join(targetDir, "package.json");
+    if (!(await fs_extra_1.default.pathExists(packageJsonPath))) {
+        throw new Error("No package.json found. This does not appear to be a Node.js project.");
+    }
+    const packageJson = await fs_extra_1.default.readJSON(packageJsonPath);
+    // Detect framework
+    const isNextJs = packageJson.dependencies?.next || packageJson.devDependencies?.next;
+    const isExpress = packageJson.dependencies?.express || packageJson.devDependencies?.express;
+    const isReact = packageJson.dependencies?.react || packageJson.devDependencies?.react;
+    const isVite = packageJson.dependencies?.vite || packageJson.devDependencies?.vite;
+    let framework;
+    if (isNextJs) {
+        framework = "nextjs";
+    }
+    else if (isExpress) {
+        framework = "express";
+    }
+    else if (isReact && isVite) {
+        framework = "react";
+    }
+    else if (isReact) {
+        framework = "react";
+    }
+    else {
+        framework = "unknown";
+    }
+    if (framework === "unknown") {
+        throw new Error("Only Next.js, Express, and React projects are currently supported.");
+    }
+    // Detect router type (only for Next.js)
+    let router = "unknown";
+    if (framework === "nextjs") {
+        const appDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "app"));
+        const pagesDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "pages"));
+        const srcAppDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "src", "app"));
+        const srcPagesDirExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "src", "pages"));
+        if (appDirExists || srcAppDirExists) {
+            router = "app";
+        }
+        else if (pagesDirExists || srcPagesDirExists) {
+            router = "pages";
+        }
+    }
+    // Detect TypeScript vs JavaScript
+    const tsconfigExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "tsconfig.json"));
+    const jsconfigExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "jsconfig.json"));
+    let language;
+    if (tsconfigExists) {
+        language = "ts";
+    }
+    else if (jsconfigExists) {
+        language = "js";
+    }
+    else {
+        // Default to TypeScript if neither exists
+        language = "ts";
+    }
+    // Detect package manager
+    const yarnLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "yarn.lock"));
+    const pnpmLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "pnpm-lock.yaml"));
+    const bunLockExists = await fs_extra_1.default.pathExists(path_1.default.join(targetDir, "bun.lockb"));
+    let packageManager = "npm";
+    if (pnpmLockExists) {
+        packageManager = "pnpm";
+    }
+    else if (yarnLockExists) {
+        packageManager = "yarn";
+    }
+    else if (bunLockExists) {
+        packageManager = "bun";
+    }
+    // Check for existing integrations
+    const hasAuth = !!(packageJson.dependencies?.["next-auth"] ||
+        packageJson.dependencies?.["better-auth"] ||
+        packageJson.dependencies?.["@auth/core"] ||
+        packageJson.dependencies?.["@kinde-oss/kinde-auth-nextjs"] ||
+        packageJson.dependencies?.["passport"]);
+    const hasPrisma = !!(packageJson.dependencies?.["@prisma/client"] || packageJson.devDependencies?.["prisma"]);
+    const hasDatabase = hasPrisma ||
+        !!(packageJson.dependencies?.["mongoose"] ||
+            packageJson.dependencies?.["typeorm"] ||
+            packageJson.dependencies?.["drizzle-orm"]);
+    return {
+        framework,
+        router,
+        language,
+        packageManager,
+        hasAuth,
+        hasPrisma,
+        hasDatabase,
+        rootDir: targetDir,
+    };
+}
+function getRouterBasePath(projectInfo) {
+    const srcExists = fs_extra_1.default.existsSync(path_1.default.join(projectInfo.rootDir, "src"));
+    if (projectInfo.router === "app") {
+        return srcExists ? "src/app" : "app";
+    }
+    else if (projectInfo.router === "pages") {
+        return srcExists ? "src/pages" : "pages";
+    }
+    throw new Error("Unknown router type");
+}
+function getLibPath(projectInfo) {
+    if (projectInfo.framework === "express") {
+        return "src/lib";
+    }
+    const srcExists = fs_extra_1.default.existsSync(path_1.default.join(projectInfo.rootDir, "src"));
+    return srcExists ? "src/lib" : "lib";
+}

package/dist/lib/ui/logger.d.ts

@@ -0,0 +1,16 @@
+import { Ora } from "ora";
+export declare class Logger {
+    private spinner;
+    info(message: string): void;
+    success(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    log(message: string): void;
+    newLine(): void;
+    startSpinner(text: string): Ora;
+    stopSpinner(success?: boolean, text?: string): void;
+    updateSpinner(text: string): void;
+    header(text: string): void;
+    footer(): void;
+}
+export declare const logger: Logger;

package/dist/lib/ui/logger.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+class Logger {
+    constructor() {
+        this.spinner = null;
+    }
+    info(message) {
+        process.stdout.write(chalk_1.default.blue("ℹ") + " " + message + "\n");
+    }
+    success(message) {
+        process.stdout.write(chalk_1.default.green("✔") + " " + message + "\n");
+    }
+    error(message) {
+        process.stderr.write(chalk_1.default.red("✖") + " " + message + "\n");
+    }
+    warn(message) {
+        process.stdout.write(chalk_1.default.yellow("⚠") + " " + message + "\n");
+    }
+    log(message) {
+        process.stdout.write(message + "\n");
+    }
+    newLine() {
+        process.stdout.write("\n");
+    }
+    startSpinner(text) {
+        this.spinner = (0, ora_1.default)(text).start();
+        return this.spinner;
+    }
+    stopSpinner(success = true, text) {
+        if (this.spinner) {
+            if (success) {
+                this.spinner.succeed(text);
+            }
+            else {
+                this.spinner.fail(text);
+            }
+            this.spinner = null;
+        }
+    }
+    updateSpinner(text) {
+        if (this.spinner) {
+            this.spinner.text = text;
+        }
+    }
+    header(text) {
+        process.stdout.write(chalk_1.default.bold.cyan(text) + "\n");
+    }
+    footer() {
+        process.stdout.write("\n");
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger();

package/dist/types/index.d.ts

@@ -0,0 +1,92 @@
+export interface TemplateMetadata {
+    name: string;
+    displayName: string;
+    description: string;
+    tags: string[];
+    defaultPackageManager: "pnpm" | "npm" | "yarn" | "bun";
+    features: string[];
+}
+export interface ModuleMetadata {
+    name: string;
+    displayName: string;
+    description: string;
+    category: "auth" | "database" | "ui" | "other";
+    supportedFrameworks: string[];
+    dependencies: {
+        common?: Record<string, string>;
+        providers?: Record<string, Record<string, string>>;
+    } | Record<string, string>;
+    devDependencies?: {
+        common?: Record<string, string>;
+        providers?: Record<string, Record<string, string>>;
+    } | Record<string, string>;
+    envVars: EnvVar[];
+    patches: ModulePatch[];
+    frameworkPatches?: Record<string, {
+        [file: string]: {
+            merge?: Record<string, unknown>;
+        };
+    }>;
+    postInstall?: string[];
+    databaseAdapters?: {
+        common?: {
+            dependencies?: Record<string, string>;
+            devDependencies?: Record<string, string>;
+        };
+        providers?: Record<string, Record<string, {
+            dependencies?: Record<string, string>;
+            devDependencies?: Record<string, string>;
+        }>>;
+    };
+    frameworkConfigs?: Record<string, {
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+        patches?: ModulePatch[];
+    }>;
+}
+export interface EnvVar {
+    key: string;
+    value?: string;
+    description: string;
+    required: boolean;
+}
+export interface ModulePatch {
+    type: "create-file" | "modify-json" | "append-env" | "inject-code";
+    description: string;
+    [key: string]: unknown;
+}
+export interface CreateFilePatch extends ModulePatch {
+    type: "create-file";
+    source: string;
+    destination: string;
+    condition?: {
+        router?: "app" | "pages";
+        language?: "ts" | "js";
+    };
+}
+export interface ModifyJsonPatch extends ModulePatch {
+    type: "modify-json";
+    file: string;
+    operations: {
+        path: string;
+        value: unknown;
+        merge?: boolean;
+    }[];
+}
+export interface ProjectInfo {
+    framework: "nextjs" | "express" | "react" | "unknown";
+    router: "app" | "pages" | "unknown";
+    language: "ts" | "js";
+    packageManager: "npm" | "yarn" | "pnpm" | "bun";
+    hasAuth: boolean;
+    hasPrisma: boolean;
+    hasDatabase: boolean;
+    rootDir: string;
+}
+export interface CLIOptions {
+    force?: boolean;
+    dryRun?: boolean;
+    yes?: boolean;
+    noInstall?: boolean;
+    pm?: "npm" | "yarn" | "pnpm" | "bun";
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/modules/auth/authjs/files/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,6 @@
+import NextAuth from "next-auth";
+import { authOptions } from "@/lib/auth";
+
+const handler = NextAuth(authOptions);
+
+export { handler as GET, handler as POST };

package/modules/auth/authjs/files/lib/auth-client.ts

@@ -0,0 +1,11 @@
+import { getServerSession } from "next-auth/next";
+import { authOptions } from "@/lib/auth";
+
+export async function getSession() {
+  return await getServerSession(authOptions);
+}
+
+export async function getCurrentUser() {
+  const session = await getSession();
+  return session?.user;
+}

package/modules/auth/authjs/files/lib/auth.ts

@@ -0,0 +1,36 @@
+import { NextAuthOptions } from "next-auth";
+import { PrismaAdapter } from "@auth/prisma-adapter";
+import { prisma } from "@/lib/prisma";
+import GoogleProvider from "next-auth/providers/google";
+
+export const authOptions: NextAuthOptions = {
+  adapter: PrismaAdapter(prisma),
+  providers: [
+    GoogleProvider({
+      clientId: process.env.GOOGLE_CLIENT_ID!,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+    }),
+  ],
+  session: {
+    strategy: "jwt",
+  },
+  callbacks: {
+    async jwt({ token, user }) {
+      if (user) {
+        token.id = user.id;
+      }
+      return token;
+    },
+    async session({ session, token }) {
+      if (token) {
+        session.user.id = token.id as string;
+      }
+      return session;
+    },
+  },
+  pages: {
+    signIn: "/auth/signin",
+    signOut: "/auth/signout",
+    error: "/auth/error",
+  },
+};

package/modules/auth/authjs/files/schemas/prisma-schema.prisma

@@ -0,0 +1,45 @@
+
+model Account {
+  id                String  @id {{idDefault}}
+  userId            String {{userIdType}}
+  type              String
+  provider          String
+  providerAccountId String
+  refresh_token     String? @db.Text
+  access_token      String? @db.Text
+  expires_at        Int?
+  token_type        String?
+  scope             String?
+  id_token          String? @db.Text
+  session_state     String?
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@unique([provider, providerAccountId])
+}
+
+model Session {
+  id           String   @id {{idDefault}}
+  sessionToken String   @unique
+  userId       String {{userIdType}}
+  expires      DateTime
+  user         User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+}
+
+model User {
+  id            String    @id {{idDefault}}
+  name          String?
+  email         String    @unique
+  emailVerified DateTime?
+  image         String?
+  accounts      Account[]
+  sessions      Session[]
+}
+
+model VerificationToken {
+  identifier String
+  token      String   @unique
+  expires    DateTime
+
+  @@unique([identifier, token])
+}

package/modules/auth/authjs/module.json

@@ -0,0 +1,22 @@
+{
+  "name": "authjs",
+  "displayName": "Auth.js",
+  "description": "Authentication with Auth.js (NextAuth.js v5)",
+  "category": "auth",
+  "provider": "authjs",
+  "supportedFrameworks": ["nextjs"],
+  "compatibility": {
+    "frameworks": ["nextjs"],
+    "databases": ["prisma"],
+    "languages": ["typescript", "javascript"],
+    "packageManagers": ["npm", "yarn", "pnpm", "bun"]
+  },
+  "databaseAdapters": {
+    "common": {
+      "dependencies": {
+        "@auth/prisma-adapter": "^2.7.1"
+      },
+      "devDependencies": {}
+    }
+  }
+}

package/modules/auth/better-auth/files/api/auth/[...all]/route.ts

@@ -0,0 +1,4 @@
+import { auth } from "@/lib/auth";
+import { toNextJsHandler } from "better-auth/next-js";
+
+export const { GET, POST } = toNextJsHandler(auth);

package/modules/auth/better-auth/files/lib/auth-client.ts

@@ -0,0 +1,7 @@
+import { createAuthClient } from "better-auth/react";
+
+export const authClient = createAuthClient({
+  baseURL: "http://localhost:3000",
+});
+
+export const { signIn, signUp, signOut, useSession } = authClient;

package/modules/auth/better-auth/files/lib/auth.ts

@@ -0,0 +1,83 @@
+import { betterAuth } from "better-auth";
+import { sendEmail } from "./email/email-service";
+import { getVerificationEmailTemplate, getPasswordResetEmailTemplate } from "./email/email-templates";
+{{#if database=='prisma'}}
+import { prisma } from "{{framework=='nextjs' ? '@/lib' : '.'}}/prisma";
+import { prismaAdapter } from "better-auth/adapters/prisma";
+{{/if}}
+{{#if database=='mongoose'}}
+import { mongoClient, db } from "{{framework=='nextjs' ? '@/lib' : '.'}}/db";
+import { mongodbAdapter } from "better-auth/adapters/mongodb";
+{{/if}}
+
+export const auth = betterAuth({
+{{#if database=='prisma'}}
+  database: prismaAdapter(prisma, {
+      provider: {{prismaProvider}},
+  }),
+{{/if}}
+{{#if database=='mongoose'}}
+  database: mongodbAdapter(db),
+{{/if}}
+  user: {
+    additionalFields: {
+      role: {
+        type: "string",
+        defaultValue: "USER",
+        required: true,
+      },
+    },
+  },
+  emailAndPassword: {
+    enabled: true,
+    requireEmailVerification: true,
+  },
+  socialProviders: {
+    google: {
+      clientId: process.env.GOOGLE_CLIENT_ID!,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+    },
+  },
+  emailVerification: {
+    sendVerificationEmail: async ({ user, url }) => {
+      const { html, text } = getVerificationEmailTemplate(user, url);
+      await sendEmail({
+        to: user.email,
+        subject: "Verify Your Email Address",
+        text,
+        html,
+      });
+    },
+    sendOnSignIn: true,
+  },
+  password: {
+    reset: {
+      sendResetEmail: async ({ user, url }) => {
+        const { html, text } = getPasswordResetEmailTemplate(user, url);
+        await sendEmail({
+          to: user.email,
+          subject: "Reset Your Password",
+          text,
+          html,
+        });
+      },
+    },
+  },
+  rateLimit: {
+    window: 10, // 10 seconds
+    max: 100, // max requests per window
+  },
+  account: {
+    accountLinking: {
+      enabled: true,
+      trustedProviders: ["google"],
+    },
+  },
+  session: {
+    cookieCache: {
+      enabled: true,
+    },
+    expiresIn: 60 * 60 * 24 * 7, // 7 days
+    updateAge: 60 * 60 * 24, // 1 day
+  }
+});

package/modules/auth/better-auth/files/lib/email-service.ts

@@ -0,0 +1,34 @@
+import nodemailer from "nodemailer";
+
+// Create email transporter
+const transporter = nodemailer.createTransporter({
+  host: process.env.EMAIL_HOST,
+  port: parseInt(process.env.EMAIL_PORT || "587"),
+  secure: process.env.EMAIL_PORT === "465",
+  auth: {
+    user: process.env.EMAIL_USER,
+    pass: process.env.EMAIL_PASS,
+  },
+});
+
+// Send email function
+export const sendEmail = async ({ to, subject, text, html }: {
+  to: string;
+  subject: string;
+  text?: string;
+  html?: string;
+}) => {
+  try {
+    await transporter.sendMail({
+      from: process.env.EMAIL_FROM,
+      to,
+      subject,
+      text,
+      html,
+    });
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error("Email sending failed:", error);
+    throw error;
+  }
+};