assets-tracker 1.0.0

package/README.md

@@ -0,0 +1,102 @@
+# 🚀 Assets Tracker
+
+[![npm version](https://img.shields.io/npm/v/assets-tracker.svg)](https://www.npmjs.com/package/assets-tracker)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Clean up your codebase and shrink your bundle size with the ultimate unused assets detector.**
+
+`assets-tracker` is a modern, high-performance CLI tool designed to identify and remove unreferenced assets from your project. Whether it's a forgotten hero image, an unused font file, or a legacy video asset, this tool helps you keep your repository lean and efficient.
+
+---
+
+## ✨ Features
+
+- 🔍 **Deep Scan**: Identifies unused images, videos, fonts, and more across your entire project.
+- 🛠️ **Smart Analysis**: Scans your source files (JS, TS, HTML, CSS, etc.) to detect asset references.
+- 🏢 **Modern CLI**: Beautiful, interactive terminal interface with progress indicators and formatted reports.
+- 🧹 **Interactive Cleanup**: Choose to delete all unused assets at once or select specific files to remove safely.
+- 📦 **Dev-Friendly**: Zero configuration needed. Works out of the box with standard project structures.
+- 📉 **Size Reports**: View exactly how much space you can save.
+
+---
+
+## 🚀 Installation
+
+Install it as a dev dependency in your project:
+
+```bash
+npm install --save-dev assets-tracker
+# or
+yarn add -D assets-tracker
+# or
+pnpm add -D assets-tracker
+```
+
+---
+
+## 📖 Usage
+
+### 🔍 Scan for Unused Assets
+Run a full scan to see what can be removed:
+
+```bash
+npx assets-tracker scan
+```
+
+### 🧹 Clean Up Unused Assets
+Start an interactive session to select and delete unused files:
+
+```bash
+npx assets-tracker clean
+```
+
+---
+
+## 📂 Supported Asset Types
+
+- **Images**: `.png`, `.jpg`, `.jpeg`, `.gif`, `.svg`, `.webp`, `.ico`
+- **Video/Audio**: `.mp4`, `.webm`, `.ogg`, `.mp3`, `.wav`, `.flac`, `.aac`
+- **Fonts**: `.woff`, `.woff2`, `.eot`, `.ttf`, `.otf`
+
+---
+
+## 🧠 How It Works
+
+1. **Discovery**: The tool builds a list of all asset files in your project (excluding `node_modules`, `dist`, `.git`, etc.).
+2. **Analysis**: It then parses your source code files to search for any mention of the asset's filename or relative path.
+3. **Reporting**: Assets that aren't mentioned anywhere are marked as "unused".
+4. **Action**: You get a detailed report and the option to delete them securely.
+
+---
+
+## 🛠️ Configuration (Coming Soon)
+
+We are working on adding a `.assettracker.json` config file to allow:
+- Custom asset extensions.
+- Custom source directories.
+- Exclusion patterns.
+
+---
+
+---
+
+## 👥 Authors
+
+- **Dheeraj & Vaibhav**
+
+## 🤝 Contributors
+
+- **Dheeraj Khush** - [GitHub](https://github.com/DheerajKhush)
+- **Vaibhav Khushalani** - [GitHub](https://github.com/VaibhavKhushalani)
+
+Feel free to check the [issues page](https://github.com/yourusername/assets-tracker/issues).
+
+## 📄 License
+
+This project is [MIT](https://opensource.org/licenses/MIT) licensed.
+
+---
+
+<p align="center">
+  Built with ❤️ for the developer community.
+</p>

package/dist/analyzer.d.ts

@@ -0,0 +1,6 @@
+import { AssetFile } from './scanner.js';
+export interface ScanResult {
+    unusedAssets: AssetFile[];
+    totalUnusedSize: number;
+}
+export declare function analyzeUnusedAssets(assets: AssetFile[], sourceFiles: string[]): Promise<ScanResult>;

package/dist/analyzer.js

@@ -0,0 +1,32 @@
+import fs from 'fs-extra';
+export async function analyzeUnusedAssets(assets, sourceFiles) {
+    const unusedAssets = [...assets];
+    // We'll read each source file once and check all assets against it.
+    // This is more efficient than reading every source file for each asset.
+    for (const sourceFile of sourceFiles) {
+        if (unusedAssets.length === 0)
+            break;
+        const content = await fs.readFile(sourceFile, 'utf8');
+        // Check which assets are referenced in this file
+        for (let i = unusedAssets.length - 1; i >= 0; i--) {
+            const asset = unusedAssets[i];
+            // Simple heuristic: check if filename or relative path is in content
+            // We use word boundaries for filename to avoid false positives 
+            // (like 'icon.png' matching 'large-icon.png')
+            // Note: This matches common patterns like:
+            // - src="path/to/asset.png"
+            // - url('path/to/asset.png')
+            // - import asset from './path/to/asset.png'
+            const fileNameEscaped = asset.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const fileNameRegex = new RegExp(`\\b${fileNameEscaped}\\b`, 'i');
+            if (content.includes(asset.path) || fileNameRegex.test(content)) {
+                unusedAssets.splice(i, 1);
+            }
+        }
+    }
+    const totalUnusedSize = unusedAssets.reduce((sum, asset) => sum + asset.size, 0);
+    return {
+        unusedAssets,
+        totalUnusedSize
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import fs from 'fs-extra';
+import inquirer from 'inquirer';
+import { findAssets, findSourceFiles } from './scanner.js';
+import { analyzeUnusedAssets } from './analyzer.js';
+import { logger, createSpinner, formatAssetTable } from './ui.js';
+import chalk from 'chalk';
+const program = new Command();
+program
+    .name('assets-tracker')
+    .description('Modern CLI tool to track and cleanup unused assets')
+    .version('1.0.0');
+async function runScan(cwd) {
+    logger.banner();
+    const spinner = createSpinner('Scanning files...').start();
+    try {
+        const assets = await findAssets(cwd);
+        const sourceFiles = await findSourceFiles(cwd);
+        spinner.text = 'Analyzing references...';
+        const result = await analyzeUnusedAssets(assets, sourceFiles);
+        spinner.stop();
+        formatAssetTable(result.unusedAssets);
+        return result;
+    }
+    catch (error) {
+        spinner.fail('Error during scan: ' + error.message);
+        process.exit(1);
+    }
+}
+program
+    .command('scan')
+    .description('Scan the codebase for unused assets and report them')
+    .action(async () => {
+    await runScan(process.cwd());
+});
+program
+    .command('clean')
+    .description('Scan and provide an interactive way to delete unused assets')
+    .action(async () => {
+    const result = await runScan(process.cwd());
+    if (!result || result.unusedAssets.length === 0)
+        return;
+    const { action } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'action',
+            message: 'How would you like to proceed?',
+            choices: [
+                { name: chalk.red('Delete all unused assets'), value: 'all' },
+                { name: chalk.yellow('Select assets to delete'), value: 'select' },
+                { name: 'Cancel', value: 'cancel' }
+            ]
+        }
+    ]);
+    if (action === 'cancel') {
+        logger.info('Clean aborted.');
+        return;
+    }
+    let toDelete = result.unusedAssets;
+    if (action === 'select') {
+        const { selected } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'selected',
+                message: 'Select assets to remove:',
+                choices: result.unusedAssets.map(a => ({
+                    name: `${a.name} (${a.path})`,
+                    value: a
+                }))
+            }
+        ]);
+        toDelete = selected;
+    }
+    if (toDelete.length === 0) {
+        logger.info('No assets selected for deletion.');
+        return;
+    }
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: chalk.red.bold(`Are you sure you want to delete ${toDelete.length} assets?`),
+            default: false
+        }
+    ]);
+    if (confirm) {
+        const deleteSpinner = createSpinner('Deleting assets...').start();
+        try {
+            for (const asset of toDelete) {
+                await fs.remove(asset.absolutePath);
+            }
+            deleteSpinner.succeed(`Successfully deleted ${toDelete.length} assets.`);
+        }
+        catch (error) {
+            deleteSpinner.fail('Error during deletion: ' + error.message);
+        }
+    }
+    else {
+        logger.info('Deletion cancelled.');
+    }
+});
+program.parse(process.argv);
+// If no arguments, show help
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/scanner.d.ts

