@reliverse/dler 1.7.1 → 1.7.3

package/bin/cli.js

@@ -8,11 +8,8 @@ import {
   runCmd as remptsRunCmd
 } from "@reliverse/rempts";
 import { promptAggCommand } from "./app/agg/run.js";
-import { getCmdBuild, getCmdPub } from "./app/cmds.js";
-import {
-  showEndPrompt,
-  showStartPrompt
-} from "./libs/sdk/sdk-impl/config/info.js";
+import { getBuildCmd, getPubCmd, getInitCmd, getRenameCmd } from "./app/cmds.js";
+import { showEndPrompt, showStartPrompt } from "./libs/sdk/sdk-impl/cfg/info.js";
 const INTERACTIVE_CMDS = ["agg", "build", "pub"];
 async function runCmd(cmdPromise, args) {
   const cmd = await cmdPromise;
@@ -32,9 +29,16 @@ Available interactive commands: ${INTERACTIVE_CMDS.join(", ")}`
     dev: {
       type: "boolean",
       description: "Runs the CLI in dev mode"
+    },
+    cwd: {
+      type: "string",
+      description: "The working directory to run the CLI in",
+      default: process.cwd()
     }
   }),
   async run({ args }) {
+    const isDev = args.dev;
+    relinka("verbose", `Running in ${isDev ? "dev" : "prod"} mode`);
     const isCI = process.env.CI === "true";
     const isNonInteractive = !process.stdout.isTTY;
     if (isCI || isNonInteractive) {
@@ -51,17 +55,34 @@ Available interactive commands: ${INTERACTIVE_CMDS.join(", ")}`
       options: [
         { value: "agg", label: "agg" },
         { value: "build", label: "build" },
-        { value: "pub", label: "pub" }
+        { value: "pub", label: "pub" },
+        { value: "copy", label: "copy" },
+        {
+          value: "init",
+          label: "Initialize files"
+        },
+        {
+          value: "rename-prepare",
+          label: "My project is a bootstrapper CLI (apply rename optimizations)"
+        },
+        {
+          value: "rename-prepare-revert",
+          label: "Revert rename CLI files optimizations"
+        }
       ]
     });
     if (cmdToRun === "agg") {
       await promptAggCommand();
-    }
-    if (cmdToRun === "build") {
-      await runCmd(getCmdBuild(), [`--dev=${args.dev}`]);
-    }
-    if (cmdToRun === "pub") {
-      await runCmd(getCmdPub(), [`--dev=${args.dev}`]);
+    } else if (cmdToRun === "build") {
+      await runCmd(getBuildCmd(), [`--dev=${args.dev}`]);
+    } else if (cmdToRun === "pub") {
+      await runCmd(getPubCmd(), [`--dev=${args.dev}`]);
+    } else if (cmdToRun === "init") {
+      await runCmd(getInitCmd(), []);
+    } else if (cmdToRun === "rename-prepare") {
+      await runCmd(getRenameCmd(), ["--prepareMyCLI"]);
+    } else if (cmdToRun === "rename-prepare-revert") {
+      await runCmd(getRenameCmd(), ["--prepareMyCLI", "--revert"]);
     }
     relinka("log", " ");
     await showEndPrompt();

package/bin/libs/sdk/sdk-impl/{config → cfg}/info.js

@@ -1,5 +1,5 @@
 import { endPrompt, startPrompt } from "@reliverse/rempts";
-const version = "1.7.1";
+const version = "1.7.3";
 export async function showStartPrompt(isDev) {
   await startPrompt({
     titleColor: "inverse",

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/dler-config-health}/dler-config-health.d.ts

@@ -1,2 +1,2 @@
-import type { CheckResult } from "../../../sdk-types.js";
+import type { CheckResult } from "../../../../sdk-types.js";
 export declare function checkDlerConfigHealth(): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/dler-config-health}/dler-config-health.js

@@ -1,4 +1,4 @@
-import { loadConfig } from "../../config/load.js";
+import { loadConfig } from "../../../cfg/load.js";
 export async function checkDlerConfigHealth() {
   const startTime = Date.now();
   const issues = [];

package/bin/libs/sdk/sdk-impl/rules/reliverse/file-extensions/file-extensions.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult, RulesCheckOptions } from "../../../../sdk-types.js";
+export declare function checkFileExtensions(options: RulesCheckOptions): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/file-extensions}/file-extensions.js

