@reliverse/dler 1.6.3 → 1.6.4

package/bin/app/check/cmd.js

@@ -1,44 +1,496 @@
+import { getFileImportsExports, extname, join } from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
 import {
   defineCommand,
-  defineArgs,
   selectPrompt,
-  multiselectPrompt
+  multiselectPrompt,
+  confirmPrompt,
+  defineArgs
 } from "@reliverse/rempts";
+import { readTSConfig } from "pkg-types";
+import { checkMissingDependencies } from "../deps/impl/wrapper.js";
+import { IGNORE_PATTERNS } from "../../libs/sdk/sdk-impl/constants.js";
+const ALLOWED_FILE_EXTENSIONS = {
+  src: ["", ".ts", ".css", ".json"],
+  // ✅ .ts files allowed in src
+  "dist-npm": ["", ".js", ".css", ".json"],
+  // ❌ no .ts files in npm dist
+  "dist-jsr": ["", ".ts", ".css", ".json"],
+  // ✅ .ts files allowed in jsr dist
+  "dist-libs/npm": ["", ".js", ".css", ".json"],
+  // ❌ no .ts files in npm libs
+  "dist-libs/jsr": ["", ".ts", ".css", ".json"]
+  // ✅ .ts files allowed in jsr libs
+};
+const STRICT_FILE_EXTENSIONS = {
+  src: [".ts", ".css", ".json"],
+  // ✅ .ts files required in src
+  "dist-npm": [".js", ".css", ".json"],
+  // ❌ no .ts files in npm dist
+  "dist-jsr": [".ts", ".css", ".json"],
+  // ✅ .ts files required in jsr dist
+  "dist-libs/npm": [".js", ".css", ".json"],
+  // ❌ no .ts files in npm libs
+  "dist-libs/jsr": [".ts", ".css", ".json"]
+  // ✅ .ts files required in jsr libs
+};
+const ALLOWED_IMPORT_EXTENSIONS = {
+  src: ["", ".js", ".css", ".json"],
+  // ❌ no .ts imports (use .js)
+  "dist-npm": ["", ".js", ".css", ".json"],
+  // ❌ no .ts imports
+  "dist-jsr": ["", ".ts", ".css", ".json"],
+  // ✅ .ts imports allowed
+  "dist-libs/npm": ["", ".js", ".css", ".json"],
+  // ❌ no .ts imports
+  "dist-libs/jsr": ["", ".ts", ".css", ".json"]
+  // ✅ .ts imports allowed
+};
+const STRICT_IMPORT_EXTENSIONS = {
+  src: [".js", ".css", ".json"],
+  // ❌ no .ts imports, no empty
+  "dist-npm": [".js", ".css", ".json"],
+  // ❌ no .ts imports
+  "dist-jsr": [".ts", ".css", ".json"],
+  // ✅ .ts imports required
+  "dist-libs/npm": [".js", ".css", ".json"],
+  // ❌ no .ts imports
+  "dist-libs/jsr": [".ts", ".css", ".json"]
+  // ✅ .ts imports required
+};
+async function validateDirectory(dir) {
+  try {
+    const stat = await fs.stat(dir);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function shouldIgnoreFile(filePath) {
+  const pathSegments = filePath.split("/");
+  return IGNORE_PATTERNS.some(
+    (pattern) => pathSegments.some((segment) => segment.includes(pattern))
+  );
+}
+async function getAllFiles(dir, onProgress) {
+  const results = [];
+  let fileCount = 0;
+  async function searchDirectory(directory) {
+    try {
+      const files = await fs.readdir(directory);
+      for (const file of files) {
+        const fullPath = join(directory, file);
+        if (shouldIgnoreFile(fullPath)) {
+          continue;
+        }
+        try {
+          const stat = await fs.stat(fullPath);
+          if (stat.isDirectory()) {
+            if (file === "templates") continue;
+            await searchDirectory(fullPath);
+          } else {
+            results.push(fullPath);
+            fileCount++;
+            onProgress?.(fileCount, fileCount, fullPath);
+          }
+        } catch {
+          relinka("warn", `skipping inaccessible file: ${fullPath}`);
+        }
+      }
+    } catch {
+      relinka("warn", `skipping inaccessible directory: ${directory}`);
+    }
+  }
+  if (!await validateDirectory(dir)) {
+    throw new Error(`directory "${dir}" does not exist or is not accessible`);
+  }
+  await searchDirectory(dir);
+  return results;
+}
+async function validateModuleResolution() {
+  try {
+    const tsconfig = await readTSConfig();
+    const moduleResolution = tsconfig?.compilerOptions?.moduleResolution;
+    if (!moduleResolution) {
+      throw new Error("moduleResolution is not specified in tsconfig.json");
+    }
+    if (moduleResolution !== "bundler" && moduleResolution !== "nodenext") {
+      throw new Error(
+        `unsupported moduleResolution: ${moduleResolution}. Only "bundler" and "nodenext" are supported`
+      );
+    }
+    return moduleResolution;
+  } catch (error) {
+    throw new Error(
+      `failed to read tsconfig.json: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+function getAllowedFileExtensions(directory, strict, moduleResolution) {
+  if (!strict) {
+    return ALLOWED_FILE_EXTENSIONS[directory];
+  }
+  if (moduleResolution === "bundler") {
+    return STRICT_FILE_EXTENSIONS[directory];
+  }
+  return STRICT_FILE_EXTENSIONS[directory];
+}
+function getAllowedImportExtensions(directory, strict) {
+  if (strict) {
+    return STRICT_IMPORT_EXTENSIONS[directory];
+  }
+  return ALLOWED_IMPORT_EXTENSIONS[directory];
+}
+export async function checkFileExtensions(options) {
+  const startTime = Date.now();
+  const issues = [];
+  const { directory, strict, moduleResolution, onProgress } = options;
+  const allowedExts = getAllowedFileExtensions(
+    directory,
+    strict,
+    moduleResolution
+  );
+  try {
+    const files = await getAllFiles(directory, onProgress);
+    const batchSize = 50;
+    const batches = [];
+    for (let i = 0; i < files.length; i += batchSize) {
+      batches.push(files.slice(i, i + batchSize));
+    }
+    for (const [batchIndex, batch] of batches.entries()) {
+      const batchPromises = batch.map(async (file, fileIndex) => {
+        const globalIndex = batchIndex * batchSize + fileIndex;
+        onProgress?.(globalIndex + 1, files.length, file);
+        const ext = extname(file);
+        if (!allowedExts.includes(ext)) {
+          let message = `file has disallowed extension "${ext}" (allowed: ${allowedExts.join(", ")})`;
+          if (ext === ".ts" && (directory === "dist-npm" || directory === "dist-libs/npm")) {
+            message = `typescript file found in javascript environment: ${file} (should be compiled to .js)`;
+          } else if (ext === ".js" && (directory === "src" || directory === "dist-jsr" || directory === "dist-libs/jsr")) {
+            message = `javascript file found in typescript environment: ${file} (should be .ts)`;
+          }
+          return {
+            file,
+            message,
+            type: "file-extension"
+          };
+        }
+        return null;
+      });
+      const batchResults = await Promise.all(batchPromises);
+      issues.push(...batchResults.filter(Boolean));
+    }
+    return {
+      success: issues.length === 0,
+      issues,
+      stats: {
+        filesChecked: files.length,
+        importsChecked: 0,
+        timeElapsed: Date.now() - startTime
+      }
+    };
+  } catch (error) {
+    throw new Error(
+      `failed to check file extensions: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+export async function checkPathExtensions(options) {
+  const startTime = Date.now();
+  const issues = [];
+  const { directory, strict, onProgress } = options;
+  const allowedExts = getAllowedImportExtensions(directory, strict);
+  try {
+    const files = await getAllFiles(directory);
+    let totalImports = 0;
+    const importableFiles = files.filter((file) => {
+      const ext = extname(file);
+      return [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext);
+    });
+    const batchSize = 20;
+    const batches = [];
+    for (let i = 0; i < importableFiles.length; i += batchSize) {
+      batches.push(importableFiles.slice(i, i + batchSize));
+    }
+    for (const [batchIndex, batch] of batches.entries()) {
+      const batchPromises = batch.map(async (file, fileIndex) => {
+        const globalIndex = batchIndex * batchSize + fileIndex;
+        onProgress?.(globalIndex + 1, importableFiles.length, file);
+        try {
+          const content = await fs.readFile(file, "utf-8");
+          const imports = getFileImportsExports(content, {
+            kind: "import",
+            pathTypes: ["relative", "alias"]
+          });
+          totalImports += imports.length;
+          const fileIssues = [];
+          for (const imp of imports) {
+            if (!imp.source) continue;
+            const ext = extname(imp.source);
+            if (!allowedExts.includes(ext)) {
+              const isTypeScriptImport = ext === ".ts";
+              const isJsEnvironment = directory === "src" || directory === "dist-npm" || directory === "dist-libs/npm";
+              let message;
+              if (isTypeScriptImport && isJsEnvironment) {
+                message = `import uses .ts extension in javascript environment: ${imp.source} (use .js extension instead)`;
+              } else {
+                message = `import has disallowed extension "${ext}": ${imp.source} (allowed: ${allowedExts.join(", ")})`;
+              }
+              fileIssues.push({
+                file,
+                message,
+                type: "path-extension",
+                line: getLineNumber(content, imp.start),
+                source: imp.source
+              });
+            }
+          }
+          return { issues: fileIssues, importCount: imports.length };
+        } catch {
+          relinka("warn", `skipping unreadable file: ${file}`);
+          return { issues: [], importCount: 0 };
+        }
+      });
+      const batchResults = await Promise.all(batchPromises);
+      for (const result of batchResults) {
+        issues.push(...result.issues);
+        totalImports += result.importCount;
+      }
+    }
+    return {
+      success: issues.length === 0,
+      issues,
+      stats: {
+        filesChecked: importableFiles.length,
+        importsChecked: totalImports,
+        timeElapsed: Date.now() - startTime
+      }
+    };
+  } catch (error) {
+    throw new Error(
+      `failed to check path extensions: ${error instanceof Error ? error.message : "unknown error"}`
+    );
+  }
+}
+function getLineNumber(content, position) {
+  return content.slice(0, position).split("\n").length;
+}
+function displayResults(checkType, directory, result) {
+  const { success, issues, stats } = result;
+  if (success) {
+    relinka("success", `\u2713 ${checkType} check passed for ${directory}`);
+    relinka(
+      "info",
+      `  files checked: ${stats.filesChecked}, imports: ${stats.importsChecked}, time: ${stats.timeElapsed}ms`
+    );
+  } else {
+    relinka(
+      "error",
+      `\u2717 ${checkType} check failed for ${directory} (${issues.length} issues)`
+    );
+    const fileIssues = issues.filter((i) => i.type === "file-extension");
+    const pathIssues = issues.filter((i) => i.type === "path-extension");
+    const missingDepIssues = issues.filter(
+      (i) => i.type === "missing-dependency"
+    );
+    const builtinIssues = issues.filter((i) => i.type === "builtin-module");
+    if (fileIssues.length > 0) {
+      relinka("error", `  file extension issues (${fileIssues.length}):`);
+      for (const issue of fileIssues.slice(0, 10)) {
+        relinka("error", `    ${issue.file}: ${issue.message}`);
+      }
+      if (fileIssues.length > 10) {
+        relinka("error", `    ... and ${fileIssues.length - 10} more`);
+      }
+    }
+    if (pathIssues.length > 0) {
+      relinka("error", `  import extension issues (${pathIssues.length}):`);
+      for (const issue of pathIssues.slice(0, 10)) {
+        relinka("error", `    ${issue.file}:${issue.line}: ${issue.message}`);
+      }
+      if (pathIssues.length > 10) {
+        relinka("error", `    ... and ${pathIssues.length - 10} more`);
+      }
+    }
+    if (missingDepIssues.length > 0) {
+      relinka("error", `  missing dependencies (${missingDepIssues.length}):`);
+      for (const issue of missingDepIssues.slice(0, 10)) {
+        relinka("error", `    ${issue.message}`);
+      }
+      if (missingDepIssues.length > 10) {
+        relinka("error", `    ... and ${missingDepIssues.length - 10} more`);
+      }
+    }
+    if (builtinIssues.length > 0) {
+      relinka("warn", `  builtin modules used (${builtinIssues.length}):`);
+      for (const issue of builtinIssues.slice(0, 10)) {
+        relinka("warn", `    ${issue.message}`);
+      }
+      if (builtinIssues.length > 10) {
+        relinka("warn", `    ... and ${builtinIssues.length - 10} more`);
+      }
+    }
+    relinka(
+      "info",
+      `  stats: ${stats.filesChecked} files, ${stats.importsChecked} imports, ${stats.timeElapsed}ms`
+    );
+  }
+}
 export default defineCommand({
   meta: {
     name: "check",
     version: "1.0.0",
-    description: "Describe what check command does."
+    description: "check your codebase source and dists for any issues."
   },
   args: defineArgs({
-    exampleArg: {
+    directory: {
+      type: "string",
+      description: "directory to check (src, dist-npm, dist-jsr, dist-libs/npm, dist-libs/jsr, or all)"
+    },
+    checks: {
       type: "string",
-      default: "defaultValue",
-      description: "An example argument"
+      description: "comma-separated list of checks to run (missing-dependencies,file-extensions,path-extensions)"
+    },
+    strict: {
+      type: "boolean",
+      description: "enable strict mode (requires explicit extensions)"
+    },
+    json: {
+      type: "boolean",
+      description: "output results in JSON format"
     }
   }),
   async run({ args }) {
     relinka(
       "info",
-      "This command allows you to check your codebase source and dists for any issues."
-    );
-    const dir = await selectPrompt({
-      title: "Select a directory to check",
-      options: [
-        { label: "all", value: "all" },
-        { label: "src", value: "src" },
-        { label: "dist-npm", value: "dist-npm" },
-        { label: "dist-jsr", value: "dist-jsr" },
-        { label: "dist-libs-npm", value: "dist-libs-npm" },
-        { label: "dist-libs-jsr", value: "dist-libs-jsr" }
-      ]
-    });
-    const checks = await multiselectPrompt({
-      title: "Select checks to run",
-      options: [
-        { label: "path-extensions", value: "path-extensions" }
-      ]
-    });
+      "this command checks your codebase for extension and dependency issues."
+    );
+    relinka(
+      "info",
+      "\u{1F4C1} file rules: .ts files allowed in src/jsr dirs, .js files in npm dirs"
+    );
+    relinka(
+      "info",
+      "\u{1F4E6} import rules: use .js imports in src/npm dirs, .ts imports in jsr dirs"
+    );
+    let moduleResolution;
+    try {
+      moduleResolution = await validateModuleResolution();
+      relinka("info", `using moduleResolution: ${moduleResolution}`);
+    } catch (error) {
+      relinka(
+        "error",
+        error instanceof Error ? error.message : "unknown error"
+      );
+      return;
+    }
+    let dir;
+    let checks;
+    let strict;
+    if (args.directory) {
+      dir = args.directory;
+    } else {
+      dir = await selectPrompt({
+        title: "select a directory to check",
+        options: [
+          { label: "all directories", value: "all" },
+          { label: "src (typescript source)", value: "src" },
+          { label: "dist-npm (compiled js)", value: "dist-npm" },
+          { label: "dist-jsr (typescript)", value: "dist-jsr" },
+          { label: "dist-libs/npm (compiled js)", value: "dist-libs/npm" },
+          { label: "dist-libs/jsr (typescript)", value: "dist-libs/jsr" }
+        ]
+      });
+    }
+    if (args.checks) {
+      checks = args.checks.split(",");
+    } else {
+      checks = await multiselectPrompt({
+        title: "select checks to run",
+        options: [
+          { label: "missing dependencies", value: "missing-dependencies" },
+          {
+            label: "file extensions (.ts/.js files)",
+            value: "file-extensions"
+          },
+          {
+            label: "import path extensions (.ts/.js imports)",
+            value: "path-extensions"
+          }
+        ]
+      });
+    }
+    if (args.strict !== void 0) {
+      strict = args.strict;
+    } else {
+      strict = await confirmPrompt({
+        title: "activate strict mode?",
+        content: "strict mode requires explicit extensions (no empty extensions). files: .ts in src/jsr dirs, .js in npm dirs. imports: .js in src/npm dirs, .ts in jsr dirs. templates folder is always exempt."
+      });
+    }
+    if (checks.length === 0) {
+      relinka("warn", "no checks selected, exiting...");
+      return;
+    }
+    const directories = dir === "all" ? [
+      "src",
+      "dist-npm",
+      "dist-jsr",
+      "dist-libs/npm",
+      "dist-libs/jsr"
+    ] : [dir];
+    for (const directory of directories) {
+      relinka("info", `
+checking directory: ${directory}`);
+      const onProgress = (current, total) => {
+        if (current % 10 === 0 || current === total) {
+          process.stdout.write(`\r  progress: ${current}/${total} files...`);
+        }
+      };
+      try {
+        if (checks.includes("missing-dependencies")) {
+          process.stdout.write("  checking missing dependencies...\n");
+          const result = await checkMissingDependencies({
+            directory,
+            strict: false,
+            // not used for deps check
+            moduleResolution,
+            // not used for deps check
+            onProgress
+          });
+          process.stdout.write("\r");
+          displayResults("missing dependencies", directory, result);
+        }
+        if (checks.includes("file-extensions")) {
+          process.stdout.write("  checking file extensions...\n");
+          const result = await checkFileExtensions({
+            directory,
+            strict,
+            moduleResolution,
+            onProgress
+          });
+          process.stdout.write("\r");
+          displayResults("file extensions", directory, result);
+        }
+        if (checks.includes("path-extensions")) {
+          process.stdout.write("  checking import path extensions...\n");
+          const result = await checkPathExtensions({
+            directory,
+            strict,
+            moduleResolution,
+            onProgress
+          });
+          process.stdout.write("\r");
+          displayResults("path extensions", directory, result);
+        }
+      } catch (error) {
+        relinka(
+          "error",
+          `failed to check ${directory}: ${error instanceof Error ? error.message : "unknown error"}`
+        );
+      }
+    }
+    relinka("success", "all checks completed!");
   }
 });