@@ -0,0 +1,12 @@
+export declare const DEFAULT_ASSET_EXTENSIONS: string[];
+export declare const DEFAULT_SOURCE_EXTENSIONS: string[];
+export declare const DEFAULT_IGNORE: string[];
+export interface AssetFile {
+    name: string;
+    path: string;
+    absolutePath: string;
+    size: number;
+    extension: string;
+}
+export declare function findAssets(cwd: string, extensions?: string[]): Promise<AssetFile[]>;
+export declare function findSourceFiles(cwd: string, extensions?: string[]): Promise<string[]>;

package/dist/scanner.js

@@ -0,0 +1,49 @@
+import { globby } from 'globby';
+import path from 'path';
+import fs from 'fs-extra';
+export const DEFAULT_ASSET_EXTENSIONS = [
+    'png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'ico',
+    'mp4', 'webm', 'ogg', 'mp3', 'wav', 'flac', 'aac',
+    'woff', 'woff2', 'eot', 'ttf', 'otf'
+];
+export const DEFAULT_SOURCE_EXTENSIONS = [
+    'js', 'ts', 'jsx', 'tsx', 'html', 'css', 'scss', 'sass', 'less', 'vue', 'svelte', 'json'
+];
+export const DEFAULT_IGNORE = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.next/**',
+    '**/coverage/**',
+    '**/package.json',
+    '**/package-lock.json',
+    '**/tsconfig.json'
+];
+export async function findAssets(cwd, extensions = DEFAULT_ASSET_EXTENSIONS) {
+    const patterns = extensions.map(ext => `**/*.${ext}`);
+    const files = await globby(patterns, {
+        cwd,
+        ignore: DEFAULT_IGNORE,
+        absolute: true
+    });
+    return Promise.all(files.map(async (file) => {
+        const stats = await fs.stat(file);
+        const relPath = path.relative(cwd, file);
+        return {
+            name: path.basename(file),
+            path: relPath,
+            absolutePath: file,
+            size: stats.size,
+            extension: path.extname(file).slice(1)
+        };
+    }));
+}
+export async function findSourceFiles(cwd, extensions = DEFAULT_SOURCE_EXTENSIONS) {
+    const patterns = extensions.map(ext => `**/*.${ext}`);
+    return globby(patterns, {
+        cwd,
+        ignore: DEFAULT_IGNORE,
+        absolute: true
+    });
+}