@@ -2,8 +2,8 @@ import { extname } from "@reliverse/pathkit";
 import {
   ALLOWED_FILE_EXTENSIONS,
   STRICT_FILE_EXTENSIONS
-} from "../check-consts.js";
-import { getAllFiles } from "../check-utils.js";
+} from "../../rules-consts.js";
+import { getAllFiles } from "../../rules-utils.js";
 function getAllowedFileExtensions(directory, strict, moduleResolution) {
   if (!strict) {
     return ALLOWED_FILE_EXTENSIONS[directory];

package/bin/libs/sdk/sdk-impl/{check/rules/deps → rules/reliverse/missing-deps}/analyzer.js

@@ -13,11 +13,23 @@ export const analyzeDependencies = async (options) => {
   );
   const builtinModules = getBuiltinModules();
   const allDependencies = /* @__PURE__ */ new Set();
+  const devOnlyDependencies = /* @__PURE__ */ new Set();
+  const duplicateDependencies = /* @__PURE__ */ new Set();
+  if (packageJson.dependencies && packageJson.devDependencies) {
+    for (const dep of Object.keys(packageJson.dependencies)) {
+      if (packageJson.devDependencies[dep]) {
+        duplicateDependencies.add(dep);
+      }
+    }
+  }
   for (const filePath of sourceFiles) {
     const fileContent = await readFile(filePath);
     const packageNames = extractPackageNames(fileContent);
     for (const packageName of packageNames) {
       allDependencies.add(packageName);
+      if (packageJson.devDependencies?.[packageName] && !packageJson.dependencies?.[packageName] && !packageJson.peerDependencies?.[packageName] && !packageJson.optionalDependencies?.[packageName] && !builtinModules.has(packageName)) {
+        devOnlyDependencies.add(packageName);
+      }
     }
   }
   const missingDependencies = /* @__PURE__ */ new Set();
@@ -37,6 +49,8 @@ export const analyzeDependencies = async (options) => {
     missingDependencies: Array.from(missingDependencies).sort(),
     allDependencies: Array.from(allDependencies).sort(),
     listedDependencies: Array.from(listedDependencies).sort(),
-    builtinModules: builtinModulesList.sort()
+    builtinModules: builtinModulesList.sort(),
+    devOnlyDependencies: Array.from(devOnlyDependencies).sort(),
+    duplicateDependencies: Array.from(duplicateDependencies).sort()
   };
 };

package/bin/libs/sdk/sdk-impl/rules/reliverse/missing-deps/deps-mod.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult, RulesCheckOptions } from "../../../../sdk-types.js";
+export declare function checkMissingDependencies(options: RulesCheckOptions): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/{check/rules/missing-deps.js → rules/reliverse/missing-deps/deps-mod.js}

