create-jjlabs-app 0.1.0

package/dist/index.js

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createRequire } from "module";
+
+// src/prompts.ts
+import prompts from "prompts";
+
+// src/utils/validate.ts
+import fs from "fs-extra";
+import path from "path";
+var VALID_NAME_REGEX = /^[a-z0-9]([a-z0-9._-]*[a-z0-9])?$/;
+function validateProjectName(name) {
+  if (!name || name.trim().length === 0) {
+    return { valid: false, message: "Project name is required." };
+  }
+  if (!VALID_NAME_REGEX.test(name)) {
+    return {
+      valid: false,
+      message: "Project name must start and end with a lowercase letter or number, and can only contain lowercase letters, numbers, hyphens, dots, and underscores."
+    };
+  }
+  return { valid: true };
+}
+async function checkDirectoryAvailable(targetDir) {
+  const resolved = path.resolve(targetDir);
+  if (await fs.pathExists(resolved)) {
+    return {
+      available: false,
+      message: `Directory "${resolved}" already exists.`
+    };
+  }
+  return { available: true };
+}
+
+// src/prompts.ts
+async function getUserChoices(argProjectName) {
+  const onCancel = () => {
+    process.exit(0);
+  };
+  const response = await prompts(
+    [
+      {
+        type: argProjectName ? null : "text",
+        name: "projectName",
+        message: "Project name:",
+        initial: "my-app",
+        validate: (value) => {
+          const result = validateProjectName(value);
+          return result.valid ? true : result.message ?? "Invalid name";
+        }
+      },
+      {
+        type: "select",
+        name: "layout",
+        message: "Choose a layout:",
+        choices: [
+          {
+            title: "Sidebar",
+            value: "sidebar",
+            description: "Dashboard-style sidebar navigation"
+          },
+          {
+            title: "Standard",
+            value: "standard",
+            description: "Header + footer layout"
+          }
+        ]
+      }
+    ],
+    { onCancel }
+  );
+  const projectName = argProjectName ?? response.projectName;
+  if (!projectName || !response.layout) {
+    return null;
+  }
+  return {
+    projectName,
+    layout: response.layout
+  };
+}
+
+// src/scaffold.ts
+import path7 from "path";
+
+// src/steps/clone.ts
+import { execFileSync } from "child_process";
+
+// src/config/constants.ts
+var TEMPLATE_REPO = "jjlabsio/starter";
+var APP_DIR = "apps/app";
+var SRC_DIR = `${APP_DIR}/src`;
+var COMPONENTS_DIR = `${SRC_DIR}/components`;
+var AUTHENTICATED_DIR = `${SRC_DIR}/app/(authenticated)`;
+var SIDEBAR_GROUP_DIR = `${AUTHENTICATED_DIR}/(sidebar)`;
+var STANDARD_GROUP_DIR = `${AUTHENTICATED_DIR}/(standard)`;
+var ROOT_PAGE = `${SRC_DIR}/app/page.tsx`;
+var SIGN_IN_PAGE = `${SRC_DIR}/app/(public)/sign-in/page.tsx`;
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var logger = {
+  info(message) {
+    console.log(pc.cyan(message));
+  },
+  success(message) {
+    console.log(pc.green(message));
+  },
+  warn(message) {
+    console.log(pc.yellow(message));
+  },
+  error(message) {
+    console.error(pc.red(message));
+  },
+  step(message) {
+    console.log(pc.bold(pc.blue(`> ${message}`)));
+  }
+};
+
+// src/steps/clone.ts
+async function cloneTemplate(targetDir) {
+  logger.step("Cloning template...");
+  try {
+    await cloneWithDegit(targetDir);
+  } catch {
+    logger.warn("degit failed, falling back to git clone...");
+    cloneWithGit(targetDir);
+  }
+}
+async function cloneWithDegit(targetDir) {
+  const degit = (await import("degit")).default;
+  const emitter = degit(TEMPLATE_REPO, { cache: false, force: true });
+  await emitter.clone(targetDir);
+}
+function cloneWithGit(targetDir) {
+  execFileSync(
+    "git",
+    ["clone", "--depth", "1", `https://github.com/${TEMPLATE_REPO}.git`, targetDir],
+    { stdio: "pipe" }
+  );
+}
+
+// src/steps/clean-layout.ts
+import path2 from "path";
+
+// src/config/layout-files.ts
+var SIDEBAR_FILES = {
+  routeGroupDir: SIDEBAR_GROUP_DIR,
+  components: [
+    `${COMPONENTS_DIR}/app-sidebar.tsx`,
+    `${COMPONENTS_DIR}/nav-main.tsx`,
+    `${COMPONENTS_DIR}/nav-secondary.tsx`,
+    `${COMPONENTS_DIR}/nav-user.tsx`,
+    `${COMPONENTS_DIR}/nav-documents.tsx`,
+    `${COMPONENTS_DIR}/site-header.tsx`,
+    `${COMPONENTS_DIR}/page-container.tsx`,
+    `${COMPONENTS_DIR}/section-cards.tsx`,
+    `${COMPONENTS_DIR}/chart-area-interactive.tsx`
+  ]
+};
+var STANDARD_FILES = {
+  routeGroupDir: STANDARD_GROUP_DIR,
+  components: [
+    `${COMPONENTS_DIR}/app-header.tsx`,
+    `${COMPONENTS_DIR}/app-footer.tsx`,
+    `${COMPONENTS_DIR}/mobile-nav.tsx`,
+    `${COMPONENTS_DIR}/user-menu.tsx`
+  ]
+};
+var FILE_MAP = {
+  sidebar: STANDARD_FILES,
+  standard: SIDEBAR_FILES
+};
+function getFilesToRemove(layout) {
+  return FILE_MAP[layout];
+}
+function getSelectedLayoutDir(layout) {
+  return layout === "sidebar" ? SIDEBAR_GROUP_DIR : STANDARD_GROUP_DIR;
+}
+
+// src/utils/fs.ts
+import fs2 from "fs-extra";
+async function removeDir(dirPath) {
+  if (await fs2.pathExists(dirPath)) {
+    await fs2.remove(dirPath);
+  }
+}
+async function removeFile(filePath) {
+  if (await fs2.pathExists(filePath)) {
+    await fs2.remove(filePath);
+  }
+}
+async function readFile(filePath) {
+  return fs2.readFile(filePath, "utf-8");
+}
+async function writeFile(filePath, content) {
+  await fs2.writeFile(filePath, content, "utf-8");
+}
+
+// src/steps/clean-layout.ts
+async function cleanLayout(projectDir, layout) {
+  const filesToRemove = getFilesToRemove(layout);
+  logger.step(`Removing unused ${layout === "sidebar" ? "standard" : "sidebar"} layout files...`);
+  await removeDir(path2.join(projectDir, filesToRemove.routeGroupDir));
+  await Promise.all(
+    filesToRemove.components.map(
+      (component) => removeFile(path2.join(projectDir, component))
+    )
+  );
+}
+
+// src/steps/clean-auth-duplication.ts
+import path3 from "path";
+async function cleanAuthDuplication(projectDir, layout) {
+  const layoutDir = getSelectedLayoutDir(layout);
+  const layoutFile = path3.join(projectDir, layoutDir, "layout.tsx");
+  logger.step("Removing duplicate auth check from selected layout...");
+  const content = await readFile(layoutFile);
+  const transformed = transformLayout(content);
+  await writeFile(layoutFile, transformed);
+}
+function transformLayout(content) {
+  let result = content;
+  result = result.replace(
+    /\s*if\s*\(!session\)\s*\{[\s\S]*?redirect\([^)]*\);\s*\}\s*/,
+    "\n\n"
+  );
+  result = result.replace(
+    /import\s*\{([^}]*)\}\s*from\s*["']next\/navigation["'];\s*\n/,
+    (_match, imports) => {
+      const remaining = imports.split(",").map((s) => s.trim()).filter((s) => s !== "" && s !== "redirect");
+      if (remaining.length === 0) return "";
+      return `import { ${remaining.join(", ")} } from "next/navigation";
+`;
+    }
+  );
+  result = result.replace(/\bsession\.user\b/g, "session!.user");
+  result = result.replace(
+    /(const session = await auth\.api\.getSession\(\{[\s\S]*?\}\);)\n/,
+    "$1\n  // session is already verified by (authenticated)/layout.tsx\n"
+  );
+  return result;
+}
+
+// src/steps/update-redirects.ts
+import path4 from "path";
+var REDIRECT_MAP = {
+  sidebar: "/dashboard",
+  standard: "/home"
+};
+async function updateRedirects(projectDir, layout) {
+  const targetPath = REDIRECT_MAP[layout];
+  if (layout === "sidebar") {
+    logger.step("Redirect paths already correct for sidebar layout.");
+    return;
+  }
+  logger.step(`Updating redirect paths to "${targetPath}"...`);
+  await Promise.all([
+    updateRootPage(projectDir, targetPath),
+    updateSignInPage(projectDir, targetPath)
+  ]);
+}
+async function updateRootPage(projectDir, targetPath) {
+  const filePath = path4.join(projectDir, ROOT_PAGE);
+  const content = await readFile(filePath);
+  const updated = content.replace(
+    /redirect\(["']\/dashboard["']\)/,
+    `redirect("${targetPath}")`
+  );
+  await writeFile(filePath, updated);
+}
+async function updateSignInPage(projectDir, targetPath) {
+  const filePath = path4.join(projectDir, SIGN_IN_PAGE);
+  const content = await readFile(filePath);
+  const updated = content.replace(
+    /callbackURL:\s*["']\/dashboard["']/,
+    `callbackURL: "${targetPath}"`
+  );
+  await writeFile(filePath, updated);
+}
+
+// src/steps/update-package-names.ts
+import path5 from "path";
+import fs3 from "fs-extra";
+var PACKAGE_JSON_PATHS = [
+  "package.json",
+  "apps/app/package.json"
+];
+async function updatePackageNames(projectDir, projectName) {
+  logger.step("Updating package names...");
+  await Promise.all(
+    PACKAGE_JSON_PATHS.map(async (relativePath) => {
+      const filePath = path5.join(projectDir, relativePath);
+      if (!await fs3.pathExists(filePath)) {
+        return;
+      }
+      const content = await fs3.readJson(filePath);
+      const updatedName = relativePath === "package.json" ? projectName : `@${projectName}/app`;
+      const { name: _, ...rest } = content;
+      await fs3.writeJson(
+        filePath,
+        { name: updatedName, ...rest },
+        { spaces: 2 }
+      );
+    })
+  );
+}
+
+// src/steps/finalize.ts
+import path6 from "path";
+import { execSync } from "child_process";
+import fs4 from "fs-extra";
+async function finalize(projectDir) {
+  await removeGitDir(projectDir);
+  await copyEnvFile(projectDir);
+  await installDependencies(projectDir);
+}
+async function removeGitDir(projectDir) {
+  const gitDir = path6.join(projectDir, ".git");
+  if (await fs4.pathExists(gitDir)) {
+    logger.step("Removing .git directory...");
+    await fs4.remove(gitDir);
+  }
+}
+async function copyEnvFile(projectDir) {
+  const envExample = path6.join(projectDir, ".env.example");
+  const envLocal = path6.join(projectDir, ".env");
+  if (await fs4.pathExists(envExample)) {
+    logger.step("Creating .env from .env.example...");
+    await fs4.copy(envExample, envLocal);
+  }
+}
+async function installDependencies(projectDir) {
+  logger.step("Installing dependencies...");
+  try {
+    execSync("pnpm install", {
+      cwd: projectDir,
+      stdio: "inherit"
+    });
+  } catch {
+    logger.warn(
+      "Failed to install dependencies. Run 'pnpm install' manually."
+    );
+  }
+}
+
+// src/scaffold.ts
+async function scaffold(options) {
+  const { projectName, layout } = options;
+  const projectDir = path7.resolve(projectName);
+  logger.info(`
+Creating ${projectName} with ${layout} layout...
+`);
+  await cloneTemplate(projectDir);
+  await cleanLayout(projectDir, layout);
+  await cleanAuthDuplication(projectDir, layout);
+  await updateRedirects(projectDir, layout);
+  await updatePackageNames(projectDir, projectName);
+  await finalize(projectDir);
+  logger.success(`
+Project "${projectName}" created successfully!
+`);
+  logger.info("Next steps:");
+  logger.info(`  cd ${projectName}`);
+  logger.info("  # Update .env with your credentials");
+  logger.info("  pnpm dev\n");
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version: VERSION } = require2("../package.json");
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(VERSION);
+    return;
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    return;
+  }
+  const argProjectName = args.find((arg) => !arg.startsWith("-"));
+  if (argProjectName) {
+    const validation = validateProjectName(argProjectName);
+    if (!validation.valid) {
+      logger.error(validation.message);
+      process.exit(1);
+    }
+    const dirCheck = await checkDirectoryAvailable(argProjectName);
+    if (!dirCheck.available) {
+      logger.error(dirCheck.message);
+      process.exit(1);
+    }
+  }
+  const choices = await getUserChoices(argProjectName);
+  if (!choices) {
+    logger.error("Setup cancelled.");
+    process.exit(1);
+  }
+  if (!argProjectName) {
+    const dirCheck = await checkDirectoryAvailable(choices.projectName);
+    if (!dirCheck.available) {
+      logger.error(dirCheck.message);
+      process.exit(1);
+    }
+  }
+  await scaffold(choices);
+}
+function printHelp() {
+  console.log(`
+  create-jjlabs-app [project-name]
+
+  Scaffold a new JJLabs app from the starter template.
+
+  Options:
+    -h, --help      Show this help message
+    -v, --version   Show version number
+
+  Examples:
+    npx create-jjlabs-app my-app
+    npx create-jjlabs-app
+  `);
+}
+main().catch((error) => {
+  logger.error(error.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "create-jjlabs-app",
+  "version": "0.1.0",
+  "description": "CLI to scaffold a new JJLabs app from the starter template",
+  "type": "module",
+  "bin": {
+    "create-jjlabs-app": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "degit": "^2.8.4",
+    "fs-extra": "^11.2.0",
+    "picocolors": "^1.1.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/prompts": "^2.4.9",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}