qleaner 1.0.10 → 1.0.12

package/README.md

@@ -1,14 +1,15 @@
 # Qleaner
 
-A powerful CLI tool to analyze and clean up your React codebase by finding unused files and listing all imports. Built with Node.js and Babel AST parsing.
+A powerful CLI tool to analyze and clean up your React codebase by finding unused files and listing all imports.
 
 ## Features
 
 - 🔍 **Scan for unused files**: Identify files that are not imported anywhere in your project
-- 📋 **List all imports**: Get a complete list of all import statements in your codebase
+- 📋 **List all imports**: Get a complete list of all import statements in your codebase with file locations
 - 🎯 **File listing**: List all files in your project
+- 📊 **Table output**: Display results in formatted tables for better readability
 - ⚙️ **Flexible configuration**: Exclude directories and files from scanning
-- 🚀 **Fast performance**: Uses fast-glob for efficient file scanning
+- 🚀 **Fast performance**: Efficient file scanning across large codebases
 - 💪 **TypeScript support**: Works with TypeScript, JavaScript, JSX, and TSX files
 
 ## Installation
@@ -40,6 +41,7 @@ qleaner qlean-list <path> [options]
 - `-e, --exclude-dir <dir...>` - Exclude directories from the scan
 - `-f, --exclude-file <file...>` - Exclude files from the scan
 - `-F, --exclude-file-print <file...>` - Do not print the excluded files
+- `-t, --table` - Display results in a formatted table
 
 **Examples:**
 
@@ -50,11 +52,17 @@ qleaner qlean-list src --list-files
 # List all imports in src directory
 qleaner qlean-list src --list-imports
 
+# List both files and imports in table format
+qleaner qlean-list src --list-files --list-imports --table
+
 # List files excluding node_modules and dist
 qleaner qlean-list src --list-files -e node_modules dist
 
 # List imports excluding specific files
 qleaner qlean-list src --list-imports -f "**/*.test.js" "**/*.spec.js"
+
+# List with table output
+qleaner qlean-list src --list-files --list-imports --table
 ```
 
 ### Scan for Unused Files
@@ -69,6 +77,7 @@ qleaner qlean-scan <path> [options]
 - `-e, --exclude-dir <dir...>` - Exclude directories from the scan
 - `-f, --exclude-file <file...>` - Exclude files from the scan
 - `-F, --exclude-file-print <files...>` - Do not print the excluded files
+- `-t, --table` - Display results in a formatted table
 
 **Examples:**
 
@@ -76,6 +85,9 @@ qleaner qlean-scan <path> [options]
 # Scan src directory for unused files
 qleaner qlean-scan src
 
+# Display unused files in a table format
+qleaner qlean-scan src --table
+
 # Scan excluding test directories
 qleaner qlean-scan src -e __tests__ __mocks__ test
 
@@ -84,14 +96,31 @@ qleaner qlean-scan src -f "**/*.test.js" "**/*.stories.js"
 
 # Scan with multiple exclusions
 qleaner qlean-scan src -e node_modules dist -f "**/*.config.js"
+
+# Scan with table output and exclusions
+qleaner qlean-scan src --table -e __tests__ dist -f "**/*.config.js"
 ```
 
+## Output Formats
+
+Qleaner provides two output formats:
+
+1. **Standard output**: Color-coded text output
+   - Green for files
+   - Yellow for imports
+   - Red for unused files
+
+2. **Table output**: Formatted tables with organized columns (use `--table` flag)
+   - Import tables show: File, Line, Column, and Import path
+   - File tables show: File path
+   - Unused files table shows: Unused file paths
+
 ## How It Works
 
-1. **File Discovery**: Uses `fast-glob` to recursively find all `.tsx`, `.ts`, `.js`, and `.jsx` files in the specified directory
-2. **AST Parsing**: Uses Babel parser to parse files and extract import statements
+1. **File Discovery**: Recursively finds all `.tsx`, `.ts`, `.js`, and `.jsx` files in the specified directory
+2. **Import Extraction**: Parses files and extracts all import statements
 3. **Analysis**: Compares file paths with import paths to identify unused files
-4. **Reporting**: Outputs the results based on the selected command and options
+4. **Reporting**: Outputs the results in standard or table format based on your preferences
 
 ## Supported File Types
 
