@react-native-reusables/cli 0.6.2 → 0.7.0

package/src/services/project-config.ts

@@ -0,0 +1,295 @@
+import { CliOptions } from "@cli/contexts/cli-options.js"
+import { retryWith } from "@cli/utils/retry-with.js"
+import { Prompt } from "@effect/cli"
+import { FileSystem, Path } from "@effect/platform"
+import { Effect, Schema } from "effect"
+import { Git } from "./git.js"
+import { type ConfigLoaderSuccessResult, createMatchPath, loadConfig as loadTypescriptConfig } from "tsconfig-paths"
+import { PROJECT_MANIFEST } from "@cli/project-manifest.js"
+
+const componentJsonSchema = Schema.Struct({
+  $schema: Schema.optional(Schema.String),
+  style: Schema.String,
+  rsc: Schema.Boolean,
+  tsx: Schema.Boolean,
+  tailwind: Schema.Struct({
+    config: Schema.optional(Schema.String),
+    css: Schema.String,
+    baseColor: Schema.String,
+    cssVariables: Schema.Boolean,
+    prefix: Schema.optional(Schema.String)
+  }),
+  aliases: Schema.Struct({
+    components: Schema.String,
+    utils: Schema.String,
+    ui: Schema.optional(Schema.String),
+    lib: Schema.optional(Schema.String),
+    hooks: Schema.optional(Schema.String)
+  }),
+  iconLibrary: Schema.optional(Schema.String)
+})
+
+const supportedExtensions = [".ts", ".tsx", ".jsx", ".js", ".css"]
+
+class ProjectConfig extends Effect.Service<ProjectConfig>()("ProjectConfig", {
+  dependencies: [Git.Default],
+  effect: Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const path = yield* Path.Path
+    const options = yield* CliOptions
+    const git = yield* Git
+
+    let componentJsonConfig: typeof componentJsonSchema.Type | null = null
+    let tsConfig: ConfigLoaderSuccessResult | null = null
+
+    const getComponentJson = () =>
+      Effect.gen(function* () {
+        if (componentJsonConfig) {
+          return componentJsonConfig
+        }
+
+        const componentJsonExists = yield* fs.exists(path.join(options.cwd, "components.json"))
+        if (!componentJsonExists) {
+          return yield* handleInvalidComponentJson(false)
+        }
+        const config = yield* fs.readFileString(path.join(options.cwd, "components.json")).pipe(
+          Effect.flatMap(Schema.decodeUnknown(Schema.parseJson())),
+          Effect.flatMap(Schema.decodeUnknown(componentJsonSchema)),
+          Effect.catchTags({
+            ParseError: () => handleInvalidComponentJson(true)
+          })
+        )
+
+        componentJsonConfig = config
+
+        yield* Effect.logDebug(`componentJsonConfig: ${JSON.stringify(componentJsonConfig, null, 2)}`)
+        return config
+      })
+
+    const getUniwindDtsPath = () =>
+      Effect.gen(function* () {
+        const metroConfigPaths = ["metro.config.js", "metro.config.ts"].map((p) => path.join(options.cwd, p)) as [
+          string,
+          ...Array<string>
+        ]
+
+        const metroContent = yield* retryWith((filePath: string) => fs.readFileString(filePath), metroConfigPaths).pipe(
+          Effect.catchAll(() => Effect.succeed(null))
+        )
+
+        if (!metroContent?.includes("withUniwindConfig")) {
+          return null
+        }
+
+        const dtsFileMatch = metroContent.match(/dtsFile\s*:\s*["']([^"']+)["']/)
+        if (dtsFileMatch?.[1]) {
+          const dtsPath = dtsFileMatch[1].replace(/^\.\//, "")
+          return path.join(options.cwd, dtsPath)
+        }
+
+        return path.join(options.cwd, PROJECT_MANIFEST.uniwindTypesFile)
+      })
+
+    const getStylingLibrary = () =>
+      Effect.gen(function* () {
+        if (options.stylingLibrary) {
+          return options.stylingLibrary
+        }
+
+        const metroConfigPaths = ["metro.config.js", "metro.config.ts"].map((p) => path.join(options.cwd, p)) as [
+          string,
+          ...Array<string>
+        ]
+
+        const metroContent = yield* retryWith((filePath: string) => fs.readFileString(filePath), metroConfigPaths).pipe(
+          Effect.catchAll(() => Effect.succeed(null))
+        )
+
+        if (metroContent?.includes("withUniwindConfig")) {
+          return "uniwind" as const
+        }
+
+        // v4 uses withNativeWind
+        // v5 uses withNativewind
+        if (metroContent?.toLowerCase().includes("withnativewind")) {
+          return "nativewind" as const
+        }
+
+        return "unknown" as const 
+      })
+
+    const handleInvalidComponentJson = (exists: boolean) =>
+      Effect.gen(function* () {
+        yield* Effect.logWarning(
+          `${exists ? "Invalid components.json" : "Missing components.json"}${" (required to continue)"}`
+        )
+        const agreeToWrite =  yield* Prompt.confirm({
+              message: `Would you like to ${exists ? "update the" : "write a"} components.json file?`,
+              label: { confirm: "y", deny: "n" },
+              initial: true,
+              placeholder: { defaultConfirm: "y/n" }
+            })
+        if (!agreeToWrite) {
+          return yield* Effect.fail(new Error("Unable to continue without a valid components.json file."))
+        }
+
+        const baseColor = options.yes
+          ? "neutral"
+          : yield* Prompt.select({
+              message: "Which color would you like to use as the base color?",
+              choices: [
+                { title: "neutral", value: "neutral" },
+                { title: "stone", value: "stone" },
+                { title: "zinc", value: "zinc" },
+                { title: "gray", value: "gray" },
+                { title: "slate", value: "slate" }
+              ] as const
+            })
+
+        const hasRootGlobalCss = yield* fs.exists(path.join(options.cwd, "global.css"))
+
+        const hasSrcGlobalCss = hasRootGlobalCss ? false : yield* fs.exists(path.join(options.cwd, "src/global.css"))
+
+        const detectedCss = hasRootGlobalCss ? "global.css" : hasSrcGlobalCss ? "src/global.css" : ""
+
+        const css =
+          options.yes && detectedCss
+            ? detectedCss
+            : yield* Prompt.text({
+                message: "What is the name of the CSS file and path to it? (e.g. global.css or src/global.css)",
+                default: detectedCss
+              })
+        
+        const stylingLibrary = yield* getStylingLibrary()
+
+        const hasTailwindConfig = yield* fs.exists(path.join(options.cwd, "tailwind.config.js"))
+        const tailwindConfig = stylingLibrary === "uniwind" ? "" :
+          options.yes && hasTailwindConfig
+            ? "tailwind.config.js"
+            : yield* Prompt.text({
+                message:
+                  "What is the name of the Tailwind config file and path to it? (e.g. tailwind.config.js or src/tailwind.config.js)",
+                default: "tailwind.config.js"
+              })
+
+        const tsConfig = yield* getTsConfig()
+
+        const aliasSymbol = `${(Object.keys(tsConfig.paths ?? {})[0] ?? "@/*").split("/*")[0]}`
+
+        const detectedAliases = {
+          components: `${aliasSymbol}/components`,
+          utils: `${aliasSymbol}/lib/utils`,
+          ui: `${aliasSymbol}/components/ui`,
+          lib: `${aliasSymbol}/lib`,
+          hooks: `${aliasSymbol}/hooks`
+        }
+
+        let aliases = detectedAliases
+
+        if (!options.yes) {
+          const useDetectedAliases = yield* Prompt.confirm({
+            message: `Use detected alias (${aliasSymbol}/*) in your setup?`,
+            initial: true
+          })
+
+          if (!useDetectedAliases) {
+            const [componentsAlias, utilsAlias, uiAlias, libAlias, hooksAlias] = yield* Prompt.all([
+              Prompt.text({
+                message: "What is the name of the components alias?",
+                default: detectedAliases.components
+              }),
+              Prompt.text({
+                message: "What is the name of the utils alias?",
+                default: detectedAliases.utils
+              }),
+              Prompt.text({
+                message: "What is the name of the ui alias?",
+                default: detectedAliases.ui
+              }),
+              Prompt.text({
+                message: "What is the name of the lib alias?",
+                default: detectedAliases.lib
+              }),
+              Prompt.text({
+                message: "What is the name of the hooks alias?",
+                default: detectedAliases.hooks
+              })
+            ])
+
+            aliases = {
+              components: componentsAlias,
+              utils: utilsAlias,
+              ui: uiAlias,
+              lib: libAlias,
+              hooks: hooksAlias
+            }
+          }
+        }
+
+        const newComponentJson = yield* Schema.encode(componentJsonSchema)({
+          $schema: "https://ui.shadcn.com/schema.json",
+          style: "new-york",
+          aliases,
+          rsc: false,
+          tsx: true,
+          tailwind: {
+            css,
+            baseColor,
+            cssVariables: true,
+            config: tailwindConfig
+          }
+        })
+
+        yield* git.promptIfDirty()
+        yield* fs.writeFileString(path.join(options.cwd, "components.json"), JSON.stringify(newComponentJson, null, 2))
+        yield* Effect.logDebug(`newComponentJson: ${JSON.stringify(newComponentJson, null, 2)}`)
+        return newComponentJson
+      })
+
+    const getTsConfig = () =>
+      Effect.try({
+        try: () => {
+          if (tsConfig) {
+            return tsConfig
+          }
+          const configResult = loadTypescriptConfig(options.cwd)
+          if (configResult.resultType === "failed") {
+            throw new Error("Error loading tsconfig.json", { cause: configResult.message })
+          }
+          tsConfig = configResult
+          return configResult
+        },
+        catch: (error) => new Error("Error loading {ts,js}config.json", { cause: String(error) })
+      })
+
+    const resolvePathFromAlias = (aliasPath: string) =>
+      Effect.gen(function* () {
+        const config = yield* getTsConfig()
+        return yield* Effect.try({
+          try: () => {
+            const matchPath = createMatchPath(config.absoluteBaseUrl, config.paths)(
+              aliasPath,
+              undefined,
+              () => true,
+              supportedExtensions
+            )
+            if (!matchPath) {
+              throw new Error("Path not found", { cause: aliasPath })
+            }
+            return matchPath
+          },
+          catch: (error) => new Error("Path not found", { cause: String(error) })
+        })
+      })
+
+    return {
+      getComponentJson,
+      getTsConfig,
+      resolvePathFromAlias,
+      getStylingLibrary,
+      getUniwindDtsPath
+    }
+  })
+}) {}
+
+export { ProjectConfig }