package/dist/ui.d.ts

@@ -0,0 +1,12 @@
+import { AssetFile } from './scanner.js';
+export declare const logger: {
+    info: (msg: string) => void;
+    success: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    dim: (msg: string) => void;
+    bold: (msg: string) => void;
+    banner: () => void;
+};
+export declare function createSpinner(text: string): import("ora").Ora;
+export declare function formatAssetTable(assets: AssetFile[]): void;

package/dist/ui.js

@@ -0,0 +1,44 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { filesize } from 'filesize';
+export const logger = {
+    info: (msg) => console.log(chalk.blue('ℹ ') + msg),
+    success: (msg) => console.log(chalk.green('✔ ') + msg),
+    warn: (msg) => console.log(chalk.yellow('⚠ ') + msg),
+    error: (msg) => console.log(chalk.red('✖ ') + msg),
+    dim: (msg) => console.log(chalk.dim(msg)),
+    bold: (msg) => console.log(chalk.bold(msg)),
+    banner: () => {
+        console.log('\n' + chalk.cyan.bold('  🚀 Assets Tracker') + chalk.dim(' - Cleanup unused assets') + '\n');
+    }
+};
+export function createSpinner(text) {
+    return ora({
+        text,
+        color: 'cyan',
+        spinner: 'dots'
+    });
+}
+export function formatAssetTable(assets) {
+    if (assets.length === 0) {
+        logger.success('No unused assets found! Your project is clean. ✨');
+        return;
+    }
+    logger.bold(`\nFound ${assets.length} unused assets:\n`);
+    // Simple table formatting
+    const headers = ['NAME', 'TYPE', 'SIZE', 'PATH'];
+    const columnWidths = [20, 8, 12, 40];
+    const headerRow = headers.map((h, i) => chalk.bold.underline(h.padEnd(columnWidths[i]))).join(' ');
+    console.log(headerRow);
+    assets.forEach(asset => {
+        const row = [
+            chalk.cyan(asset.name.substring(0, columnWidths[0] - 3).padEnd(columnWidths[0])),
+            chalk.dim(asset.extension.toUpperCase().padEnd(columnWidths[1])),
+            chalk.yellow(filesize(asset.size).toString().padEnd(columnWidths[2])),
+            chalk.white(asset.path.substring(0, columnWidths[3] - 3).padEnd(columnWidths[3]))
+        ].join(' ');
+        console.log(row);
+    });
+    const totalSize = assets.reduce((sum, a) => sum + a.size, 0);
+    console.log('\n' + chalk.bgCyan.black(` Potential Savings: ${filesize(totalSize)} `) + '\n');
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "assets-tracker",
+  "version": "1.0.0",
+  "description": "A modern, high-performance CLI tool to identify and remove unused assets in your codebase. Automatically scan for unreferenced images, fonts, and media files to optimize your project size.",
+  "main": "dist/index.js",
+  "bin": {
+    "assets-tracker": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "deploy": "npm run build && npm publish --access public"
+  },
+  "keywords": [
+    "assets",
+    "unused-assets",
+    "cleanup",
+    "cli",
+    "optimization",
+    "bundle-size",
+    "images",
+    "media-cleanup",
+    "web-performance",
+    "developer-tools"
+  ],
+  "author": "Dheeraj & Vaibhav",
+  "contributors": [
+    {
+      "name": "Dheeraj Khush",
+      "url": "https://github.com/DheerajKhush"
+    },
+    {
+      "name": "Vaibhav Khushalani",
+      "url": "https://github.com/VaibhavKhushalani"
+    }
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "filesize": "^10.1.2",
+    "fs-extra": "^11.2.0",
+    "globby": "^14.0.1",
+    "inquirer": "^9.2.22",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.14.2",
+    "nodemon": "^3.1.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  },
+  "type": "module"
+}