#!/usr/bin/env node import * as NodeRuntime from "@effect/platform-node/NodeRuntime";import * as NodeServices from "@effect/platform-node/NodeServices";import { isCommandAvailable, resolveSpawnCommand } from "@t3tools/shared/shell";import * as Console from "effect/Console";import * as Data from "effect/Data";import * as Effect from "effect/Effect";import * as FileSystem from "effect/FileSystem";import * as Logger from "effect/Logger";import * as Path from "effect/Path";import * as PlatformError from "effect/PlatformError";import { Command } from "effect/unstable/cli";import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"; interface NativeStaticTool {  readonly command: string;  readonly installHint: string;} class NativeStaticCheckError extends Data.TaggedError("NativeStaticCheckError")<{  readonly message: string;}> {} const tools = [  {    command: "swiftlint",    installHint: "brew install swiftlint",  },  {    command: "ktlint",    installHint: "brew install ktlint",  },  {    command: "detekt",    installHint: "brew install detekt",  },] as const satisfies ReadonlyArray<NativeStaticTool>; const sourceExtensions = new Set([".swift", ".kt", ".kts"]);const excludedDirectories = new Set([  ".expo",  ".git",  "build",  "DerivedData",  "node_modules",  "Pods",  "Vendor",]);const generatedNativeProjectDirectories = new Set(["android", "ios"]); const appRoot = Effect.service(Path.Path).pipe(  Effect.flatMap((path) => path.fromFileUrl(new URL("../apps/mobile", import.meta.url))),); const commandOutputOptions = {  stdout: "inherit",  stderr: "inherit",} as const; const commandExists = Effect.fn("commandExists")(function* (command: string) {  return yield* isCommandAvailable(command);}); const warnMissingTool = (tool: NativeStaticTool, checkName: string) =>  Effect.logWarning(    `${tool.command} is not installed; skipping ${checkName}. Install it with '${tool.installHint}' or run 'brew bundle install --file apps/mobile/Brewfile'.`,  ); const runCommand = Effect.fn("runCommand")(function* (  command: string,  args: ReadonlyArray<string>,  cwd: string,) {  yield* Console.log(`$ ${[command, ...args].join(" ")}`);  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;  const spawnCommand = yield* resolveSpawnCommand(command, args);  const child = yield* spawner.spawn(    ChildProcess.make(spawnCommand.command, spawnCommand.args, {      cwd,      ...commandOutputOptions,      shell: spawnCommand.shell,    }),  );  const exitCode = Number(yield* child.exitCode);   if (exitCode !== 0) {    return yield* new NativeStaticCheckError({      message: `Command exited with non-zero exit code (${exitCode})`,    });  }}); function collectSources(  directory: string,  root: string,): Effect.Effect<  ReadonlyArray<string>,  PlatformError.PlatformError,  FileSystem.FileSystem | Path.Path> {  return Effect.gen(function* () {    const fs = yield* FileSystem.FileSystem;    const path = yield* Path.Path;    const entries = yield* fs.readDirectory(directory);    const sources: Array<string> = [];     for (const entry of entries) {      const entryPath = path.join(directory, entry);      const stat = yield* fs.stat(entryPath);       if (stat.type === "Directory") {        const isGeneratedNativeProjectDirectory =          directory === root && generatedNativeProjectDirectories.has(entry);         if (excludedDirectories.has(entry) || isGeneratedNativeProjectDirectory) {          continue;        }         sources.push(...(yield* collectSources(entryPath, root)));        continue;      }       if (stat.type === "File" && sourceExtensions.has(path.extname(entry))) {        sources.push(entryPath);      }    }     return sources;  });} const runNativeStaticChecks = Effect.fn("runNativeStaticChecks")(function* () {  const path = yield* Path.Path;  const root = yield* appRoot;  const sources = yield* collectSources(root, root);  const swiftSources = sources.filter((source) => path.extname(source) === ".swift");  const kotlinSources = sources.filter((source) => {    const extension = path.extname(source);    return extension === ".kt" || extension === ".kts";  });  const availableTools = new Map<string, boolean>();   for (const tool of tools) {    availableTools.set(tool.command, yield* commandExists(tool.command));  }   yield* Console.log(    `Found ${swiftSources.length} Swift and ${kotlinSources.length} Kotlin native source files.`,  );   if (swiftSources.length > 0) {    if (availableTools.get("swiftlint")) {      yield* runCommand("swiftlint", ["lint", "--config", ".swiftlint.yml", "--strict"], root);    } else {      yield* warnMissingTool(tools[0], "SwiftLint");    }  }   if (kotlinSources.length > 0) {    const relativeKotlinSources = kotlinSources.map((source) => path.relative(root, source));     if (availableTools.get("ktlint")) {      yield* runCommand("ktlint", relativeKotlinSources, root);    } else {      yield* warnMissingTool(tools[1], "ktlint");    }     if (availableTools.get("detekt")) {      yield* runCommand(        "detekt",        [          "--config",          "detekt.yml",          "--input",          relativeKotlinSources.join(","),          "--build-upon-default-config",        ],        root,      );    } else {      yield* warnMissingTool(tools[2], "detekt");    }  }   yield* Console.log("Skipping generated native project folders: android/, ios/.");}); export const mobileNativeStaticCheckCommand = Command.make("mobile-native-static-check", {}, () =>  runNativeStaticChecks(),).pipe(  Command.withDescription("Run mobile native static analysis when native tools are available."),); if (import.meta.main) {  Command.run(mobileNativeStaticCheckCommand, { version: "0.0.0" }).pipe(    Effect.scoped,    Effect.provide([Logger.layer([Logger.consolePretty()]), NodeServices.layer]),    NodeRuntime.runMain,  );}