@react-native-reusables/cli 0.6.3 → 0.7.0

package/src/services/commands/doctor.ts

@@ -0,0 +1,287 @@
+import { CliOptions } from "@cli/contexts/cli-options.js"
+import { type CustomFileCheck, type FileCheck, type MissingInclude, PROJECT_MANIFEST } from "@cli/project-manifest.js"
+import { ProjectConfig } from "@cli/services/project-config.js"
+import { RequiredFilesChecker } from "@cli/services/required-files-checker.js"
+import { Spinner } from "@cli/services/spinner.js"
+import { runCommand } from "@cli/utils/run-command.js"
+import { Prompt } from "@effect/cli"
+import { FileSystem, Path } from "@effect/platform"
+import { Data, Effect, Layer, Schema } from "effect"
+import logSymbols from "log-symbols"
+
+const packageJsonSchema = Schema.Struct({
+  dependencies: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String })),
+  devDependencies: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.String }))
+})
+
+class PackageJsonError extends Data.TaggedError("PackageJsonError")<{
+  cause?: unknown
+  message?: string
+}> {}
+
+type DoctorOptions = {
+  cwd: string
+  summary: boolean
+  yes: boolean
+}
+
+class Doctor extends Effect.Service<Doctor>()("Doctor", {
+  dependencies: [RequiredFilesChecker.Default, Spinner.Default],
+  effect: Effect.gen(function* () {
+    const options = yield* CliOptions
+    const fs = yield* FileSystem.FileSystem
+    const path = yield* Path.Path
+    const requiredFileChecker = yield* RequiredFilesChecker
+    const spinner = yield* Spinner
+    const projectConfig = yield* ProjectConfig
+
+    const stylingLibrary = yield* projectConfig.getStylingLibrary()
+
+    if (stylingLibrary !== "unknown"){
+      console.log(
+        `\x1b[2m${logSymbols.info} Styling Library: ${stylingLibrary === "uniwind" ? "Uniwind" : "Nativewind"}\x1b[0m`
+      )
+    } 
+
+
+    const checkRequiredDependencies = ({
+      dependencies,
+      devDependencies
+    }: {
+      dependencies: Array<string>
+      devDependencies: Array<string>
+    }) =>
+      Effect.gen(function* () {
+        const packageJsonExists = yield* fs.exists(path.join(options.cwd, "package.json"))
+        if (!packageJsonExists) {
+          return yield* Effect.fail(new PackageJsonError({ message: "A package.json was not found and is required." }))
+        }
+
+        const packageJson = yield* fs.readFileString(path.join(options.cwd, "package.json")).pipe(
+          Effect.flatMap(Schema.decodeUnknown(Schema.parseJson())),
+          Effect.flatMap(Schema.decodeUnknown(packageJsonSchema)),
+          Effect.catchTags({
+            ParseError: () => Effect.fail(new PackageJsonError({ message: "Failed to parse package.json" }))
+          })
+        )
+
+        const uninstalledDependencies: Array<string> = []
+        const uninstalledDevDependencies: Array<string> = []
+
+        for (const dependency of dependencies) {
+          if (
+            !packageJson.dependencies?.[dependency.split("@")[0]] &&
+            !packageJson.devDependencies?.[dependency.split("@")[0]]
+          ) {
+            uninstalledDependencies.push(dependency)
+            continue
+          }
+          yield* Effect.logDebug(
+            `${logSymbols.success} ${dependency}@${packageJson.dependencies?.[dependency.split("@")[0]]} is installed`
+          )
+        }
+
+        for (const devDependency of devDependencies) {
+          if (
+            !packageJson.devDependencies?.[devDependency.split("@")[0]] &&
+            !packageJson.dependencies?.[devDependency.split("@")[0]]
+          ) {
+            uninstalledDevDependencies.push(devDependency)
+            continue
+          }
+          yield* Effect.logDebug(
+            `${logSymbols.success} ${devDependency}@${packageJson.devDependencies?.[devDependency]} is installed`
+          )
+        }
+
+        return { uninstalledDependencies, uninstalledDevDependencies }
+      })
+
+    const registry = stylingLibrary === "uniwind" ? "uniwind" : "nativewind"
+
+    return {
+      run: (options: DoctorOptions) =>
+        Effect.gen(function* () {
+          yield* Effect.logDebug(`Doctor options: ${JSON.stringify(options, null, 2)}`)
+          const { uninstalledDependencies, uninstalledDevDependencies } = yield* checkRequiredDependencies({
+            dependencies: PROJECT_MANIFEST.dependencies[registry],
+            devDependencies: PROJECT_MANIFEST.devDependencies
+          })
+
+          const { customFileResults, deprecatedFileResults, fileResults } = yield* requiredFileChecker.run({
+            customFileChecks: PROJECT_MANIFEST.customFileChecks,
+            deprecatedFromLib: PROJECT_MANIFEST.deprecatedFromLib,
+            deprecatedFromUi: PROJECT_MANIFEST.deprecatedFromUi,
+            fileChecks: PROJECT_MANIFEST.fileChecks,
+            stylingLibrary: registry 
+          })
+
+          const result = {
+            missingFiles: [...fileResults.missingFiles, ...customFileResults.missingFiles],
+            uninstalledDependencies,
+            uninstalledDevDependencies,
+            missingIncludes: [...fileResults.missingIncludes, ...customFileResults.missingIncludes],
+            deprecatedFileResults
+          }
+
+          let total = Object.values(result).reduce((sum, cat) => sum + cat.length, 0)
+          if (!options.summary) {
+            const dependenciesToInstall: Array<string> = []
+            for (const dep of result.uninstalledDependencies) {
+              const confirmsInstall = options.yes
+                ? true
+                : yield* Prompt.confirm({
+                    message: `The ${dep} dependency is missing. Do you want to install it?`,
+                    initial: true
+                  })
+              if (confirmsInstall) {
+                if (uninstalledDependencies.includes("expo")) {
+                  continue
+                }
+                total--
+                yield* Effect.logDebug(`Adding ${dep} to dependencies to install`)
+                dependenciesToInstall.push(dep)
+                result.uninstalledDependencies = result.uninstalledDependencies.filter((d) => d !== dep)
+              }
+            }
+
+            if (dependenciesToInstall.length > 0) {
+              yield* Effect.logDebug(`Installing ${dependenciesToInstall.join(", ")}`)
+              if (process.env.INTERNAL_ENV !== "development") {
+                spinner.start("Installing dependencies")
+                yield* runCommand("npx", ["expo", "install", ...dependenciesToInstall], {
+                  cwd: options.cwd
+                })
+                spinner.stop()
+              }
+            }
+
+            const devDependenciesToInstall: Array<string> = []
+            for (const dep of result.uninstalledDevDependencies) {
+              const confirmsInstall = options.yes
+                ? true
+                : yield* Prompt.confirm({
+                    message: `The ${dep} dependency is missing. Do you want to install it?`,
+                    initial: true
+                  })
+              if (confirmsInstall) {
+                if (uninstalledDependencies.includes("expo")) {
+                  continue
+                }
+                total--
+                yield* Effect.logDebug(`Adding ${dep} to devDependencies to install`)
+                devDependenciesToInstall.push(dep)
+                result.uninstalledDevDependencies = result.uninstalledDevDependencies.filter((d) => d !== dep)
+              }
+            }
+
+            if (devDependenciesToInstall.length > 0) {
+              yield* Effect.logDebug(`Installing ${devDependenciesToInstall.join(", ")}`)
+              if (process.env.INTERNAL_ENV !== "development") {
+                spinner.start("Installing dev dependencies")
+                yield* runCommand("npx", ["expo", "install", ...devDependenciesToInstall], {
+                  cwd: options.cwd
+                })
+                spinner.stop()
+              }
+            }
+          }
+
+          if (total === 0) {
+            console.log(`\x1b[2m${logSymbols.success} All checks passed.\x1b[0m\n`)
+            return yield* Effect.succeed(true)
+          }
+
+          const analysis = analyzeResult(result)
+          if (options.summary) {
+            console.log(
+              `\x1b[2m${logSymbols.warning} ${total} Potential issue${
+                total > 1 ? "s" : ""
+              } found. For more info, run: 'npx @react-native-reusables/cli doctor${
+                options.cwd !== "." ? ` -c ${options.cwd}` : ""
+              }'\x1b[0m\n`
+            )
+          } else {
+            yield* Effect.log("\n\n🩺 Diagnosis")
+            for (const item of analysis) {
+              console.group(`\n${item.title}`)
+              item.logs.forEach((line) => console.log(line))
+              console.groupEnd()
+            }
+            console.log(`\n`)
+          }
+        })
+    }
+  })
+}) {}
+
+function make(options: DoctorOptions) {
+  const optionsLayer = Layer.succeed(CliOptions, { ...options, stylingLibrary: undefined })
+  return Effect.gen(function* () {
+    const doctor = yield* Doctor
+    return yield* doctor.run(options)
+  }).pipe(Effect.provide(Doctor.Default), Effect.provide(ProjectConfig.Default), Effect.provide(optionsLayer))
+}
+
+export { Doctor, make }
+
+interface Result {
+  missingFiles: Array<FileCheck | CustomFileCheck>
+  missingIncludes: Array<MissingInclude>
+  uninstalledDependencies: Array<string>
+  uninstalledDevDependencies: Array<string>
+  deprecatedFileResults: Array<Omit<FileCheck, "docs" | "stylingLibraries">>
+}
+
+function analyzeResult(result: Result) {
+  const categories: Array<{ title: string; logs: Array<string>; count: number }> = []
+
+  if (result.missingFiles.length > 0) {
+    categories.push({
+      title: `${logSymbols.error} Missing Files (${result.missingFiles.length})`,
+      count: result.missingFiles.length,
+      logs: result.missingFiles.flatMap((f) => [`• ${f.name}`, `  📘 Docs: ${f.docs}`])
+    })
+  }
+
+  if (result.missingIncludes.length > 0) {
+    categories.push({
+      title: `${logSymbols.error} Potentially Misconfigured Files (${result.missingIncludes.length})`,
+      count: result.missingIncludes.length,
+      logs: result.missingIncludes.flatMap((inc) => [
+        `• ${inc.fileName}`,
+        `  ↪ ${inc.message}`,
+        `  📘 Docs: ${inc.docs}`
+      ])
+    })
+  }
+
+  if (result.uninstalledDependencies.length > 0) {
+    categories.push({
+      title: `${logSymbols.error} Missing Dependencies (${result.uninstalledDependencies.length})`,
+      count: result.uninstalledDependencies.length,
+      logs: ["• Install with:", `  ↪ npx expo install ${result.uninstalledDependencies.join(" ")}`]
+    })
+  }
+
+  if (result.uninstalledDevDependencies.length > 0) {
+    categories.push({
+      title: `${logSymbols.error} Missing Dev Dependencies (${result.uninstalledDevDependencies.length})`,
+      count: result.uninstalledDevDependencies.length,
+      logs: ["• Install with:", `  ↪ npx expo install -- -D ${result.uninstalledDevDependencies.join(" ")}`]
+    })
+  }
+
+  if (result.deprecatedFileResults.length > 0) {
+    categories.push({
+      title: `${logSymbols.warning} Deprecated (${result.deprecatedFileResults.length})`,
+      count: result.deprecatedFileResults.length,
+      logs: result.deprecatedFileResults.flatMap((deprecatedFile) => [
+        `• ${deprecatedFile.name}`,
+        ...deprecatedFile.includes.map((item) => `  ↪ ${item.message}\n  📘 Docs: ${item.docs}`)
+      ])
+    })
+  }
+
+  return categories
+}

