pruny 1.0.6 → 1.0.7

package/README.md

@@ -29,6 +29,17 @@ pruny --json
 pruny -v
 ```
 
+### Public Asset Scanning (New in v1.1.0)
+
+Pruny automatically scans your `public/` directory for unused images and files.
+
+- **Enabled by default**: Run `npx pruny` and it will show unused assets, excluding ignored folders.
+- **Disable it**: Use `--no-public` flag.
+  ```bash
+  pruny --no-public
+  ```
+- **How it works**: It checks if filenames in `public/` (e.g., `logo.png` or `/images/logo.png`) are referenced in your code.
+
 ## Config
 
 Create `pruny.config.json` (optional):

package/docs/index.md

@@ -3,7 +3,11 @@
 > Find and remove unused Next.js API routes.
 
 ## Summary
-Pruny is a CLI tool that scans Next.js projects (App Router) to identify API routes that are not referenced in the codebase. It supports auto-detection of usage via `fetch`, `axios`, and `useSWR`, and respects `vercel.json` cron jobs.
+Pruny is a CLI tool that scans Next.js projects (App Router) to identify:
+1. **Unused API Routes**: Endpoints not referenced in the codebase.
+2. **Unused Public Assets**: Images and files in `public/` that are never used.
+
+It supports auto-detection of usage via `fetch`, `axios`, `useSWR`, and respects `vercel.json` cron jobs.
 
 ## Installation
 

package/llms.txt

@@ -3,7 +3,11 @@
 > Find and remove unused Next.js API routes.
 
 ## Summary
-Pruny is a CLI tool that scans Next.js projects (App Router) to identify API routes that are not referenced in the codebase. It supports auto-detection of usage via `fetch`, `axios`, and `useSWR`, and respects `vercel.json` cron jobs.
+Pruny is a CLI tool that scans Next.js projects (App Router) to identify:
+1. **Unused API Routes**: Endpoints not referenced in the codebase.
+2. **Unused Public Assets**: Images and files in `public/` that are never used.
+
+It supports auto-detection of usage via `fetch`, `axios`, `useSWR`, and respects `vercel.json` cron jobs.
 
 ## Installation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pruny",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Find and remove unused Next.js API routes",
   "type": "module",
   "bin": {

package/src/config.ts

@@ -15,6 +15,7 @@ const DEFAULT_CONFIG: Config = {
 interface CLIOptions {
   dir?: string;
   config?: string;
+  excludePublic?: boolean;
 }
 
 /**
@@ -38,11 +39,21 @@ export function loadConfig(options: CLIOptions): Config {
   return {
     dir: options.dir || fileConfig.dir || DEFAULT_CONFIG.dir,
     ignore: {
-      routes: fileConfig.ignore?.routes || DEFAULT_CONFIG.ignore.routes,
-      folders: fileConfig.ignore?.folders || DEFAULT_CONFIG.ignore.folders,
-      files: fileConfig.ignore?.files || DEFAULT_CONFIG.ignore.files,
+      routes: [
+        ...(DEFAULT_CONFIG.ignore.routes || []),
+        ...(fileConfig.ignore?.routes || []),
+      ],
+      folders: [
+        ...(DEFAULT_CONFIG.ignore.folders || []),
+        ...(fileConfig.ignore?.folders || []),
+      ],
+      files: [
+        ...(DEFAULT_CONFIG.ignore.files || []),
+        ...(fileConfig.ignore?.files || []),
+      ],
     },
     extensions: fileConfig.extensions || DEFAULT_CONFIG.extensions,
+    excludePublic: options.excludePublic ?? fileConfig.excludePublic ?? false,
   };
 }
 

package/src/index.ts

@@ -17,11 +17,13 @@ program
   .option('--fix', 'Delete unused API routes')
   .option('-c, --config <path>', 'Path to config file')
   .option('--json', 'Output as JSON')
+  .option('--no-public', 'Disable public assets scanning')
   .option('-v, --verbose', 'Show detailed info')
   .action(async (options) => {
     const config = loadConfig({
       dir: options.dir,
       config: options.config,
+      excludePublic: !options.public, // commander handles --no-public as public: false
     });
 
     // Resolve absolute path
@@ -51,27 +53,45 @@ program
       console.log(`   Total routes:  ${result.total}`);
       console.log(chalk.green(`   Used routes:   ${result.used}`));
       console.log(chalk.red(`   Unused routes: ${result.unused}`));
+      
+      if (result.publicAssets) {
+        console.log('');
+        console.log(chalk.bold('🖼️  Public Assets'));
+        console.log(`   Total assets:  ${result.publicAssets.total}`);
+        console.log(chalk.green(`   Used assets:   ${result.publicAssets.used}`));
+        console.log(chalk.red(`   Unused assets: ${result.publicAssets.unused}`));
+      }
       console.log('');
 
-      if (result.total === 0) {
+      // 1. API Routes Logic
+      const unusedRoutes = result.routes.filter((r) => !r.used);
+      if (unusedRoutes.length > 0) {
+        console.log(chalk.red.bold('❌ Unused API Routes:\n'));
+        for (const route of unusedRoutes) {
+          console.log(chalk.red(`   ${route.path}`));
+          console.log(chalk.dim(`      → ${route.filePath}`));
+        }
+        console.log('');
+      } else if (result.total === 0) {
         console.log(chalk.yellow('⚠️  No API routes found.\n'));
-        return;
-      }
-
-      const unused = result.routes.filter((r) => !r.used);
-
-      if (unused.length === 0) {
+      } else {
         console.log(chalk.green('✅ All API routes are used!\n'));
-        return;
       }
 
-      // List unused routes
-      console.log(chalk.red.bold('❌ Unused routes:\n'));
-      for (const route of unused) {
-        console.log(chalk.red(`   ${route.path}`));
-        console.log(chalk.dim(`      → ${route.filePath}`));
+      // 2. Public Assets Logic
+      if (result.publicAssets) {
+        const unusedAssets = result.publicAssets.assets.filter(a => !a.used);
+        if (unusedAssets.length > 0) {
+          console.log(chalk.red.bold('❌ Unused Public Assets:\n'));
+          for (const asset of unusedAssets) {
+            console.log(chalk.red(`   ${asset.relativePath}`));
+            console.log(chalk.dim(`      → ${asset.path}`));
+          }
+          console.log('');
+        } else if (result.publicAssets.total > 0) {
+          console.log(chalk.green('✅ All public assets are used!\n'));
+        }
       }
-      console.log('');
 
       // Show used routes in verbose mode
       if (options.verbose) {
@@ -97,24 +117,28 @@ program
 
       // --fix: Delete unused routes
       if (options.fix) {
-        console.log(chalk.yellow.bold('🗑️  Deleting unused routes...\n'));
-
-        for (const route of unused) {
-          const routeDir = dirname(join(config.dir, route.filePath));
-          try {
-            rmSync(routeDir, { recursive: true, force: true });
-            console.log(chalk.red(`   Deleted: ${route.filePath}`));
-          } catch (err) {
-            console.log(
-              chalk.yellow(`   Failed to delete: ${route.filePath}`)
-            );
+        if (unusedRoutes.length > 0) {
+          console.log(chalk.yellow.bold('🗑️  Deleting unused routes...\n'));
+
+          for (const route of unusedRoutes) {
+            const routeDir = dirname(join(config.dir, route.filePath));
+            try {
+              rmSync(routeDir, { recursive: true, force: true });
+              console.log(chalk.red(`   Deleted: ${route.filePath}`));
+            } catch (err) {
+              console.log(
+                chalk.yellow(`   Failed to delete: ${route.filePath}`)
+              );
+            }
           }
-        }
 
-        console.log(
-          chalk.green(`\n✅ Deleted ${unused.length} unused route(s).\n`)
-        );
-      } else {
+          console.log(
+            chalk.green(`\n✅ Deleted ${unusedRoutes.length} unused route(s).\n`)
+          );
+        } else {
+          console.log(chalk.yellow('No unused routes to delete.\n'));
+        }
+      } else if (unusedRoutes.length > 0) {
         console.log(
           chalk.dim('💡 Run with --fix to delete unused routes.\n')
         );

package/src/scanner.ts

@@ -179,10 +179,18 @@ export async function scan(config: Config): Promise<ScanResult> {
     }
   }
 
+  // 7. Scan public assets (if not excluded)
+  let publicAssets;
+  if (!config.excludePublic) {
+    const { scanPublicAssets } = await import('./scanners/public-assets.js');
+    publicAssets = await scanPublicAssets(config);
+  }
+
   return {
     total: routes.length,
     used: routes.filter((r) => r.used).length,
     unused: routes.filter((r) => !r.used).length,
     routes,
+    publicAssets,
   };
 }

package/src/scanners/public-assets.ts

@@ -0,0 +1,89 @@
+import fg from 'fast-glob';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import type { Config } from '../types.js';
+
+export interface PublicAsset {
+  path: string;        // Absolute path
+  relativePath: string; // Path relative to public/ (e.g., 'images/logo.png')
+  used: boolean;
+  references: string[];
+}
+
+export interface PublicScanResult {
+  total: number;
+  used: number;
+  unused: number;
+  assets: PublicAsset[];
+}
+
+/**
+ * Scan for unused assets in public directory
+ */
+export async function scanPublicAssets(config: Config): Promise<PublicScanResult> {
+  const cwd = config.dir;
+  const publicDir = join(cwd, 'public');
+
+  if (!existsSync(publicDir)) {
+    return { total: 0, used: 0, unused: 0, assets: [] };
+  }
+
+  // 1. Find all files in public directory
+  const assetFiles = await fg('**/*', {
+    cwd: publicDir,
+    ignore: config.ignore.folders || [],
+    onlyFiles: true,
+  });
+
+  if (assetFiles.length === 0) {
+    return { total: 0, used: 0, unused: 0, assets: [] };
+  }
+
+  // 2. Build asset map
+  const assets: PublicAsset[] = assetFiles.map((file) => ({
+    path: join(publicDir, file),
+    relativePath: '/' + file, // e.g., /images/logo.png
+    used: false,
+    references: [],
+  }));
+
+  // 3. Find all source files to scan
+  const extGlob = `**/*{${config.extensions.join(',')}}`;
+  const sourceFiles = await fg(extGlob, {
+    cwd,
+    ignore: [...config.ignore.folders, ...config.ignore.files, 'public/**'],
+  });
+
+  // 4. Scan source files for references
+  for (const file of sourceFiles) {
+    const filePath = join(cwd, file);
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      
+      for (const asset of assets) {
+        if (asset.used) continue; // Optimization: stop checking if already found (unless we want all refs)
+
+        // Check for exact path match (e.g. "/images/logo.png")
+        // We match strict usage to avoid false positives
+        if (content.includes(asset.relativePath)) {
+          asset.used = true;
+          asset.references.push(file);
+        } else {
+             // Also check for filename only usage if it's unique enough? 
+             // For now, sticking to relative path for safety to avoid false positives.
+             // Maybe simple version: check if just filename exists? 
+             // Common pattern: src="/images/logo.png"
+        }
+      }
+    } catch {
+      // Skip unreadable files
+    }
+  }
+
+  return {
+    total: assets.length,
+    used: assets.filter((a) => a.used).length,
+    unused: assets.filter((a) => !a.used).length,
+    assets,
+  };
+}

package/src/types.ts

@@ -8,6 +8,7 @@ export interface Config {
   dir: string;
   ignore: IgnoreConfig;
   extensions: string[];
+  excludePublic?: boolean;
 }
 
 export interface ApiRoute {
@@ -26,6 +27,17 @@ export interface ScanResult {
   used: number;
   unused: number;
   routes: ApiRoute[];
+  publicAssets?: {
+    total: number;
+    used: number;
+    unused: number;
+    assets: {
+      path: string;
+      relativePath: string;
+      used: boolean;
+      references: string[];
+    }[];
+  };
 }
 
 export interface VercelConfig {