@reliverse/dler 1.6.2 → 1.6.4

package/README.md

@@ -150,6 +150,52 @@ bun tools:agg # shortcut for:
 bun src/cli.ts tools --dev --tool agg --input src/libs/sdk/sdk-impl --out src/libs/sdk/sdk-mod.ts --recursive --named --strip src/libs/sdk
 ```
 
+### 1.5. `check`
+
+checks your project for common issues and potential improvements. This command performs several types of checks:
+
+- **File Extensions**: Validates that files have the correct extensions based on their location and module resolution strategy
+  - Enforces `.ts` files in source and JSR distributions
+  - Enforces `.js` files in NPM distributions
+  - Supports `.css` and `.json` files in all environments
+  - Adapts to your module resolution strategy (bundler/nodenext)
+
+- **Path Extensions**: Ensures import statements use the correct file extensions
+  - Validates import paths match your module resolution strategy
+  - Checks for proper extension usage in import statements
+  - Supports both relative and absolute imports
+
+- **Dependencies**: Identifies missing dependencies in your project
+  - Scans all source files for imports
+  - Compares against package.json
+  - Reports missing dependencies
+
+```bash
+# Fully interactive mode (when no args provided)
+dler check
+
+# Mixed mode (some args provided, prompts for the rest)
+dler check --directory src
+dler check --checks file-extensions,path-extensions
+dler check --strict
+
+# Fully automated mode (all args provided)
+dler check --directory src --checks file-extensions,path-extensions --strict
+
+# Output in JSON format
+dler check --json
+```
+
+**arguments:**
+
+- `--directory`: directory to check (src, dist-npm, dist-jsr, dist-libs/npm, dist-libs/jsr, or all)
+- `--checks`: comma-separated list of checks to run (missing-dependencies, file-extensions, path-extensions)
+- `--strict`: enable strict mode (requires explicit extensions)
+- `--json`: output results in JSON format
+
+**pro tip:**  
+the command will prompt you only for the arguments you haven't provided. for example, if you specify `--directory` but not `--checks`, it will only prompt you to select which checks to run.
+
 ### 2. `build`
 
 since dler is fully modular, build command is separated for its own build-in plugin as well.
@@ -164,7 +210,7 @@ not yet documented.
 
 ### 4. `deps`
 
-finds missing dependencies in your project by scanning your code for imports and comparing them to your `package.json`.
+finds missing dependencies in your project by scanning your code for imports and comparing them to your `package.json`. This command is particularly useful for maintaining clean dependency lists and preventing runtime errors.
 
 **what it does:**
 
@@ -179,6 +225,7 @@ finds missing dependencies in your project by scanning your code for imports and
 - can also show all used dependencies (listed and missing)
 - optionally includes node.js built-in modules in the report
 - outputs results in a readable format or as json
+- exits with error code 1 if missing dependencies are found
 
 **usage examples:**
 

package/bin/app/agg/cmd.d.ts

@@ -34,7 +34,6 @@ declare const _default: import("@reliverse/rempts").Command<{
     sort: {
         description: string;
         type: "boolean";
-        default: false;
     };
     header: {
         description: string;
@@ -43,12 +42,10 @@ declare const _default: import("@reliverse/rempts").Command<{
     verbose: {
         description: string;
         type: "boolean";
-        default: false;
     };
     includeInternal: {
         description: string;
         type: "boolean";
-        default: false;
     };
     internalMarker: {
         description: string;
@@ -58,7 +55,6 @@ declare const _default: import("@reliverse/rempts").Command<{
     override: {
         description: string;
         type: "boolean";
-        default: false;
     };
     extensions: {
         description: string;
@@ -68,12 +64,10 @@ declare const _default: import("@reliverse/rempts").Command<{
     separateTypesFile: {
         description: string;
         type: "boolean";
-        default: false;
     };
     typesOut: {
         description: string;
         type: "string";
-        required: false;
     };
 }>;
 export default _default;

package/bin/app/agg/cmd.js

@@ -37,8 +37,7 @@ export default defineCommand({
     },
     sort: {
       description: "Sort aggregated lines alphabetically",
-      type: "boolean",
-      default: false
+      type: "boolean"
     },
     header: {
       description: "Add a header comment to the aggregator output",
@@ -46,13 +45,11 @@ export default defineCommand({
     },
     verbose: {
       description: "Enable verbose logging",
-      type: "boolean",
-      default: false
+      type: "boolean"
     },
     includeInternal: {
       description: "Include files marked as internal (starting with #)",
-      type: "boolean",
-      default: false
+      type: "boolean"
     },
     internalMarker: {
       description: "Marker for internal files (default: #)",
@@ -61,8 +58,7 @@ export default defineCommand({
     },
     override: {
       description: "Override entire file instead of updating only the aggregator block",
-      type: "boolean",
-      default: false
+      type: "boolean"
     },
     extensions: {
       description: "Comma-separated list of file extensions to process (default: .ts,.js,.mts,.cts,.mjs,.cjs)",
@@ -71,13 +67,11 @@ export default defineCommand({
     },
     separateTypesFile: {
       description: "Create a separate file for type exports",
-      type: "boolean",
-      default: false
+      type: "boolean"
     },
     typesOut: {
       description: "Output file path for types (used when separateTypesFile is true)",
-      type: "string",
-      required: false
+      type: "string"
     }
   }),
   async run({ args }) {

package/bin/app/check/cmd.d.ts

@@ -1,7 +1,21 @@
+import type { CheckResult, FileCheckOptions } from "../../libs/sdk/sdk-types.js";
+export declare function checkFileExtensions(options: FileCheckOptions): Promise<CheckResult>;
+export declare function checkPathExtensions(options: FileCheckOptions): Promise<CheckResult>;
 declare const _default: import("@reliverse/rempts").Command<{
-    exampleArg: {
+    directory: {
         type: "string";
-        default: string;
+        description: string;
+    };
+    checks: {
+        type: "string";
+        description: string;
+    };
+    strict: {
+        type: "boolean";
+        description: string;
+    };
+    json: {
+        type: "boolean";
         description: string;
     };
 }>;

package/bin/app/check/cmd.js

@@ -1,19 +1,496 @@
-import { defineCommand, defineArgs } from "@reliverse/rempts";
+import { getFileImportsExports, extname, join } from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import {
+  defineCommand,
+  selectPrompt,
+  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",
-      default: "defaultValue",
-      description: "An example argument"
+      description: "directory to check (src, dist-npm, dist-jsr, dist-libs/npm, dist-libs/jsr, or all)"
+    },
+    checks: {
+      type: "string",
+      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 }) {
-    console.log("Command 'check' executed.");
-    console.log("Received args:", args);
+    relinka(
+      "info",
+      "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!");
   }
 });