@@ -106,6 +135,7 @@ qleaner qlean-scan src -e node_modules dist -f "**/*.config.js"
 - 📊 **Code analysis**: Understand import patterns and dependencies in your codebase
 - 🔍 **Project audit**: Identify orphaned files that may have been forgotten
 - 📦 **Bundle optimization**: Find files that can be removed to reduce bundle size
+- 🎯 **Maintenance**: Keep your codebase clean and maintainable
 
 ## Configuration
 
@@ -115,6 +145,31 @@ You can exclude directories and files from scanning using the command-line optio
 - Excluding third-party libraries
 - Excluding configuration files
 
+**Common exclusions:**
+- Test files: `-f "**/*.test.*" "**/*.spec.*"`
+- Storybook files: `-f "**/*.stories.*"`
+- Test directories: `-e __tests__ __mocks__ test`
+- Build outputs: `-e dist build .next`
+- Configuration files: `-f "**/*.config.*"`
+- Third-party code: `-e node_modules vendor`
+
+## Tips and Best Practices
+
+1. **Start with a small scope**: Begin by scanning a specific directory before scanning the entire project
+2. **Use exclusions**: Exclude test files and build outputs when scanning for unused files
+3. **Review before deleting**: Always review the unused files list before removing them - some files might be used dynamically (e.g., through dynamic imports, configuration files, or asset references)
+4. **Use table format**: The table format is easier to read for large results
+5. **Combine options**: Use multiple flags together for comprehensive analysis
+6. **Check dynamic imports**: Files imported using dynamic imports (`import()`) may appear as unused but are actually needed
+
+## Important Notes
+
+⚠️ **Warning**: Always review files before deletion. Some files might be:
+- Used dynamically (dynamic imports)
+- Referenced in configuration files
+- Required for build processes
+- Used as entry points that aren't directly imported
+
 ## Requirements
 
 - Node.js 14+ 

package/bin/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const { Command } = require("commander");
-const { getFiles, unUsedFiles } = require("../command");
-const Table = require('cli-table3')
+const { list, scan } = require("../controllers/list");
+
 
 async function loadChalk() {
   return (await import("chalk")).default;
@@ -31,13 +31,7 @@ async function loadChalk() {
     )
     .option("-t, --table", "Print the results in a table")
     .action(async (path, options) => {
-      const { tableImports, tableFiles } = await getFiles(path, options, chalk);
-      if(options.table){
-        console.log(chalk.yellow('***************** Imported Files *****************'));
-        console.log(tableImports.toString());
-        console.log(chalk.green('***************** List Files *****************'));
-        console.log(tableFiles.toString());
-      }
+      await list(chalk, path, options);
     });
 
   program
@@ -48,27 +42,27 @@ async function loadChalk() {
     .option("-f, --exclude-file <file...>", "Exclude files from the scan")
     .option(
       "-F, --exclude-file-print <files...>",
-      "Do not Print the excluded files"
+      "Scan but don't print the excluded files"
     )
     .option("-t, --table", "Print the results in a table")
+    .option("-d, --dry-run", "Show what would be deleted without actually deleting (skips prompt)")
     .action(async (path, options) => {
-      const unusedFiles = await unUsedFiles(path, options);
-      // console.clear()
-      if(options.table){
-        const table = new Table({
-            head: ['Unused Files'],
-            colWidths: [50]
-        })
-        unusedFiles.forEach(file => {
-            table.push([file])
-        })
-        console.log(table.toString())
-
-      }else {
-        unusedFiles.forEach((file) => {
-            console.log(chalk.red(file));
-          });
-      }
+      await scan(chalk, path, options);
     });
+
+  program
+  .command('qlean-image')
+  .description("Scan the project for unused images")
+  .argument("<path>", "The path to the directory to scan for unused images")
+  .option("-e, --exclude-dir <dir...>", "Exclude directories from the scan")
+  .option("-f, --exclude-file <file...>", "Exclude files from the scan")
+  .option(
+    "-F, --exclude-file-print <files...>",
+    "Scan but don't print the excluded files"
+  )
+  .option("-t, --table", "Print the results in a table")
+  .action(async (path, options) => {
+
+  });
   program.parse(process.argv);
 })();