@@ -1,5 +1,5 @@
-import { analyzeDependencies } from "./deps/analyzer.js";
-import { IGNORE_PATTERNS } from "../../constants.js";
+import { IGNORE_PATTERNS } from "../../../constants.js";
+import { analyzeDependencies } from "./analyzer.js";
 export async function checkMissingDependencies(options) {
   const startTime = Date.now();
   const issues = [];

package/bin/libs/sdk/sdk-impl/{check/rules/deps → rules/reliverse/missing-deps}/deps-types.d.ts

@@ -23,4 +23,6 @@ export type DependencyResult = {
     allDependencies: string[];
     listedDependencies: string[];
     builtinModules: string[];
+    devOnlyDependencies: string[];
+    duplicateDependencies: string[];
 };

package/bin/libs/sdk/sdk-impl/{check/rules/deps → rules/reliverse/missing-deps}/filesystem.js

@@ -1,6 +1,6 @@
 import fs from "@reliverse/relifso";
-import { glob } from "glob";
 import path from "node:path";
+import { glob } from "tinyglobby";
 export const findSourceFiles = async (directory, ignorePatterns) => {
   const pattern = `${directory}/**/*.{js,jsx,ts,tsx}`;
   const defaultIgnores = [
@@ -16,8 +16,7 @@ export const findSourceFiles = async (directory, ignorePatterns) => {
   const allIgnores = [...defaultIgnores, ...ignorePatterns];
   return await glob(pattern, {
     ignore: allIgnores,
-    absolute: true,
-    nodir: true
+    absolute: true
   });
 };
 export const readFile = async (filePath) => {

package/bin/libs/sdk/sdk-impl/rules/reliverse/missing-deps/formatter.js

@@ -0,0 +1,113 @@
+import { re } from "@reliverse/relico";
+export const formatOutput = (result, options) => {
+  if (options.json) {
+    return JSON.stringify(result, null, 2);
+  }
+  let output = "";
+  output += re.bluePastel("\nMissing Dependencies Finder Results\n");
+  output += re.gray("---------------------------------------\n\n");
+  output += re.bold("Statistics:\n");
+  output += `${re.gray("\u2022 ")}Total dependencies found: ${result.allDependencies.length}
+`;
+  output += `${re.gray("\u2022 ")}Listed in package.json: ${result.listedDependencies.length}
+`;
+  output += `${re.gray("\u2022 ")}Missing from package.json: ${result.missingDependencies.length}
+`;
+  if (options.builtins) {
+    output += `${re.gray("\u2022 ")}Node.js built-in modules: ${result.builtinModules.length}
+`;
+  }
+  output += `${re.gray("\u2022 ")}Dev-only dependencies used in production: ${result.devOnlyDependencies.length}
+`;
+  output += `${re.gray("\u2022 ")}Duplicate dependencies: ${result.duplicateDependencies.length}
+`;
+  output += "\n";
+  if (result.duplicateDependencies.length > 0) {
+    output += re.yellowPastel("\u26A0\uFE0F  Duplicate Dependencies Found:\n");
+    output += re.yellow(
+      "These packages are listed in both dependencies and devDependencies.\n"
+    );
+    output += re.yellow(
+      "This can cause confusion and potential issues. Consider keeping them in only one section.\n\n"
+    );
+    for (const dep of result.duplicateDependencies) {
+      output += `${re.gray("\u2022 ")}${re.yellow(dep)}
+`;
+    }
+    output += "\n";
+  }
+  if (result.devOnlyDependencies.length > 0) {
+    output += re.yellowPastel(
+      "\u26A0\uFE0F  Dev-only Dependencies Used in Production Code:\n"
+    );
+    output += re.yellow(
+      "These packages are only in devDependencies but are imported in your code.\n"
+    );
+    output += re.yellow(
+      "They will cause errors in production after bundling!\n\n"
+    );
+    for (const dep of result.devOnlyDependencies) {
+      output += `${re.gray("\u2022 ")}${re.yellow(dep)}
+`;
+    }
+    output += "\n";
+    output += re.gray("To fix, move these to dependencies:\n");
+    output += re.cyan(
+      `npm install ${result.devOnlyDependencies.join(" ")} --save
+`
+    );
+  }
+  if (result.missingDependencies.length > 0) {
+    output += re.redPastel("Missing Dependencies:\n");
+    for (const dep of result.missingDependencies) {
+      output += `${re.gray("\u2022 ")}${re.yellow(dep)}
+`;
+    }
+    output += "\n";
+    output += re.gray("To install, run:\n");
+    output += re.cyan(
+      `npm install ${result.missingDependencies.join(" ")}
+`
+    );
+  } else {
+    output += re.greenPastel("No missing dependencies found! \u{1F389}\n\n");
+  }
+  if (options.builtins && result.builtinModules.length > 0) {
+    output += re.bluePastel("Node.js Built-in Modules Used:\n");
+    for (const dep of result.builtinModules) {
+      output += `${re.gray("\u2022 ")}${re.blue(dep)}
+`;
+    }
+    output += "\n";
+  }
+  if (options.showAll) {
+    output += re.bold("All Dependencies:\n");
+    output += re.gray(
+      "(\u2713 = listed in package.json, \u2717 = missing, \u26A0\uFE0F = dev-only, \u{1F504} = duplicate)\n"
+    );
+    for (const dep of result.allDependencies) {
+      const isListed = result.listedDependencies.includes(dep);
+      const isBuiltin = result.builtinModules.includes(dep);
+      const isDevOnly = result.devOnlyDependencies.includes(dep);
+      const isDuplicate = result.duplicateDependencies.includes(dep);
+      if (isDuplicate) {
+        output += `${re.gray("\u2022 ")}${re.yellow("\u{1F504} ")}${re.yellow(dep)}${re.gray(" (duplicate)")}
+`;
+      } else if (isListed && !isDevOnly) {
+        output += `${re.gray("\u2022 ") + re.green("\u2713 ") + dep}
+`;
+      } else if (isBuiltin) {
+        output += `${re.gray("\u2022 ")}${re.blue("\u26A1 ")}${dep}${re.gray(" (built-in)")}
+`;
+      } else if (isDevOnly) {
+        output += `${re.gray("\u2022 ")}${re.yellow("\u26A0\uFE0F ")}${re.yellow(dep)}${re.gray(" (dev-only)")}
+`;
+      } else {
+        output += `${re.gray("\u2022 ")}${re.red("\u2717 ")}${re.yellow(dep)}
+`;
+      }
+    }
+    output += "\n";
+  }
+  return output;
+};

package/bin/libs/sdk/sdk-impl/rules/reliverse/no-index-files/no-index-files.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult, RulesCheckOptions } from "../../../../sdk-types.js";
+export declare function checkNoIndexFiles(options: RulesCheckOptions): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/rules/reliverse/no-index-files/no-index-files.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { glob } from "tinyglobby";
+export async function checkNoIndexFiles(options) {
+  const { directory } = options;
+  const startTime = Date.now();
+  const indexFiles = await glob("**/index.{ts,js}", {
+    cwd: directory,
+    ignore: ["node_modules/**", "dist/**", ".git/**"]
+  });
+  const issues = [];
+  const stats = {
+    filesChecked: indexFiles.length,
+    importsChecked: 0,
+    timeElapsed: Date.now() - startTime
+  };
+  for (const file of indexFiles) {
+    const fullPath = path.join(directory, file);
+    const dirName = path.basename(path.dirname(file));
+    issues.push({
+      type: "no-index-files",
+      file: fullPath,
+      line: 1,
+      message: `Avoid using index.{ts,js} file names. Use descriptive names like mod.{ts,js} or ${dirName}-mod.{ts,js} instead. This reduces confusion, especially since TypeScript can resolve index files implicitly depending on the module resolution strategy.`
+    });
+  }
+  return {
+    success: issues.length === 0,
+    issues,
+    stats
+  };
+}

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/package-json-health}/package-json-health.d.ts

@@ -1,2 +1,2 @@
-import type { CheckResult } from "../../../sdk-types.js";
+import type { CheckResult } from "../../../../sdk-types.js";
 export declare function checkPackageJsonHealth(): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/rules/reliverse/path-extensions/path-extensions.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult, RulesCheckOptions } from "../../../../sdk-types.js";
+export declare function checkPathExtensions(options: RulesCheckOptions): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/path-extensions}/path-extensions.js