package/src/services/commands/init.ts

@@ -0,0 +1,94 @@
+import { CliOptions } from "@cli/contexts/cli-options.js"
+import { PROJECT_MANIFEST } from "@cli/project-manifest.js"
+import { Doctor } from "@cli/services/commands/doctor.js"
+import { ProjectConfig } from "@cli/services/project-config.js"
+import { Template } from "@cli/services/template.js"
+import { Prompt } from "@effect/cli"
+import { FileSystem, Path } from "@effect/platform"
+import { Effect, Layer } from "effect"
+import logSymbols from "log-symbols"
+
+type InitOptions = {
+  cwd: string
+  template: string
+}
+
+class Init extends Effect.Service<Init>()("Init", {
+  dependencies: [Template.Default],
+  effect: Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const path = yield* Path.Path
+    const doctor = yield* Doctor
+    const template = yield* Template
+
+    return {
+      run: (options: InitOptions) =>
+        Effect.gen(function* () {
+          yield* Effect.logDebug(`Init options: ${JSON.stringify(options, null, 2)}`)
+
+          const packageJsonExists = yield* fs.exists(path.join(options.cwd, "package.json"))
+
+          yield* Effect.logDebug(`Does package.json exist: ${packageJsonExists ? "yes" : "no"}`)
+
+          if (packageJsonExists) {
+            yield* Effect.logWarning(`${logSymbols.warning} A project already exists in this directory.`)
+            const choice = yield* Prompt.select({
+              message: "How would you like to proceed?",
+              choices: [
+                { title: "Initialize a new project here anyway", value: "init-new" },
+                { title: "Inspect project configuration", value: "doctor" },
+                { title: "Cancel and exit", value: "cancel" }
+              ]
+            })
+            yield* Effect.logDebug(`Init choice: ${choice}`)
+            if (choice === "cancel") {
+              return yield* Effect.succeed(true)
+            }
+            if (choice === "doctor") {
+              console.log("")
+              return yield* doctor.run({ ...options, summary: false, yes: false })
+            }
+          }
+
+          const projectName = yield* Prompt.text({
+            message: "What is the name of your project? (e.g. my-app)",
+            default: "my-app"
+          })
+
+          const templateFromFlag = PROJECT_MANIFEST.templates.find((t) => t.subPath === options.template)
+
+          const selectedTemplate = templateFromFlag
+            ? templateFromFlag
+            : yield* Prompt.select({
+                message: "Select a template",
+                choices: PROJECT_MANIFEST.templates.map((template) => ({
+                  title: template.name,
+                  value: template
+                }))
+              })
+
+          yield* template.clone({
+            cwd: options.cwd,
+            name: projectName,
+            repo: selectedTemplate
+          })
+        })
+    }
+  })
+}) {}
+
+function make(options: InitOptions) {
+  const optionsLayer = Layer.succeed(CliOptions, { ...options, yes: true, stylingLibrary: undefined })
+  return Effect.gen(function* () {
+    const init = yield* Init
+
+    return yield* init.run(options)
+  }).pipe(
+    Effect.provide(Init.Default),
+    Effect.provide(Doctor.Default),
+    Effect.provide(ProjectConfig.Default),
+    Effect.provide(optionsLayer)
+  )
+}
+
+export { make }