package/command.js

@@ -1,25 +1,26 @@
 const fg = require("fast-glob");
 const fs = require("fs");
-const Table = require('cli-table3');
+const Table = require("cli-table3");
 const parser = require("@babel/parser");
 const traverse = require("@babel/traverse").default;
-
-
-
+const path = require("path");
+const { createResolver } = require("./utils/resolver");
+const { loadCache, getFileHash, needsRebuild, saveCache } = require("./utils/cache");
 
 async function getFiles(directory = "src", options, chalk) {
-    const contentPaths = [`${directory}/**/*.{tsx,ts,js,jsx}`];
-    if (options.excludeDir && options.excludeDir.length > 0) {
-        options.excludeDir.forEach(dir => {
-            contentPaths.push(`!${dir}/**`);
-        });
-    }
-    if (options.excludeFile && options.excludeFile.length > 0) {
-        options.excludeFile.forEach(file => {
-            contentPaths.push(`!${directory}/**/${file}`);
-        });
-    }
-    const files = await fg(contentPaths);
+  const contentPaths = [`${directory}/**/*.{tsx,ts,js,jsx}`];
+  if (options.excludeDir && options.excludeDir.length > 0) {
+    options.excludeDir.forEach((dir) => {
+      contentPaths.push(`!${dir}/**`);
+    });
+  }
+  if (options.excludeFile && options.excludeFile.length > 0) {
+    options.excludeFile.forEach((file) => {
+      contentPaths.push(`!${directory}/**/${file}`);
+    });
+  }
+
+  const files = await fg(contentPaths);
   const imports = [];
   for (const file of files) {
     const code = fs.readFileSync(file, "utf8");
@@ -30,13 +31,12 @@ async function getFiles(directory = "src", options, chalk) {
     traverse(ast, {
       ImportDeclaration: ({ node }) => {
         imports.push({
-            from: node.source.value,
-            file: file,
-            line: node.loc.start.line,
-            column: node.loc.start.column,
+          from: node.source.value,
+          file: file,
+          line: node.loc.start.line,
+          column: node.loc.start.column,
         });
       },
-
     });
     //   ExportNamedDeclaration: ({ node }) => {
     //     if (node.declaration.declarations && node.declaration.declarations[0].id && node.declaration.declarations[0].id.name) {
@@ -51,123 +51,166 @@ async function getFiles(directory = "src", options, chalk) {
     //   },
     // });
   }
-  
+
   if (options.table) {
     const tableImports = new Table({
-        head: ['File', 'Line', 'Column', 'Import'],
-        colWidths: [20, 10, 10, 20],
+      head: ["File", "Line", "Column", "Import"],
+      colWidths: [20, 10, 10, 20],
+    });
+
+    const tableFiles = new Table({
+      head: ["File"],
+      colWidths: [20],
+    });
+
+    if (options.listFiles) {
+      files.forEach((file) => {
+        tableFiles.push([file]);
       });
-    
-      const tableFiles = new Table({
-        head: ['File'],
-        colWidths: [20],
+    }
+    if (options.listImports) {
+      imports.forEach((importStatement) => {
+        tableImports.push([
+          importStatement.file,
+          importStatement.line,
+          importStatement.column,
+          importStatement.from,
+        ]);
       });
-    
-      if (options.listFiles) {
-        files.forEach((file) => {
-            tableFiles.push([file]);
-        })
-      }
-      if (options.listImports) {
-        imports.forEach((importStatement) => {
-          tableImports.push([importStatement.file, importStatement.line, importStatement.column, importStatement.from]);
-        })
-      }
-      return { tableImports, tableFiles };
-  }else{
+    }
+    return { tableImports, tableFiles };
+  } else {
     if (options.listFiles) {
-        console.log(chalk.green('***************** Files *****************'));
-        files.forEach((file) => {
-            console.log(chalk.green(file));
-        })
-      }
-      if (options.listImports) {
-        console.log(chalk.yellow('***************** Imports *****************'));
-        imports.forEach((importStatement) => {
-          console.log(chalk.yellow(`${importStatement.file}:${importStatement.line}:${importStatement.column}  ${importStatement.from}`));
-        })
-      }
+      console.log(chalk.green("***************** Files *****************"));
+      files.forEach((file) => {
+        console.log(chalk.green(file));
+      });
+    }
+    if (options.listImports) {
+      console.log(chalk.yellow("***************** Imports *****************"));
+      imports.forEach((importStatement) => {
+        console.log(
+          chalk.yellow(
+            `${importStatement.file}:${importStatement.line}:${importStatement.column}  ${importStatement.from}`
+          )
+        );
+      });
+    }
+    return { tableImports: imports, tableFiles: files };
   }
 }
 
-async function unUsedFiles(directory = "src", options) {
-    const contentPaths = [`${directory}/**/*.{tsx,ts,js,jsx}`];
-    if (options.excludeDir && options.excludeDir.length > 0) {
-        options.excludeDir.forEach(dir => {
-            contentPaths.push(`!${dir}/**`);
-        });
-    }
-    if (options.excludeFile && options.excludeFile.length > 0) {
-        options.excludeFile.forEach(file => {
-            contentPaths.push(`!${directory}/**/${file}`);
-        });
-    }
-    
-    const files = await fg(contentPaths);
-    const imports = [];
-    const unusedFiles = [];
-    for (const file of files) {
-      const code = fs.readFileSync(file, "utf8");
+async function unUsedFiles(chalk, directory = "src", options) {
+  console.time('unUsedFiles');
+  const resolver = createResolver(directory);
+  const cache = loadCache(process.cwd());
+  const contentPaths = [`${directory}/**/*.{tsx,ts,js,jsx}`];
+  if (options.excludeDir && options.excludeDir.length > 0) {
+    options.excludeDir.forEach((dir) => {
+      contentPaths.push(`!${dir}/**`);
+    });
+  }
+  if (options.excludeFile && options.excludeFile.length > 0) {
+    options.excludeFile.forEach((file) => {
+      contentPaths.push(`!${directory}/**/${file}`);
+    });
+  }
+
+  const files = await fg(contentPaths);
+  const imports = [];
+  const unusedFiles = [];
+
+  // debug log
+  // let debugCount = 0;
+  // console.log('total files---', files.length);
+  for (const file of files) {
+    const code = fs.readFileSync(file, "utf8");
+    if(needsRebuild(file, code, cache)) {
       const ast = parser.parse(code, {
         sourceType: "module",
-        plugins: [
-          "jsx",
-          "typescript",
-        ],
+        plugins: ["jsx", "typescript"],
       });
-  
+      cache[file] = {
+        hash: getFileHash(code),
+        imports: [],
+        isImported: false,
+        lastModified: fs.statSync(file).mtime.getTime(),
+      };
       traverse(ast, {
         ImportDeclaration: ({ node }) => {
           imports.push({
-              from: node.source.value,
-              file: file,
-              line: node.loc.start.line,
-              column: node.loc.start.column,
+            from: node.source.value,
+            file: file,
+            line: node.loc.start.line,
+            column: node.loc.start.column,
+          });
+          cache[file].imports.push({
+            from: node.source.value,
+            file: file,
+            line: node.loc.start.line,
+            column: node.loc.start.column,
+            lastModified: fs.statSync(file).mtime.getTime(),
           });
         },
       });
+    }else {
+      // debugCount++;
+      // console.log('cache hit', debugCount);
     }
+  }
 
-    // console.log('imports', imports);
-    // console.log('files', files);
-    for (const file of files) {
-        let i = 0;
-        // console.log('Checking', file);
-        let isFound = false;
-        while (!isFound && i < imports.length) {
-            
-            if (compareFiles(file, imports[i].from)) {
-                isFound = true;
-                break;
-            }else if(i === imports.length - 1) {
-                if(options.excludeFilePrint && options.excludeFilePrint.length > 0) {
-                    if(!isExcludedFile(file, options.excludeFilePrint)){
-                        unusedFiles.push(file); 
-                    }
-                }else {
-                    unusedFiles.push(file);
-                }
-                break;
+  // console.log('imports', imports);
+  // console.log('files', files);
+  // debugCount = 0;
+  // console.log('total files', files.length);
+  for (const file of files) {
+    const code = fs.readFileSync(file, "utf8");
+    if(!cache[file].isImported || needsRebuild(file, code, cache)) {
+      let i = 0;
+      // console.log('Checking', file);
+      let isFound = false;
+      while (!isFound && i < imports.length) {
+        const importFilePath = await resolver(
+          chalk,
+          imports[i].file,
+          imports[i].from
+        );
+        // console.log(chalk.blue('importFilePath'), importFilePath);
+        if (compareFiles(path.resolve(file), importFilePath)) {
+          isFound = true;
+          cache[file].isImported = true;
+          break;
+        } else if (i === imports.length - 1) {
+          if (options.excludeFilePrint && options.excludeFilePrint.length > 0) {
+            if (!isExcludedFile(file, options.excludeFilePrint)) {
+              unusedFiles.push(file);
             }
-            i++;
+          } else {
+            unusedFiles.push(file);
+          }
+          break;
         }
+        i++;
+      }
+    }else {
+      // debugCount++;
+      // console.log('debug hit', debugCount);
     }
-    return unusedFiles;
+  }
+  console.timeEnd('unUsedFiles');
+  saveCache(process.cwd(), cache);
+  return unusedFiles;
 }
 
 function isExcludedFile(file, excludeFiles) {
-    return excludeFiles.some(exclude => file.includes(exclude));
+  return excludeFiles.some((exclude) => file.includes(exclude));
 }
 
-function compareFiles(filePath, importPath) {  
-    const importNoExt = importPath.replace(/\.[^/.]+$/, "");
-    const prefixImportPath = importNoExt.replace(/^(?:\.{1,2}\/|[@~]+\/)+/, "");
-    // console.log('importNoExt', importNoExt, '  prefixImportPath', prefixImportPath, '  filePath', filePath, '  ', filePath.includes(prefixImportPath));
-    
-    return  filePath.includes(prefixImportPath);
+function compareFiles(filePath, importPath) {
+  return filePath === importPath;
 }
 
 module.exports = {
   getFiles,
   unUsedFiles,
-};
+};

package/controllers/list.js

@@ -0,0 +1,60 @@
+const { getFiles, unUsedFiles } = require("../command");
+const Table = require('cli-table3');
+const askDeleteFiles = require("../utils/utils");
+
+
+async function list(chalk, path, options) {
+    const { tableImports, tableFiles } = await getFiles(path, options, chalk);
+    if(options.table){
+      console.log(chalk.yellow('***************** Imported Files *****************'));
+      console.log(tableImports.toString());
+      console.log(chalk.green('***************** List Files *****************'));
+      console.log(tableFiles.toString());
+    }
+}
+
+async function scan(chalk, path, options) {
+    const unusedFiles = await unUsedFiles(chalk,path, options);
+    // console.clear()
+    
+    if (options.dryRun) {
+      console.log(chalk.cyan('\n[DRY RUN MODE] No files will be deleted\n'));
+    }
+    
+    if(options.table){
+      const table = new Table({
+          head: options.dryRun ? ['Unused Files (Would Delete)'] : ['Unused Files'],
+          colWidths: [50]
+      })
+      unusedFiles.forEach(file => {
+          table.push([file])
+      })
+      console.log(table.toString())
+
+    }else {
+      unusedFiles.forEach((file) => {
+          console.log(chalk.red(file));
+        });
+    }
+    
+    if (options.dryRun && unusedFiles.length > 0) {
+      console.log(chalk.cyan(`\n[DRY RUN] Would delete ${unusedFiles.length} file(s)`));
+      console.log(chalk.cyan('Run without --dry-run to actually delete files\n'));
+    } else if (!options.dryRun && unusedFiles.length > 0) {
+      askDeleteFiles(unusedFiles);
+    }
+}
+
+async function image(chalk, path, options) {
+    const unusedImages = await unUsedImages(chalk,path, options);
+    if(options.table){
+      console.log(chalk.yellow('***************** Unused Images *****************'));
+      console.log(unusedImages.toString());
+    }
+}
+
+
+module.exports = {
+  list,
+  scan
+};

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "qleaner",
   "packageManager": "yarn@4.6.0",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "main": "command.js",
   "bin": "./bin/cli.js",
   "scripts": {
-    "start": "node ./bin/cli.js"
+    "start": "node ./bin/cli.js",
+    "resolve": "node ./utils/resolver.js"
   },
   "devDependencies": {
     "@types/node": "^20.10.5",
@@ -17,6 +18,8 @@
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
     "commander": "^14.0.2",
-    "fast-glob": "^3.3.3"
+    "enhanced-resolve": "^5.18.3",
+    "fast-glob": "^3.3.3",
+    "prompts": "^2.4.2"
   }
 }

package/unused-check-cache.json

@@ -0,0 +1,180 @@
+{
+  "src/hello.find.tsx": {
+    "hash": "13088ef1169a758d26b7fde99ca67d5a",
+    "imports": [
+      {
+        "from": "./demo/functions",
+        "file": "src/hello.find.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380790
+      },
+      {
+        "from": "~/demo/book/hidden",
+        "file": "src/hello.find.tsx",
+        "line": 2,
+        "column": 0,
+        "lastModified": 1764776380790
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764776380790
+  },
+  "src/jambo.tsx": {
+    "hash": "6b9a7f99ad2bd68e567368a35bc2831c",
+    "imports": [
+      {
+        "from": "./demo/functions",
+        "file": "src/jambo.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380792
+      },
+      {
+        "from": "hello.find",
+        "file": "src/jambo.tsx",
+        "line": 2,
+        "column": 0,
+        "lastModified": 1764776380792
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764776380792
+  },
+  "src/main.js": {
+    "hash": "961f4425237e1551bb8ec8a136f12a66",
+    "imports": [
+      {
+        "from": "jambo",
+        "file": "src/main.js",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380796
+      },
+      {
+        "from": "poa",
+        "file": "src/main.js",
+        "line": 2,
+        "column": 0,
+        "lastModified": 1764776380796
+      },
+      {
+        "from": "./style.css",
+        "file": "src/main.js",
+        "line": 3,
+        "column": 0,
+        "lastModified": 1764776380796
+      },
+      {
+        "from": "./demo/demo",
+        "file": "src/main.js",
+        "line": 4,
+        "column": 0,
+        "lastModified": 1764776380796
+      },
+      {
+        "from": "./jambo",
+        "file": "src/main.js",
+        "line": 5,
+        "column": 0,
+        "lastModified": 1764776380796
+      },
+      {
+        "from": "@/demo/book/hidden",
+        "file": "src/main.js",
+        "line": 6,
+        "column": 0,
+        "lastModified": 1764776380796
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764776380796
+  },
+  "src/poa.tsx": {
+    "hash": "09d1c8072d500780c9d6b223f5609cc5",
+    "imports": [
+      {
+        "from": "one.png",
+        "file": "src/poa.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380809
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764776380809
+  },
+  "src/demo/demo.tsx": {
+    "hash": "fe20d628c85aad8b491b3e45e6559ce4",
+    "imports": [
+      {
+        "from": "../hello.find",
+        "file": "src/demo/demo.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764828590237
+      },
+      {
+        "from": "../demo/book/hidden",
+        "file": "src/demo/demo.tsx",
+        "line": 2,
+        "column": 0,
+        "lastModified": 1764828590237
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764828590237
+  },
+  "src/demo/functions.js": {
+    "hash": "091a10616a5be2b7c7803a3f7513453e",
+    "imports": [],
+    "isImported": true,
+    "lastModified": 1764776380788
+  },
+  "src/demo/public.tsx": {
+    "hash": "d41d8cd98f00b204e9800998ecf8427e",
+    "imports": [],
+    "isImported": false,
+    "lastModified": 1764690373726
+  },
+  "src/shell/main.js": {
+    "hash": "d41d8cd98f00b204e9800998ecf8427e",
+    "imports": [],
+    "isImported": false,
+    "lastModified": 1764822800241
+  },
+  "src/demo/book/hidden.tsx": {
+    "hash": "6c3fb783f6f246ad67252489ba9367f4",
+    "imports": [
+      {
+        "from": "../../main",
+        "file": "src/demo/book/hidden.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380785
+      }
+    ],
+    "isImported": true,
+    "lastModified": 1764776380785
+  },
+  "src/demo/book/public.tsx": {
+    "hash": "d41d8cd98f00b204e9800998ecf8427e",
+    "imports": [],
+    "isImported": false,
+    "lastModified": 1764690329997
+  },
+  "src/layer/shell/shell.tsx": {
+    "hash": "659029bd48113a93f0ce44bc1e8005d3",
+    "imports": [
+      {
+        "from": "../../demo/book/hidden",
+        "file": "src/layer/shell/shell.tsx",
+        "line": 1,
+        "column": 0,
+        "lastModified": 1764776380795
+      }
+    ],
+    "isImported": false,
+    "lastModified": 1764776380795
+  }
+}

package/utils/cache.js

@@ -0,0 +1,38 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+
+function loadCache(rootPath) {
+    const file = path.join(rootPath, "unused-check-cache.json");
+    if(!fs.existsSync(file)) return {};
+
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'))
+    } catch{
+        return {};
+    }
+}
+
+function getFileHash(content) {
+    return crypto.createHash('md5').update(content).digest('hex');
+}
+
+
+function needsRebuild(file, content, cache) {
+    const hash = getFileHash(content);
+    return !cache[file] || cache[file].hash !== hash
+}
+
+
+function saveCache(rootPath, cache) {
+    const file = path.join(rootPath, "unused-check-cache.json");
+    fs.writeFileSync(file, JSON.stringify(cache, null, 2))
+}
+
+module.exports = {
+    loadCache,
+    getFileHash,
+    needsRebuild,
+    saveCache
+}

package/utils/resolver.js

@@ -0,0 +1,32 @@
+const path = require('path');
+const {create} = require('enhanced-resolve');
+
+
+function createResolver(directory) {
+const resolver = create({
+    extensions: [".js", ".jsx", ".ts", ".tsx"],
+    alias: {
+      "@": path.resolve(directory),
+      "~": path.resolve(directory)
+    },
+    mainFiles: ["index"],
+    // Where resolution begins
+    modules: [
+        path.resolve(directory)
+    ]
+  });
+
+  return function resolveImport(chalk,sourceFile, importPath) {
+    // console.log(chalk.yellow('sourceFile--resolver'), sourceFile, chalk.yellow('importPath--resolver'), importPath);
+    return new Promise((resolve, reject) => {
+      resolver(path.dirname(sourceFile), importPath, (err, result) => {
+        if (err) return resolve(null);
+        resolve(path.resolve(result));
+      });
+    });
+  }
+}
+
+module.exports = {
+  createResolver
+};

package/utils/utils.js

@@ -0,0 +1,56 @@
+const prompts = require('prompts');
+const fs = require('fs');
+const path = require('path');
+
+async function askDeleteFiles(files) {
+    const response = await prompts({
+        type: 'multiselect',
+        name: 'toDelete',
+        message: 'Select unused files to delete or move to .trash directory',
+        choices: files.map(file => ({
+            title: file,
+            value: file,
+        })) 
+    })
+    if(response && response.toDelete && response.toDelete.length > 0) {
+        const method = await prompts({
+            type: 'select',
+            name: 'method',
+            message: 'Select a method to delete the files',
+            choices: [
+                { title: 'Move to .trash directory', value: 'moveToTrash' },
+                { title: 'Delete files', value: 'deleteFiles' },
+            ]
+        })
+        if(method.method === 'moveToTrash') {
+            return await moveToTrash(response.toDelete);
+        } else if(method.method === 'deleteFiles') {
+            return await deleteFiles(response.toDelete);
+        }
+    }
+}
+
+async function moveToTrash(files) {
+    const trashDir = path.join(process.cwd(), '.trash');
+
+    if(!fs.existsSync(trashDir)) {
+        fs.mkdirSync(trashDir);
+    }
+
+    for(const file of files) {
+       const fileName = path.basename(file);
+       const destination = path.join(trashDir, fileName);
+       fs.renameSync(file, destination);
+    }
+
+    console.log(`Moved ${files.length} files to .trash directory`);
+}
+
+async function deleteFiles(files) {
+    for(const file of files) {
+        fs.unlinkSync(file);
+    }
+    console.log(`Deleted ${files.length} files`);
+}
+
+module.exports = askDeleteFiles;