@@ -4,11 +4,11 @@ import { relinka } from "@reliverse/relinka";
 import {
   ALLOWED_IMPORT_EXTENSIONS,
   STRICT_IMPORT_EXTENSIONS
-} from "../check-consts.js";
+} from "../../rules-consts.js";
 import {
   getAllFiles,
   getLineNumber
-} from "../check-utils.js";
+} from "../../rules-utils.js";
 function getAllowedImportExtensions(directory, strict) {
   if (strict) {
     return STRICT_IMPORT_EXTENSIONS[directory];

package/bin/libs/sdk/sdk-impl/rules/reliverse/self-include/self-include.d.ts

@@ -0,0 +1,2 @@
+import type { CheckResult, RulesCheckOptions } from "../../../../sdk-types.js";
+export declare function checkSelfInclude(options: RulesCheckOptions): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/self-include}/self-include.js

@@ -1,11 +1,11 @@
 import { getFileImportsExports, extname } from "@reliverse/pathkit";
 import fs from "@reliverse/relifso";
 import { relinka } from "@reliverse/relinka";
+import { loadConfig } from "../../../cfg/load.js";
 import {
   getAllFiles,
   getLineNumber
-} from "../check-utils.js";
-import { loadConfig } from "../../config/load.js";
+} from "../../rules-utils.js";
 export async function checkSelfInclude(options) {
   const startTime = Date.now();
   const issues = [];

package/bin/libs/sdk/sdk-impl/{check/rules → rules/reliverse/tsconfig-health}/tsconfig-health.d.ts

@@ -1,2 +1,2 @@
-import type { CheckResult } from "../../../sdk-types.js";
+import type { CheckResult } from "../../../../sdk-types.js";
 export declare function checkTsConfigHealth(): Promise<CheckResult>;

package/bin/libs/sdk/sdk-impl/{check/check-mod.js → rules/rules-mod.js}

@@ -22,6 +22,7 @@ export function displayCheckResults(checkType, directory, result) {
       (i) => i.type === "dler-config-health"
     );
     const selfIncludeIssues = issues.filter((i) => i.type === "self-include");
+    const noIndexIssues = issues.filter((i) => i.type === "no-index-files");
     if (fileIssues.length > 0) {
       relinka("error", `  file extension issues (${fileIssues.length}):`);
       for (const issue of fileIssues.slice(0, 10)) {
@@ -79,6 +80,15 @@ export function displayCheckResults(checkType, directory, result) {
         relinka("error", `    ... and ${selfIncludeIssues.length - 10} more`);
       }
     }
+    if (noIndexIssues.length > 0) {
+      relinka("error", `  index file issues (${noIndexIssues.length}):`);
+      for (const issue of noIndexIssues.slice(0, 10)) {
+        relinka("error", `    ${issue.file}: ${issue.message}`);
+      }
+      if (noIndexIssues.length > 10) {
+        relinka("error", `    ... and ${noIndexIssues.length - 10} more`);
+      }
+    }
     relinka(
       "info",
       `  stats: ${stats.filesChecked} files, ${stats.importsChecked} imports, ${stats.timeElapsed}ms`

package/bin/libs/sdk/sdk-impl/{check/check-utils.d.ts → rules/rules-utils.d.ts}

@@ -1,4 +1,4 @@
-import type { AllowedFileExtensionsType } from "./check-consts";
+import type { AllowedFileExtensionsType } from "./rules-consts";
 export declare function validateDirectory(dir: string): Promise<boolean>;
 export declare function shouldIgnoreFile(filePath: string): boolean;
 export declare function getAllFiles(dir: AllowedFileExtensionsType, onProgress?: (current: number, total: number, file: string) => void): Promise<string[]>;

package/bin/libs/sdk/sdk-impl/utils/utils-pkg-json-libs.js

@@ -276,7 +276,9 @@ async function library_writeJsrPackageJSON(libName, outDirBin, pkgJsonDir, origi
       "package.json",
       "README.md",
       "LICENSE"
-    ]
+    ],
+    main: `./bin/${path.basename(libsList[libName].libMainFile)}`,
+    module: `./bin/${path.basename(libsList[libName].libMainFile)}`
   });
   const pkgPath = path.join(pkgJsonDir, "package.json");
   await fs.ensureDir(path.dirname(pkgPath));
