okj

Author: AmanVarshney01

apps/cli/src/helpers/addons/addons-setup.ts

@@ -53,7 +53,7 @@ ${pc.cyan("Docs:")} ${pc.underline("https://turborepo.com/docs")}
   }
 
   if (hasOxlint) {
-    await setupOxlint(projectDir, packageManager);
+    await setupOxlint(config);
   }
 
   if (addons.includes("starlight")) {

apps/cli/src/helpers/addons/examples-setup.ts

@@ -7,22 +7,22 @@
 import { spinner } from "@clack/prompts";
 import { $ } from "execa";
 
-import type { PackageManager } from "../../types";
+import type { ProjectConfig } from "../../types";
 
 import { getPackageExecutionArgs } from "../../utils/package-runner";
 
-export async function setupOxlint(projectDir: string, packageManager: PackageManager) {
+export async function setupOxlint(config: ProjectConfig) {
   // Dependencies (oxlint, oxfmt) and scripts are added by template-generator
   // This only runs the init CLIs
 
   const s = spinner();
   s.start("Initializing oxlint and oxfmt...");
 
-  const oxlintArgs = getPackageExecutionArgs(packageManager, "oxlint@latest --init");
-  await $({ cwd: projectDir, env: { CI: "true" } })`${oxlintArgs}`;
+  const oxlintArgs = getPackageExecutionArgs(config.packageManager, "oxlint@latest --init");
+  await $({ cwd: config.projectDir, env: { CI: "true" } })`${oxlintArgs}`;
 
-  const oxfmtArgs = getPackageExecutionArgs(packageManager, "oxfmt@latest --init");
-  await $({ cwd: projectDir, env: { CI: "true" } })`${oxfmtArgs}`;
+  const oxfmtArgs = getPackageExecutionArgs(config.packageManager, "oxfmt@latest --init");
+  await $({ cwd: config.projectDir, env: { CI: "true" } })`${oxfmtArgs}`;
 
   s.stop("oxlint and oxfmt initialized successfully!");
 }

apps/cli/src/helpers/addons/oxlint-setup.ts

@@ -11,10 +11,9 @@ import { setupBetterAuthPlugins } from "../../utils/better-auth-plugin-setup";
 import { writeBtsConfig } from "../../utils/bts-config";
 import { isSilent } from "../../utils/context";
 import { exitWithError } from "../../utils/errors";
-import { formatProjectFiles } from "../../utils/file-formatter";
+import { formatProject } from "../../utils/file-formatter";
 import { setupCatalogs } from "../../utils/setup-catalogs";
 import { setupAddons } from "../addons/addons-setup";
-import { setupExamples } from "../addons/examples-setup";
 import { setupDatabase } from "../core/db-setup";
 import { setupServerDeploy } from "../deployment/server-deploy-setup";
 import { setupWebDeploy } from "../deployment/web-deploy-setup";
@@ -44,17 +43,12 @@ export async function createProject(options: ProjectConfig, cliInput: CreateProj
     }
 
     await writeTreeToFilesystem(result.tree, projectDir);
-    await formatProjectFiles(projectDir);
     await setPackageManagerVersion(projectDir, options.packageManager);
 
     if (!isConvex && options.database !== "none") {
       await setupDatabase(options, cliInput);
     }
 
-    if (options.examples.length > 0 && options.examples[0] !== "none") {
-      await setupExamples(options);
-    }
-
     if (options.addons.length > 0 && options.addons[0] !== "none") {
       await setupAddons(options);
     }
@@ -69,9 +63,14 @@ export async function createProject(options: ProjectConfig, cliInput: CreateProj
     await setupEnvironmentVariables(options);
     await setupWebDeploy(options);
     await setupServerDeploy(options);
+
+    // Process catalogs after addons (which may create new apps/packages)
     await setupCatalogs(options.projectDir, options);
+
     await writeBtsConfig(options);
 
+    await formatProject(projectDir);
+
     if (!isSilent()) log.success("Project template successfully scaffolded!");
 
     if (options.install) {

apps/cli/src/helpers/core/create-project.ts

@@ -1,7 +1,6 @@
 import fs from "fs-extra";
 import path from "node:path";
 import { format, type FormatOptions } from "oxfmt";
-import { glob } from "tinyglobby";
 
 const formatOptions: FormatOptions = {
   experimentalSortPackageJson: true,
@@ -10,7 +9,7 @@ const formatOptions: FormatOptions = {
   },
 };
 
-export async function formatFile(filePath: string, content: string): Promise<string | null> {
+export async function formatCode(filePath: string, content: string): Promise<string | null> {
   try {
     const result = await format(path.basename(filePath), content, formatOptions);
 
@@ -24,27 +23,28 @@ export async function formatFile(filePath: string, content: string): Promise<str
   }
 }
 
-/**
- * Format all files in a project directory using oxfmt
- */
-export async function formatProjectFiles(projectDir: string): Promise<void> {
-  const files = await glob(["**/*.{ts,tsx,js,jsx,json,mjs,cjs}"], {
-    cwd: projectDir,
-    absolute: true,
-    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
-  });
-
-  await Promise.all(
-    files.map(async (filePath) => {
-      try {
-        const content = await fs.readFile(filePath, "utf-8");
-        const formatted = await formatFile(filePath, content);
-        if (formatted && formatted !== content) {
-          await fs.writeFile(filePath, formatted, "utf-8");
+export async function formatProject(projectDir: string) {
+  async function formatDirectory(dir: string) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    await Promise.all(
+      entries.map(async (entry) => {
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+          await formatDirectory(fullPath);
+        } else if (entry.isFile()) {
+          try {
+            const content = await fs.readFile(fullPath, "utf-8");
+            const formatted = await formatCode(fullPath, content);
+            if (formatted && formatted !== content) {
+              await fs.writeFile(fullPath, formatted, "utf-8");
+            }
+          } catch {}
         }
-      } catch {
-        // Silently skip files that can't be formatted
-      }
-    }),
-  );
+      }),
+    );
+  }
+
+  await formatDirectory(projectDir);
 }

apps/cli/src/utils/file-formatter.ts

@@ -20,35 +20,52 @@ export async function setupCatalogs(projectDir: string, options: ProjectConfig)
     return;
   }
 
-  const packagePaths = [
-    ".", // root monorepo
-    "apps/server",
-    "apps/web",
-    "apps/native",
-    "apps/fumadocs",
-    "apps/docs",
-    "packages/api",
-    "packages/db",
-    "packages/auth",
-    "packages/backend",
-    "packages/config",
-    "packages/env",
-    "packages/infra",
-  ];
-
   const packagesInfo: PackageInfo[] = [];
 
-  for (const pkgPath of packagePaths) {
-    const fullPath = path.join(projectDir, pkgPath);
-    const pkgJsonPath = path.join(fullPath, "package.json");
-
-    if (await fs.pathExists(pkgJsonPath)) {
-      const pkgJson = await fs.readJson(pkgJsonPath);
-      packagesInfo.push({
-        path: fullPath,
-        dependencies: pkgJson.dependencies || {},
-        devDependencies: pkgJson.devDependencies || {},
-      });
+  // Add root package.json
+  const rootPkgJsonPath = path.join(projectDir, "package.json");
+  if (await fs.pathExists(rootPkgJsonPath)) {
+    const pkgJson = await fs.readJson(rootPkgJsonPath);
+    packagesInfo.push({
+      path: projectDir,
+      dependencies: pkgJson.dependencies || {},
+      devDependencies: pkgJson.devDependencies || {},
+    });
+  }
+
+  // Dynamically discover packages in apps/ and packages/
+  const appsDir = path.join(projectDir, "apps");
+  const packagesDir = path.join(projectDir, "packages");
+
+  if (await fs.pathExists(appsDir)) {
+    const appDirs = await fs.readdir(appsDir);
+    for (const appDir of appDirs) {
+      const appPath = path.join(appsDir, appDir);
+      const pkgJsonPath = path.join(appPath, "package.json");
+      if (await fs.pathExists(pkgJsonPath)) {
+        const pkgJson = await fs.readJson(pkgJsonPath);
+        packagesInfo.push({
+          path: appPath,
+          dependencies: pkgJson.dependencies || {},
+          devDependencies: pkgJson.devDependencies || {},
+        });
+      }
+    }
+  }
+
+  if (await fs.pathExists(packagesDir)) {
+    const packageDirs = await fs.readdir(packagesDir);
+    for (const packageDir of packageDirs) {
+      const packagePath = path.join(packagesDir, packageDir);
+      const pkgJsonPath = path.join(packagePath, "package.json");
+      if (await fs.pathExists(pkgJsonPath)) {
+        const pkgJson = await fs.readJson(pkgJsonPath);
+        packagesInfo.push({
+          path: packagePath,
+          dependencies: pkgJson.dependencies || {},
+          devDependencies: pkgJson.devDependencies || {},
+        });
+      }
     }
   }
 

apps/cli/src/utils/setup-catalogs.ts

@@ -0,0 +1,3 @@
+/node_modules
+/dist
+.smoke