package/src/services/required-files-checker.ts

@@ -0,0 +1,375 @@
+import { CliOptions } from "@cli/contexts/cli-options.js"
+import type { CustomFileCheck, FileCheck, FileWithContent, MissingInclude } from "@cli/project-manifest.js"
+import { PROJECT_MANIFEST } from "@cli/project-manifest.js"
+import { ProjectConfig } from "@cli/services/project-config.js"
+import { retryWith } from "@cli/utils/retry-with.js"
+import { FileSystem, Path } from "@effect/platform"
+import { Data, Effect } from "effect"
+import logSymbols from "log-symbols"
+
+class RequiredFileError extends Data.TaggedError("RequiredFileError")<{
+  file: string
+  message?: string
+}> { }
+
+class RequiredFilesChecker extends Effect.Service<RequiredFilesChecker>()("RequiredFilesChecker", {
+  effect: Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const path = yield* Path.Path
+    const options = yield* CliOptions
+    const projectConfig = yield* ProjectConfig
+
+    const checkFiles = (fileChecks: Array<FileCheck>, stylingLibrary: "nativewind" | "uniwind") =>
+      Effect.gen(function* () {
+        const missingFiles: Array<FileCheck> = []
+        const missingIncludes: Array<MissingInclude> = []
+
+        const filesWithContent = yield* Effect.forEach(
+          fileChecks.filter((file) => file.stylingLibraries.includes(stylingLibrary)),
+          (file) =>
+            retryWith(
+              (filePath: string) =>
+                Effect.gen(function* () {
+                  const fileContents = yield* fs.readFileString(filePath)
+                  yield* Effect.logDebug(`${logSymbols.success} ${file.name} found`)
+                  return { ...file, content: fileContents } as FileWithContent
+                }),
+              file.fileNames.map((p) => path.join(options.cwd, p)) as [string, ...Array<string>]
+            ).pipe(
+              Effect.catchAll(() => {
+                missingFiles.push(file)
+                return Effect.logDebug(`${logSymbols.error} ${file.name} not found`).pipe(() => Effect.succeed(null))
+              })
+            ),
+          { concurrency: "unbounded" }
+        ).pipe(Effect.map((files) => files.filter((file): file is FileWithContent => file !== null)))
+
+        yield* Effect.forEach(filesWithContent, (file) =>
+          Effect.gen(function* () {
+            const { content, includes, name } = file
+            for (const include of includes) {
+              if (include.content.every((str) => content.includes(str))) {
+                yield* Effect.logDebug(`${logSymbols.success} ${name} has ${include.content.join(", ")}`)
+                continue
+              }
+              yield* Effect.logDebug(`${logSymbols.error} ${name} missing ${include.content.join(", ")}`)
+              missingIncludes.push({ ...include, fileName: name })
+            }
+          })
+        )
+
+        return { missingFiles, missingIncludes }
+      })
+
+    const checkDeprecatedFiles = (
+      deprecatedFromLib: Array<Omit<FileCheck, "docs" | "stylingLibraries">>,
+      deprecatedFromUi: Array<Omit<FileCheck, "docs" | "stylingLibraries">>
+    ) =>
+      Effect.gen(function* () {
+        const componentJson = yield* projectConfig.getComponentJson()
+        const aliasForLib = componentJson.aliases.lib ?? `${componentJson.aliases.utils}/lib`
+
+        const existingDeprecatedFromLibs = yield* Effect.forEach(
+          deprecatedFromLib,
+          (file) =>
+            projectConfig.resolvePathFromAlias(`${aliasForLib}/${file.fileNames[0]}`).pipe(
+              Effect.flatMap((fullPath) =>
+                Effect.gen(function* () {
+                  const exists = yield* fs.exists(fullPath)
+                  if (!exists) {
+                    yield* Effect.logDebug(
+                      `${logSymbols.success} Deprecated ${aliasForLib}/${file.fileNames[0]} not found`
+                    )
+                    return { ...file, hasIncludes: false }
+                  }
+
+                  yield* Effect.logDebug(`${logSymbols.error} Deprecated ${aliasForLib}/${file.fileNames[0]} found`)
+
+                  const fileContent = yield* fs.readFileString(fullPath)
+
+                  return {
+                    ...file,
+                    hasIncludes: file.includes.some((include) =>
+                      include.content.some((content) => fileContent.includes(content))
+                    )
+                  }
+                })
+              )
+            ),
+          { concurrency: "unbounded" }
+        ).pipe(
+          Effect.map((results) =>
+            results.filter((result) => result.hasIncludes).map(({ hasIncludes: _hasIncludes, ...result }) => result)
+          )
+        )
+
+        const aliasForUi = componentJson.aliases.ui ?? `${componentJson.aliases.components}/ui`
+
+        const existingDeprecatedFromUi = yield* Effect.forEach(
+          deprecatedFromUi,
+          (file) =>
+            projectConfig.resolvePathFromAlias(`${aliasForUi}/${file.fileNames[0]}`).pipe(
+              Effect.flatMap((fullPath) =>
+                Effect.gen(function* () {
+                  const exists = yield* fs.exists(fullPath)
+                  if (!exists) {
+                    yield* Effect.logDebug(
+                      `${logSymbols.success} Deprecated ${aliasForUi}/${file.fileNames[0]} not found`
+                    )
+                    return { ...file, hasIncludes: false }
+                  }
+
+                  yield* Effect.logDebug(`${logSymbols.error} Deprecated ${aliasForUi}/${file.fileNames[0]} found`)
+
+                  const fileContent = yield* fs.readFileString(fullPath)
+
+                  return {
+                    ...file,
+                    hasIncludes: file.includes.some((include) =>
+                      include.content.some((content) => fileContent.includes(content))
+                    )
+                  }
+                })
+              )
+            ),
+          { concurrency: "unbounded" }
+        ).pipe(
+          Effect.map((results) =>
+            results.filter((result) => result.hasIncludes).map(({ hasIncludes: _hasIncludes, ...result }) => result)
+          )
+        )
+
+        return [...existingDeprecatedFromLibs, ...existingDeprecatedFromUi]
+      })
+
+    const checkCustomFiles = (
+      customFileChecks: Record<string, CustomFileCheck>,
+      stylingLibrary: "nativewind" | "uniwind"
+    ) =>
+      Effect.gen(function* () {
+        const componentJson = yield* projectConfig.getComponentJson()
+        const aliasForLib = componentJson.aliases.lib ?? `${componentJson.aliases.utils}/lib`
+        const missingFiles: Array<CustomFileCheck> = []
+        const missingIncludes: Array<MissingInclude> = []
+
+        // Check CSS files
+        const cssPaths = [componentJson.tailwind.css, "global.css", "src/global.css"].filter((p) => p != null)
+        const cssContent = yield* retryWith(
+          (filePath: string) =>
+            Effect.gen(function* () {
+              const content = yield* fs.readFileString(filePath)
+              yield* Effect.logDebug(`${logSymbols.success} ${customFileChecks.css.name} found`)
+              return content
+            }),
+          cssPaths.map((p) => path.join(options.cwd, p)) as [string, ...Array<string>]
+        ).pipe(
+          Effect.catchAll(() =>
+            Effect.fail(
+              new RequiredFileError({
+                file: "CSS",
+                message:
+                  "CSS file not found. Please follow the instructions at https://www.nativewind.dev/docs/getting-started/installation#installation-with-expo"
+              })
+            )
+          )
+        )
+
+        const cssShouldInclude =
+          stylingLibrary === "uniwind" ? customFileChecks.uniwindCss.includes : customFileChecks.css.includes
+
+        for (const include of cssShouldInclude) {
+          if (include.content.every((str) => cssContent.includes(str))) {
+            yield* Effect.logDebug(
+              `${logSymbols.success} ${customFileChecks.css.name} has ${include.content.join(", ")}`
+            )
+            continue
+          }
+          yield* Effect.logDebug(
+            `${logSymbols.error} ${customFileChecks.css.name} missing ${include.content.join(", ")}`
+          )
+          missingIncludes.push({ ...include, fileName: customFileChecks.css.name })
+        }
+
+        // Check Nativewind env or Uniwind types file
+        if (componentJson.tsx !== false) {
+          const missingTypeFiles: Array<CustomFileCheck> = []
+
+          if (stylingLibrary === "nativewind") {
+            const nativewindEnvContent = yield* fs
+              .readFileString(path.join(options.cwd, PROJECT_MANIFEST.nativewindEnvFile))
+              .pipe(
+                Effect.catchAll(() => {
+                  missingTypeFiles.push(customFileChecks.nativewindEnv)
+                  return Effect.succeed(null)
+                })
+              )
+
+            if (nativewindEnvContent) {
+              for (const include of customFileChecks.nativewindEnv.includes) {
+                if (include.content.every((str) => nativewindEnvContent.includes(str))) {
+                  yield* Effect.logDebug(
+                    `${logSymbols.success} ${customFileChecks.nativewindEnv.name} has ${include.content.join(", ")}`
+                  )
+                  continue
+                }
+                yield* Effect.logDebug(
+                  `${logSymbols.error} ${customFileChecks.nativewindEnv.name} missing ${include.content.join(", ")}`
+                )
+                missingIncludes.push({ ...include, fileName: customFileChecks.nativewindEnv.name })
+              }
+            }
+          }
+
+          if (stylingLibrary === "uniwind") {
+            // Get uniwind dts path from metro config (supports custom dtsFile)
+            const uniwindDtsPath = yield* projectConfig.getUniwindDtsPath()
+            const uniwindTypesContent: string | null = uniwindDtsPath
+              ? yield* fs.readFileString(uniwindDtsPath).pipe(
+                Effect.catchAll(() => {
+                  missingTypeFiles.push(customFileChecks.uniwindTypes)
+                  return Effect.succeed(null)
+                })
+              )
+              : null
+
+            if (uniwindTypesContent) {
+              for (const include of customFileChecks.uniwindTypes.includes) {
+                if (include.content.every((str) => uniwindTypesContent.includes(str))) {
+                  yield* Effect.logDebug(
+                    `${logSymbols.success} ${customFileChecks.uniwindTypes.name} has ${include.content.join(", ")}`
+                  )
+                  continue
+                }
+                yield* Effect.logDebug(
+                  `${logSymbols.error} ${customFileChecks.uniwindTypes.name} missing ${include.content.join(", ")}`
+                )
+                missingIncludes.push({ ...include, fileName: customFileChecks.uniwindTypes.name })
+              }
+            }
+          }
+
+          if (missingTypeFiles.length === 2) {
+            missingFiles.push(missingTypeFiles[0], missingTypeFiles[1])
+          }
+        }
+
+        if (stylingLibrary === "nativewind") {
+          // Check Tailwind config
+          const tailwindConfigPaths = [
+            componentJson.tailwind.config,
+            "tailwind.config.js",
+            "tailwind.config.ts"
+          ].filter((p) => p != null)
+          const tailwindConfigContent = yield* retryWith(
+            (filePath: string) =>
+              Effect.gen(function* () {
+                const content = yield* fs.readFileString(filePath)
+                yield* Effect.logDebug(`${logSymbols.success} ${customFileChecks.tailwindConfig.name} found`)
+                return content
+              }),
+            tailwindConfigPaths.map((p) => path.join(options.cwd, p)) as [string, ...Array<string>]
+          ).pipe(
+            Effect.catchAll(() => {
+              console.warn(
+                `${logSymbols.warning} Tailwind config not found, Please follow the instructions at https://www.nativewind.dev/docs/getting-started/installation#installation-with-expo`);
+              return Effect.succeed("")
+            })
+          )
+
+          for (const include of customFileChecks.tailwindConfig.includes) {
+            if (include.content.every((str) => tailwindConfigContent.includes(str))) {
+              yield* Effect.logDebug(
+                `${logSymbols.success} ${customFileChecks.tailwindConfig.name} has ${include.content.join(", ")}`
+              )
+              continue
+            }
+            yield* Effect.logDebug(
+              `${logSymbols.error} ${customFileChecks.tailwindConfig.name} missing ${include.content.join(", ")}`
+            )
+            missingIncludes.push({ ...include, fileName: customFileChecks.tailwindConfig.name })
+          }
+        }
+
+        // Check theme file
+        const themeAliasPath = yield* projectConfig.resolvePathFromAlias(`${aliasForLib}/theme.ts`)
+        const themeContent = yield* fs.readFileString(themeAliasPath).pipe(
+          Effect.catchAll(() => {
+            missingFiles.push(customFileChecks.theme)
+            return Effect.succeed(null)
+          })
+        )
+
+        if (themeContent) {
+          for (const include of customFileChecks.theme.includes) {
+            if (include.content.every((str) => themeContent.includes(str))) {
+              yield* Effect.logDebug(
+                `${logSymbols.success} ${customFileChecks.theme.name} has ${include.content.join(", ")}`
+              )
+              continue
+            }
+            yield* Effect.logDebug(
+              `${logSymbols.error} ${customFileChecks.theme.name} missing ${include.content.join(", ")}`
+            )
+            missingIncludes.push({ ...include, fileName: customFileChecks.theme.name })
+          }
+        } else {
+          yield* Effect.logDebug(`${logSymbols.error} ${customFileChecks.theme.name} not found`)
+        }
+
+        // Check utils file
+        const utilsPath = yield* projectConfig.resolvePathFromAlias(`${aliasForLib}/utils.ts`)
+        const utilsContent = yield* fs.readFileString(utilsPath).pipe(
+          Effect.catchAll(() => {
+            missingFiles.push(customFileChecks.utils)
+            return Effect.succeed(null)
+          })
+        )
+
+        if (utilsContent) {
+          for (const include of customFileChecks.utils.includes) {
+            if (include.content.every((str) => utilsContent.includes(str))) {
+              yield* Effect.logDebug(
+                `${logSymbols.success} ${customFileChecks.utils.name} has ${include.content.join(", ")}`
+              )
+              continue
+            }
+            yield* Effect.logDebug(
+              `${logSymbols.error} ${customFileChecks.utils.name} missing ${include.content.join(", ")}`
+            )
+            missingIncludes.push({ ...include, fileName: customFileChecks.utils.name })
+          }
+        } else {
+          yield* Effect.logDebug(`${logSymbols.error} ${customFileChecks.utils.name} not found`)
+        }
+
+        return { missingFiles, missingIncludes }
+      })
+
+    return {
+      run: ({
+        customFileChecks,
+        deprecatedFromLib,
+        deprecatedFromUi,
+        fileChecks,
+        stylingLibrary
+      }: {
+        fileChecks: Array<FileCheck>
+        customFileChecks: Record<string, CustomFileCheck>
+        deprecatedFromLib: Array<Omit<FileCheck, "docs" | "stylingLibraries">>
+        deprecatedFromUi: Array<Omit<FileCheck, "docs" | "stylingLibraries">>
+        stylingLibrary: "nativewind" | "uniwind"
+      }) =>
+        Effect.gen(function* () {
+          const [fileResults, customFileResults, deprecatedFileResults] = yield* Effect.all([
+            checkFiles(fileChecks, stylingLibrary),
+            checkCustomFiles(customFileChecks, stylingLibrary),
+            checkDeprecatedFiles(deprecatedFromLib, deprecatedFromUi)
+          ])
+
+          return { fileResults, customFileResults, deprecatedFileResults }
+        })
+    }
+  })
+}) { }
+
+export { RequiredFilesChecker }

package/src/services/spinner.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect"
+import ora from "ora"
+
+class Spinner extends Effect.Service<Spinner>()("Spinner", {
+  effect: Effect.gen(function* () {
+    const spinner = yield* Effect.try({
+      try: () => ora(),
+      catch: () => new Error("Failed to create spinner")
+    })
+
+    return spinner
+  })
+}) {}
+
+export { Spinner }