@reliverse/dler 2.3.3 → 2.3.4

package/dist/cmds/tsc/cache.js

@@ -1,34 +1,31 @@
 import { existsSync, statSync } from "node:fs";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { loadCache, saveCache } from "../../utils/cache.js";
 const CACHE_VERSION = "1.0.0";
-const DEFAULT_CACHE_DIR = "node_modules/.cache/dler-tsc";
 const DEFAULT_MAX_AGE = 24 * 60 * 60 * 1e3;
 export class TscCache {
   options;
   metadata = null;
-  metadataPath;
   constructor(options = {}) {
     this.options = {
       enabled: options.enabled ?? true,
-      cacheDir: options.cacheDir ?? DEFAULT_CACHE_DIR,
+      cacheDir: options.cacheDir ?? "node_modules/.cache/dler",
       maxAge: options.maxAge ?? DEFAULT_MAX_AGE
     };
-    this.metadataPath = join(this.options.cacheDir, "metadata.json");
   }
   async initialize() {
     if (!this.options.enabled) {
       return;
     }
     try {
-      await mkdir(this.options.cacheDir, { recursive: true });
       await this.loadMetadata();
     } catch {
       this.options.enabled = false;
     }
   }
   async loadMetadata() {
-    if (!existsSync(this.metadataPath)) {
+    const cachedMetadata = await loadCache("tsc");
+    if (!cachedMetadata) {
       this.metadata = {
         version: CACHE_VERSION,
         lastUpdated: Date.now(),
@@ -36,22 +33,14 @@ export class TscCache {
       };
       return;
     }
-    try {
-      const content = await readFile(this.metadataPath, "utf-8");
-      this.metadata = JSON.parse(content);
-      if (Date.now() - this.metadata.lastUpdated > this.options.maxAge) {
-        this.metadata = {
-          version: CACHE_VERSION,
-          lastUpdated: Date.now(),
-          packages: {}
-        };
-      }
-    } catch {
+    if (Date.now() - cachedMetadata.lastUpdated > this.options.maxAge) {
       this.metadata = {
         version: CACHE_VERSION,
         lastUpdated: Date.now(),
         packages: {}
       };
+    } else {
+      this.metadata = cachedMetadata;
     }
   }
   async saveMetadata() {
@@ -60,7 +49,7 @@ export class TscCache {
     }
     try {
       this.metadata.lastUpdated = Date.now();
-      await writeFile(this.metadataPath, JSON.stringify(this.metadata, null, 2), "utf-8");
+      await saveCache("tsc", this.metadata);
     } catch {
     }
   }

package/dist/cmds/tsc/impl.js

@@ -466,14 +466,11 @@ const collectAllResults = async (packages, monorepoRoot, options = {}, cache) =>
     incremental = true,
     buildMode = false
   } = options;
-  if (!verbose) {
-    logger.info(`Processing ${packages.length} packages...`);
-  }
   try {
     const tscResults = await pMap(
       packages,
       async (pkg, index) => {
-        if (!verbose) {
+        if (verbose) {
           logger.info(`Processing ${pkg.name} (${index + 1}/${packages.length})...`);
         }
         return runTscOnPackage(pkg, monorepoRoot, {
@@ -675,8 +672,7 @@ export const runTscOnAllPackages = async (ignore, cwd, options = {}) => {
     }
     const { stopOnError = false } = options;
     logger.info(
-      `   Checking ${packages.length} packages (concurrency: ${concurrency}, stopOnError: ${stopOnError})...
-`
+      `Checking ${packages.length} packages (concurrency: ${concurrency}, stopOnError: ${stopOnError})...`
     );
     if (verbose) {
       logger.info("\u{1F680} Starting TypeScript checks...\n");

package/dist/cmds/unused/cmd.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/cmds/unused/cmd.js

@@ -0,0 +1,105 @@
+import { logger } from "@reliverse/relinka";
+import { defineCommand, option } from "@reliverse/rempts-core";
+import { type } from "arktype";
+import { findUnusedDependencies } from "./impl.js";
+export default defineCommand({
+  description: "Find unused dependencies in package.json files",
+  options: {
+    // Target package selection
+    target: option(type("string | undefined"), {
+      short: "t",
+      description: "Target workspace package(s) (from workspaces.packages). Use '.' for current directory package. Supports multiple packages (space-separated) and glob patterns."
+    }),
+    package: option(type("string | undefined"), {
+      description: "Target workspace package(s) (alias for --target). Use '.' for current directory package. Supports multiple packages (space-separated) and glob patterns."
+    }),
+    pkg: option(type("string | undefined"), {
+      description: "Target workspace package(s) (alias for --target). Use '.' for current directory package. Supports multiple packages (space-separated) and glob patterns."
+    }),
+    w: option(type("boolean | undefined"), {
+      description: "Check unused dependencies in root package.json"
+    }),
+    // Scope filtering
+    scope: option(type("'dev'|'prod'|'peer'|'optional' | undefined"), {
+      short: "s",
+      description: "Check specific dependency scope: dev, prod, peer, optional. If not specified, checks all scopes."
+    }),
+    dev: option(type("boolean | undefined"), {
+      short: "D",
+      description: "Check only devDependencies (shorthand for --scope dev)"
+    }),
+    prod: option(type("boolean | undefined"), {
+      short: "P",
+      description: "Check only dependencies (shorthand for --scope prod)"
+    }),
+    peer: option(type("boolean | undefined"), {
+      short: "R",
+      description: "Check only peerDependencies (shorthand for --scope peer)"
+    }),
+    optional: option(type("boolean | undefined"), {
+      short: "O",
+      description: "Check only optionalDependencies (shorthand for --scope optional)"
+    }),
+    // Analysis options
+    ignore: option(type("string | undefined"), {
+      short: "i",
+      description: "Comma-separated list of package names to ignore when checking for unused dependencies"
+    }),
+    includePeer: option(type("boolean | undefined"), {
+      description: "Include peerDependencies in the analysis (default: false)",
+      default: false
+    }),
+    // Other options
+    cwd: option(type("string | undefined"), {
+      description: "Working directory (monorepo root)"
+    }),
+    verbose: option(type("boolean | undefined"), {
+      short: "v",
+      description: "Verbose output"
+    })
+  },
+  handler: async ({ flags }) => {
+    try {
+      if (typeof process.versions.bun === "undefined") {
+        logger.error("\u274C This command requires Bun runtime.");
+        logger.error("Please run this command using Bun: bun dler unused");
+        process.exit(1);
+      }
+      logger.log("\u{1F50D} Finding unused dependencies...");
+      let scope;
+      if (flags.scope) {
+        scope = flags.scope;
+      } else if (flags.dev) {
+        scope = "dev";
+      } else if (flags.peer) {
+        scope = "peer";
+      } else if (flags.optional) {
+        scope = "optional";
+      }
+      const ignoreList = flags.ignore ? flags.ignore.split(",").map((pkg) => pkg.trim()).filter(Boolean) : void 0;
+      const options = {
+        target: flags.target || flags.package || flags.pkg,
+        w: flags.w,
+        scope,
+        ignore: ignoreList,
+        includePeer: flags.includePeer ?? false,
+        cwd: flags.cwd || void 0,
+        verbose: flags.verbose ?? false
+      };
+      await findUnusedDependencies(options);
+    } catch (error) {
+      logger.error("\n\u274C Failed to find unused dependencies:");
+      if (error instanceof Error) {
+        logger.error(error.message);
+      } else {
+        logger.error(String(error));
+      }
+      logger.log("");
+      logger.log("\u{1F4A1} Tips:");
+      logger.log("  \u2022 Ensure you're in a valid project directory with package.json");
+      logger.log("  \u2022 Use --verbose flag for more detailed output");
+      logger.log("  \u2022 Use --ignore flag to exclude specific packages from analysis");
+      process.exit(1);
+    }
+  }
+});

package/dist/cmds/unused/impl.d.ts

@@ -0,0 +1,16 @@
+export interface UnusedOptions {
+    target?: string;
+    w?: boolean;
+    scope?: "dev" | "prod" | "peer" | "optional";
+    ignore?: string[];
+    includePeer: boolean;
+    cwd?: string;
+    verbose: boolean;
+}
+export interface MonorepoInfo {
+    isMonorepo: boolean;
+    rootPath: string;
+    rootPackageJson: any;
+    workspacePackages?: string[];
+}
+export declare function findUnusedDependencies(options: UnusedOptions): Promise<void>;

package/dist/cmds/unused/impl.js

@@ -0,0 +1,415 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { createIncludeFilter } from "@reliverse/matcha";
+import path from "@reliverse/pathkit";
+import { logger } from "@reliverse/relinka";
+import { hasWorkspaces, readPackageJSON } from "@reliverse/typerso";
+const monorepoCache = /* @__PURE__ */ new Map();
+async function detectMonorepo(startDir) {
+  const cwd = resolve(startDir ?? process.cwd());
+  if (monorepoCache.has(cwd)) {
+    return monorepoCache.get(cwd);
+  }
+  let currentDir = cwd;
+  while (true) {
+    const packageJsonPath2 = path.join(currentDir, "package.json");
+    if (existsSync(packageJsonPath2)) {
+      const packageJson2 = await readPackageJSON(currentDir);
+      if (packageJson2 && hasWorkspaces(packageJson2)) {
+        const workspacePackages = await discoverWorkspacePackages(currentDir, packageJson2);
+        const result2 = {
+          isMonorepo: true,
+          rootPath: currentDir,
+          rootPackageJson: packageJson2,
+          workspacePackages
+        };
+        monorepoCache.set(cwd, result2);
+        return result2;
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    throw new Error("No package.json found in current directory or any parent directory");
+  }
+  const packageJson = await readPackageJSON(cwd);
+  if (!packageJson) {
+    throw new Error("Could not read package.json");
+  }
+  const result = {
+    isMonorepo: false,
+    rootPath: cwd,
+    rootPackageJson: packageJson
+  };
+  monorepoCache.set(cwd, result);
+  return result;
+}
+const workspaceCache = /* @__PURE__ */ new Map();
+function hasBiomeConfig(rootPath) {
+  return existsSync(path.join(rootPath, "biome.json")) || existsSync(path.join(rootPath, "biome.jsonc"));
+}
+function hasTurboConfig(rootPath) {
+  return existsSync(path.join(rootPath, "turbo.json"));
+}
+async function discoverWorkspacePackages(monorepoRoot, rootPackageJson) {
+  if (workspaceCache.has(monorepoRoot)) {
+    return workspaceCache.get(monorepoRoot);
+  }
+  const packages = [];
+  if (!rootPackageJson.workspaces?.packages) {
+    workspaceCache.set(monorepoRoot, packages);
+    return packages;
+  }
+  const patterns = Array.isArray(rootPackageJson.workspaces.packages) ? rootPackageJson.workspaces.packages : [];
+  const packagePaths = [];
+  const validationPromises = [];
+  for (const pattern of patterns) {
+    if (pattern.includes("*")) {
+      const glob = new Bun.Glob(pattern);
+      const matches = glob.scanSync({ cwd: monorepoRoot, onlyFiles: false });
+      for (const match of matches) {
+        const packagePath = resolve(monorepoRoot, match);
+        packagePaths.push(packagePath);
+        validationPromises.push(isValidWorkspacePackage(packagePath));
+      }
+    } else {
+      const packagePath = resolve(monorepoRoot, pattern);
+      packagePaths.push(packagePath);
+      validationPromises.push(isValidWorkspacePackage(packagePath));
+    }
+  }
+  const validationResults = await Promise.all(validationPromises);
+  for (let i = 0; i < packagePaths.length; i++) {
+    if (validationResults[i]) {
+      packages.push(packagePaths[i]);
+    }
+  }
+  workspaceCache.set(monorepoRoot, packages);
+  return packages;
+}
+async function isValidWorkspacePackage(packagePath) {
+  const packageJsonPath = path.join(packagePath, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+  const packageJson = await readPackageJSON(packagePath);
+  return !!packageJson?.name;
+}
+function containsGlobPattern(str) {
+  return str.includes("*") || str.includes("?") || str.includes("[") || str.includes("{");
+}
+function containsMultipleTargets(str) {
+  return str.includes(" ") && str.trim().split(/\s+/).length > 1;
+}
+const packageInfoCache = /* @__PURE__ */ new Map();
+async function getPackageInfo(monorepoInfo) {
+  if (packageInfoCache.has(monorepoInfo.rootPath)) {
+    return packageInfoCache.get(monorepoInfo.rootPath);
+  }
+  const packages = [];
+  if (monorepoInfo.isMonorepo) {
+    if (hasDependencies(monorepoInfo.rootPackageJson)) {
+      packages.push({
+        name: monorepoInfo.rootPackageJson.name || "root",
+        path: monorepoInfo.rootPath,
+        json: monorepoInfo.rootPackageJson,
+        packagePath: monorepoInfo.rootPath,
+        packageJson: monorepoInfo.rootPackageJson
+      });
+    }
+    if (monorepoInfo.workspacePackages) {
+      for (const packagePath of monorepoInfo.workspacePackages) {
+        const packageJson = await readPackageJSON(packagePath);
+        if (packageJson && hasDependencies(packageJson)) {
+          packages.push({
+            name: packageJson.name || "unnamed",
+            path: packagePath,
+            json: packageJson,
+            packagePath,
+            packageJson
+          });
+        }
+      }
+    }
+  } else {
+    packages.push({
+      name: monorepoInfo.rootPackageJson.name || "project",
+      path: monorepoInfo.rootPath,
+      json: monorepoInfo.rootPackageJson,
+      packagePath: monorepoInfo.rootPath,
+      packageJson: monorepoInfo.rootPackageJson
+    });
+  }
+  packageInfoCache.set(monorepoInfo.rootPath, packages);
+  return packages;
+}
+function hasDependencies(packageJson) {
+  return !!(packageJson.dependencies || packageJson.devDependencies || packageJson.peerDependencies || packageJson.optionalDependencies);
+}
+async function resolveTargetPackages(monorepoInfo, targetOption, w) {
+  const allPackages = await getPackageInfo(monorepoInfo);
+  if (!(targetOption || w)) {
+    const currentDir = process.cwd();
+    const currentPackage = allPackages.find((pkg) => pkg.path === currentDir);
+    if (currentPackage) {
+      return [currentPackage];
+    }
+    return allPackages;
+  }
+  if (w) {
+    const rootPackage = allPackages.find((pkg) => pkg.path === monorepoInfo.rootPath);
+    return rootPackage ? [rootPackage] : [];
+  }
+  if (targetOption) {
+    if (containsGlobPattern(targetOption) || containsMultipleTargets(targetOption)) {
+      const targets = [];
+      if (containsMultipleTargets(targetOption)) {
+        targets.push(...targetOption.trim().split(/\s+/));
+      } else {
+        targets.push(targetOption);
+      }
+      const matchedPackages = [];
+      const filter = createIncludeFilter(targets);
+      const matchingPackages = filter(allPackages);
+      matchedPackages.push(...matchingPackages);
+      return matchedPackages;
+    } else {
+      const pkg = allPackages.find(
+        (p) => p.name === targetOption || relative(monorepoInfo.rootPath, p.path) === targetOption || p.path === resolve(monorepoInfo.rootPath, targetOption)
+      );
+      return pkg ? [pkg] : [];
+    }
+  }
+  return [];
+}
+function getSourceFiles(packagePath, rootPath) {
+  const files = [];
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+  const skipDirs = ["node_modules", ".git", "dist", "build", ".cache", "coverage", ".turbo"];
+  function scanDir(dir) {
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          if (!skipDirs.includes(entry)) {
+            scanDir(fullPath);
+          }
+        } else if (stat.isFile()) {
+          const ext = path.extname(entry);
+          if (extensions.includes(ext)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch (error) {
+    }
+  }
+  scanDir(packagePath);
+  return files;
+}
+function analyzePackageScripts(packageJson) {
+  const usedPackages = /* @__PURE__ */ new Set();
+  if (packageJson.scripts) {
+    for (const script of Object.values(packageJson.scripts)) {
+      const buildTools = ["biome", "turbo", "ultracite"];
+      for (const tool of buildTools) {
+        if (script.includes(tool)) {
+          if (tool === "biome") {
+            usedPackages.add("@biomejs/biome");
+          } else {
+            usedPackages.add(tool);
+          }
+        }
+      }
+    }
+  }
+  return usedPackages;
+}
+function analyzeSourceFile(filePath, packageJson) {
+  const usedPackages = /* @__PURE__ */ new Set();
+  const packageName = packageJson.name || "";
+  try {
+    const content = require("node:fs").readFileSync(filePath, "utf8");
+    const importPatterns = [
+      // ES6 imports
+      /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g,
+      // Dynamic imports
+      /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+      // Require statements
+      /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+      // TypeScript type imports
+      /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g
+    ];
+    for (const pattern of importPatterns) {
+      let match = pattern.exec(content);
+      while (match !== null) {
+        const importedPackage = match[1];
+        if (!importedPackage) continue;
+        if (!(importedPackage.startsWith(".") || path.extname(importedPackage))) {
+          const basePackage = importedPackage.split("/")[0];
+          if (basePackage && basePackage.startsWith("@")) {
+            const parts = importedPackage.split("/");
+            if (parts.length >= 2) {
+              usedPackages.add(`${parts[0]}/${parts[1]}`);
+            }
+          } else if (basePackage) {
+            usedPackages.add(basePackage);
+          }
+        }
+        match = pattern.exec(content);
+      }
+    }
+    if (content.includes(packageName)) {
+      usedPackages.delete(packageName);
+    }
+  } catch (error) {
+  }
+  return usedPackages;
+}
+function collectAllDependencies(packageJson, scope, includePeer = false) {
+  const allDeps = {};
+  const depTypes = [
+    { key: "dependencies", type: "prod" },
+    { key: "devDependencies", type: "dev" },
+    { key: "peerDependencies", type: "peer" },
+    { key: "optionalDependencies", type: "optional" }
+  ];
+  for (const { key, type } of depTypes) {
+    if (packageJson[key] && (!scope || scope === type)) {
+      if (type === "peer" && !includePeer) {
+        continue;
+      }
+      Object.assign(allDeps, packageJson[key]);
+    }
+  }
+  return allDeps;
+}
+export async function findUnusedDependencies(options) {
+  const monorepoInfo = await detectMonorepo(options.cwd);
+  const targetPackages = await resolveTargetPackages(monorepoInfo, options.target, options.w);
+  if (targetPackages.length === 0) {
+    logger.warn("No packages found to analyze");
+    return;
+  }
+  const hasBiome = hasBiomeConfig(monorepoInfo.rootPath);
+  const hasTurbo = hasTurboConfig(monorepoInfo.rootPath);
+  let totalUnused = 0;
+  const results = [];
+  for (const targetPackage of targetPackages) {
+    if (options.verbose) {
+      logger.log(`Analyzing ${targetPackage.packageJson.name || "unnamed package"}...`);
+    }
+    const sourceFiles = getSourceFiles(targetPackage.packagePath, monorepoInfo.rootPath);
+    const usedPackages = /* @__PURE__ */ new Set();
+    for (const file of sourceFiles) {
+      const fileUsedPackages = analyzeSourceFile(file, targetPackage.packageJson);
+      for (const pkg of fileUsedPackages) {
+        usedPackages.add(pkg);
+      }
+    }
+    const scriptUsedPackages = analyzePackageScripts(targetPackage.packageJson);
+    for (const pkg of scriptUsedPackages) {
+      usedPackages.add(pkg);
+    }
+    if (hasBiome) {
+      usedPackages.add("@biomejs/biome");
+      usedPackages.add("ultracite");
+    }
+    if (hasTurbo) {
+      usedPackages.add("turbo");
+    }
+    const allDeps = collectAllDependencies(
+      targetPackage.packageJson,
+      options.scope,
+      options.includePeer
+    );
+    const unusedDeps = [];
+    for (const [depName, depVersion] of Object.entries(allDeps)) {
+      if (options.ignore?.includes(depName)) {
+        continue;
+      }
+      if (!usedPackages.has(depName)) {
+        let scope = "unknown";
+        if (targetPackage.packageJson.dependencies?.[depName]) {
+          scope = "prod";
+        } else if (targetPackage.packageJson.devDependencies?.[depName]) {
+          scope = "dev";
+        } else if (targetPackage.packageJson.peerDependencies?.[depName]) {
+          scope = "peer";
+        } else if (targetPackage.packageJson.optionalDependencies?.[depName]) {
+          scope = "optional";
+        }
+        unusedDeps.push({
+          name: depName,
+          scope,
+          version: depVersion
+        });
+      }
+    }
+    if (unusedDeps.length > 0) {
+      results.push({
+        packageName: targetPackage.packageJson.name || "unnamed package",
+        packagePath: targetPackage.packagePath,
+        unusedDeps
+      });
+      totalUnused += unusedDeps.length;
+    }
+  }
+  if (results.length === 0) {
+    logger.success("\u2705 No unused dependencies found!");
+    return;
+  }
+  logger.log(`
+\u{1F4E6} Found ${totalUnused} unused dependencies across ${results.length} packages:
+`);
+  const packageSuggestions = [];
+  for (const result of results) {
+    const relativePath = relative(process.cwd(), result.packagePath);
+    const depsByScope = {};
+    const allDeps = [];
+    for (const dep of result.unusedDeps) {
+      if (!depsByScope[dep.scope]) {
+        depsByScope[dep.scope] = [];
+      }
+      depsByScope[dep.scope].push(dep.name);
+      allDeps.push(dep);
+    }
+    packageSuggestions.push({
+      packageName: result.packageName,
+      packagePath: result.packagePath,
+      relativePath,
+      depsByScope,
+      allDeps
+    });
+  }
+  for (const suggestion of packageSuggestions) {
+    logger.log(`\u{1F4C1} ${suggestion.packageName} (${suggestion.relativePath}):`);
+    for (const dep of suggestion.allDeps) {
+      logger.log(`  \u274C ${dep.name}@${dep.version} (${dep.scope})`);
+    }
+    logger.log("");
+  }
+  logger.log("\u{1F527} Suggested removal commands:");
+  for (const suggestion of packageSuggestions) {
+    const packageTarget = suggestion.relativePath === "package.json" ? "." : suggestion.relativePath;
+    for (const [scope, deps] of Object.entries(suggestion.depsByScope)) {
+      if (deps.length > 0) {
+        const scopeFlag = scope === "prod" ? "" : ` --${scope}`;
+        const depList = deps.join(" ");
+        logger.log(`  bun dler rm ${depList} --target "${packageTarget}"${scopeFlag}`);
+      }
+    }
+    logger.log("");
+  }
+  logger.log(`\u{1F4A1} Use --ignore flag to exclude specific packages from analysis`);
+  logger.log(
+    `\u{1F4A1} If some dep is used, but was marked as unused, please create an issue: https://github.com/reliverse/dler/issues`
+  );
+}