package/src/services/git.ts

@@ -0,0 +1,39 @@
+import { Data, Effect } from "effect"
+import { Command } from "@effect/platform"
+import { Prompt } from "@effect/cli"
+import logSymbols from "log-symbols"
+
+export class GitError extends Data.TaggedError("GitError")<{
+  cause?: unknown
+  message?: string
+}> {}
+
+const COMMANDS = {
+  status: Command.make("git", "status", "--porcelain")
+} as const
+
+export class Git extends Effect.Service<Git>()("Git", {
+  succeed: {
+    promptIfDirty: () =>
+      Effect.gen(function* () {
+        const gitStatus = yield* COMMANDS.status.pipe(
+          Command.string,
+          Effect.catchAll(() => Effect.succeed("")) // Not a git repository
+        )
+        const isDirty = gitStatus.trim().length > 0
+        if (!isDirty) {
+          return false
+        }
+        const result = yield* Prompt.confirm({
+          message: `${logSymbols.warning} The Git repository is dirty (uncommitted changes). Continue anyway?`,
+          initial: true
+        })
+
+        if (!result) {
+          return yield* Effect.fail(new GitError({ message: "Aborted due to uncommitted changes." }))
+        }
+
+        return result
+      })
+  }
+}) {}

package/src/services/package-manager.ts