@@ -319,7 +321,7 @@ async function library_writeNpmLibPackageJSON(libName, outDirBin, pkgJsonDir, or
       libName
     ),
     exports: {
-      ".": `./bin/${libsList[libName].libMainFile.replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`
+      ".": `./bin/${path.basename(libsList[libName].libMainFile).replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`
     },
     files: config.publishArtifacts?.global || [
       "bin",
@@ -327,8 +329,8 @@ async function library_writeNpmLibPackageJSON(libName, outDirBin, pkgJsonDir, or
       "README.md",
       "LICENSE"
     ],
-    main: `./bin/${libsList[libName].libMainFile.replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`,
-    module: `./bin/${libsList[libName].libMainFile.replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`,
+    main: `./bin/${path.basename(libsList[libName].libMainFile).replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`,
+    module: `./bin/${path.basename(libsList[libName].libMainFile).replace(/\.ts$/, `.${unifiedBundlerOutExt}`)}`,
     publishConfig: { access: "public" }
   });
   const pkgPath = path.join(pkgJsonDir, "package.json");

package/bin/libs/sdk/sdk-types.d.ts

@@ -851,7 +851,7 @@ export type PerfTimer = {
 /** Options common to both NPM and JSR build targets */
 /** Options specific to the transpilation/bundling process */
 type DirectoryType = "src" | "dist-npm" | "dist-jsr" | "dist-libs/npm" | "dist-libs/jsr";
-export type FileCheckOptions = {
+export type RulesCheckOptions = {
     directory: DirectoryType;
     strict: boolean;
     moduleResolution: "bundler" | "nodenext";
@@ -865,7 +865,7 @@ export type FileCheckOptions = {
     depth?: number;
 };
 export type CheckIssue = {
-    type: "file-extension" | "path-extension" | "missing-dependency" | "builtin-module" | "dler-config-health" | "self-include" | "tsconfig-health";
+    type: "file-extension" | "path-extension" | "missing-dependency" | "builtin-module" | "dler-config-health" | "self-include" | "tsconfig-health" | "no-index-files";
     message: string;
     file: string;
     line?: number;

package/bin/mod.d.ts

@@ -1 +1 @@
-export { defineConfig } from "./libs/sdk/sdk-impl/config/define";
+export { defineConfig } from "./libs/sdk/sdk-impl/cfg/define";

package/bin/mod.js

@@ -1 +1 @@
-export { defineConfig } from "./libs/sdk/sdk-impl/config/define.js";
+export { defineConfig } from "./libs/sdk/sdk-impl/cfg/define.js";

package/package.json

@@ -6,19 +6,17 @@
     "@reliverse/relico": "^1.1.2",
     "@reliverse/relifso": "^1.3.1",
     "@reliverse/relinka": "^1.4.7",
-    "@reliverse/rempts": "^1.7.12",
+    "@reliverse/rempts": "^1.7.17",
     "@rollup/plugin-alias": "^5.1.1",
     "@rollup/plugin-commonjs": "^28.0.3",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/pluginutils": "^5.1.4",
-    "chalk": "^5.4.1",
     "defu": "^6.1.4",
     "esbuild": "^0.25.5",
     "execa": "^9.6.0",
     "fix-dts-default-cjs-exports": "^1.0.1",
-    "glob": "^11.0.2",
     "hookable": "^5.5.3",
     "jiti": "^2.4.2",
     "magic-string": "^0.30.17",
@@ -41,7 +39,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.1",
+  "version": "1.7.3",
   "keywords": [
     "reliverse",
     "cli",

package/bin/app/deps/cmd.js

@@ -1,84 +0,0 @@
-import path from "@reliverse/pathkit";
-import { re } from "@reliverse/relico";
-import { defineArgs, defineCommand } from "@reliverse/rempts";
-import { analyzeDependencies } from "../../libs/sdk/sdk-impl/check/rules/deps/analyzer.js";
-import { formatOutput } from "../../libs/sdk/sdk-impl/check/rules/deps/formatter.js";
-export default defineCommand({
-  meta: {
-    name: "deps",
-    version: "1.0.0",
-    description: "Find dependencies used but not listed in package.json"
-  },
-  args: defineArgs({
-    directory: {
-      type: "string",
-      description: "directory to scan (defaults to current directory)",
-      default: "."
-    },
-    all: {
-      type: "boolean",
-      description: "show all dependencies (both listed and not listed)"
-    },
-    ignore: {
-      type: "string",
-      description: "comma-separated patterns to ignore"
-    },
-    json: {
-      type: "boolean",
-      description: "output in JSON format"
-    },
-    builtins: {
-      type: "boolean",
-      description: "include Node.js built-in modules in the output"
-    },
-    dev: {
-      type: "boolean",
-      description: "check devDependencies instead of dependencies"
-    },
-    peer: {
-      type: "boolean",
-      description: "check peerDependencies instead of dependencies"
-    },
-    optional: {
-      type: "boolean",
-      description: "check optionalDependencies instead of dependencies"
-    },
-    fix: {
-      type: "boolean",
-      description: "automatically add missing dependencies to package.json"
-    },
-    depth: {
-      type: "number",
-      description: "maximum directory depth to scan (0 for unlimited)",
-      default: 0
-    }
-  }),
-  async run({ args }) {
-    try {
-      const directory = path.resolve(args.directory);
-      const ignorePatterns = args.ignore ? args.ignore.split(",") : [];
-      const options = {
-        directory,
-        showAll: args.all,
-        ignorePatterns,
-        json: args.json,
-        builtins: args.builtins,
-        dev: args.dev,
-        peer: args.peer,
-        optional: args.optional,
-        fix: args.fix,
-        depth: args.depth
-      };
-      console.log(re.gray(`Scanning directory: ${directory}`));
-      const result = await analyzeDependencies(options);
-      const output = formatOutput(result, options);
-      console.log(output);
-      if (result.missingDependencies.length > 0) {
-        process.exit(1);
-      }
-    } catch (error) {
-      console.error("Error:", error);
-      process.exit(1);
-    }
-  }
-});