@react-native-reusables/cli 0.7.0 → 0.7.1

package/src/services/commands/doctor.ts

@@ -1,287 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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 }