@@ -0,0 +1,48 @@
+import { Effect } from "effect"
+import { detect } from "package-manager-detector"
+
+const PACKAGE_MANAGERS = ["npm", "bun", "pnpm", "yarn@berry", "yarn"] as const
+
+const BINARY_RUNNERS = {
+  npm: ["npx"],
+  bun: ["bunx", "--bun"],
+  pnpm: ["pnpm", "dlx"],
+  yarn: ["npx"],
+  "yarn@berry": ["npx"]
+} as const
+
+const detectPackageManager = (cwd: string) =>
+  Effect.tryPromise({
+    try: () => {
+      return detect({
+        cwd,
+        strategies: ["install-metadata", "lockfile", "packageManager-field", "devEngines-field"]
+      })
+    },
+    catch: () => new Error("Failed to get package manager")
+  })
+
+const getPackageManager = (cwd: string) =>
+  Effect.gen(function* () {
+    const pm = yield* detectPackageManager(cwd)
+    if (!pm) {
+      return "npm"
+    }
+    const name = PACKAGE_MANAGERS.find((name) => pm.agent.startsWith(name) || pm.name.startsWith(name)) ?? "npm"
+    return name
+  })
+const getBinaryRunner = (cwd: string) =>
+  Effect.gen(function* () {
+    const pm = yield* getPackageManager(cwd)
+    return BINARY_RUNNERS[pm]
+  })
+
+class PackageManager extends Effect.Service<PackageManager>()("PackageManager", {
+  succeed: {
+    detectPackageManager,
+    getPackageManager,
+    getBinaryRunner
+  }
+}) {}
+
+export { PackageManager }