ghost-import-hunter 2.0.2 → 3.0.1

package/README.md

@@ -102,9 +102,36 @@ Add to your GitHub Actions or GitLab CI:
 ```
 
 ### Command Line Options
-- `--help` - Show all commands
-- `--json` - Output as JSON
-- `--ignore` - Ignore patterns (glob)
+
+To see all available commands, you can view the help menu:
+
+**Using npx:**
+```bash
+npx ghost-import-hunter --help
+```
+
+**Local Development:**
+```bash
+node dist/index.js --help
+```
+
+**Output:**
+```text
+Usage: ghost-import-hunter [options] [directory]
+
+A deterministic tool to find AI hallucinations and unused code
+
+Arguments:
+  directory         Directory to scan (default: ".")
+
+Options:
+  -V, --version     output the version number
+  --fix             Automatically fix unused imports
+  --interactive     Interactively fix unused imports and hallucinations
+  --prune           Uninstall completely unused dependencies from package.json
+  --uninstall-self  Uninstall ghost-import-hunter globally from your system
+  -h, --help        display help for command
+```
 
 ---
 

package/dist/analyzer.js

@@ -38,7 +38,7 @@ const ts = __importStar(require("typescript"));
 const path = __importStar(require("path"));
 const glob_1 = require("glob");
 async function analyzeProject(directory) {
-    const report = { hallucinations: [], unused: [] };
+    const report = { hallucinations: [], unused: [], usedModules: [] };
     // 1. Find all files in the project
     const files = await (0, glob_1.glob)('**/*.{ts,tsx,js,jsx}', {
         cwd: directory,
@@ -59,80 +59,165 @@ async function analyzeProject(directory) {
         skipLibCheck: true
     });
     const checker = program.getTypeChecker();
+    const allUsedModules = new Set();
     // 3. Analyze each file
     for (const sourceFile of program.getSourceFiles()) {
         // Skip external library files (node_modules)
         if (sourceFile.fileName.includes('node_modules'))
             continue;
         // Also ensure we are only analyzing files we actually found (extra safety)
-        // Normalize paths for comparison
         const normalizedFilePath = path.resolve(sourceFile.fileName);
         const isProjectFile = files.some(f => path.resolve(f) === normalizedFilePath);
         if (!isProjectFile)
             continue;
+        // Track imports to find unused ones
+        // Map<Symbol, UnusedItem>
+        const trackedImports = new Map();
+        // Pass 1: Collect Imports & Check Hallucinations
         ts.forEachChild(sourceFile, (node) => {
             if (ts.isImportDeclaration(node)) {
-                visitImportDeclaration(node, sourceFile, checker, report);
+                visitImportDeclaration(node, sourceFile, checker, report, trackedImports, allUsedModules);
             }
         });
+        // Pass 2: Check Usage
+        // We visit all nodes EXCEPT ImportDeclarations (which we already processed)
+        // If we find an identifier that resolves to a symbol in 'trackedImports', delete it from the map.
+        const visitUsage = (node) => {
+            if (ts.isIdentifier(node)) {
+                const symbol = checker.getSymbolAtLocation(node);
+                if (symbol) {
+                    // Check direct match
+                    if (trackedImports.has(symbol)) {
+                        trackedImports.delete(symbol);
+                    }
+                    else {
+                        // Handle aliased symbols (e.g. import { a as b } ... b usage checks alias a)
+                        // Actually, 'getSymbolAtLocation' on the usage 'b' returns the local symbol for 'b'.
+                        // And that IS the key in our map.
+                        // However, TypeScript sometimes handles equality strictly.
+                        // What if it's a shorthand property? { b } -> uses b.
+                        if (symbol.flags & ts.SymbolFlags.Alias) {
+                            const aliased = checker.getAliasedSymbol(symbol);
+                            if (aliased && trackedImports.has(aliased)) {
+                                trackedImports.delete(aliased);
+                            }
+                        }
+                    }
+                }
+            }
+            // Recurse, but don't enter ImportDeclarations again
+            if (!ts.isImportDeclaration(node)) {
+                ts.forEachChild(node, visitUsage);
+            }
+        };
+        ts.forEachChild(sourceFile, (node) => {
+            if (!ts.isImportDeclaration(node)) {
+                visitUsage(node);
+            }
+        });
+        // Any remaining imports are unused
+        trackedImports.forEach((unusedItem) => {
+            report.unused.push(unusedItem);
+        });
     }
+    report.usedModules = Array.from(allUsedModules);
     return report;
 }
-function visitImportDeclaration(node, sourceFile, checker, report) {
+function visitImportDeclaration(node, sourceFile, checker, report, trackedImports, allUsedModules) {
     const moduleSpecifier = node.moduleSpecifier;
     if (!ts.isStringLiteral(moduleSpecifier))
         return;
     const moduleName = moduleSpecifier.text;
-    // Resolve Module Symbol
+    allUsedModules.add(moduleName);
+    // Resolve Module Symbol (Hallucination Check)
     const symbol = checker.getSymbolAtLocation(moduleSpecifier);
     if (!symbol) {
-        // Module not found at all
-        // Get line number
         const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
         report.hallucinations.push({
             file: sourceFile.fileName,
             line: line + 1,
+            start: node.getStart(),
+            end: node.getEnd(),
             module: moduleName,
             member: '*' // Whole module missing
         });
-        return;
+        return; // Can't check usage if module missing
+    }
+    // Default Import
+    if (node.importClause?.name) {
+        const defaultImport = node.importClause.name;
+        const defaultSymbol = checker.getSymbolAtLocation(defaultImport);
+        if (defaultSymbol) {
+            const { line } = sourceFile.getLineAndCharacterOfPosition(defaultImport.getStart());
+            trackedImports.set(defaultSymbol, {
+                file: sourceFile.fileName,
+                line: line + 1,
+                start: defaultImport.getStart(),
+                end: defaultImport.getEnd(),
+                module: moduleName,
+                member: 'default'
+            });
+        }
+    }
+    // Namespace Import (* as name)
+    if (node.importClause?.namedBindings && ts.isNamespaceImport(node.importClause.namedBindings)) {
+        const namespaceImport = node.importClause.namedBindings.name;
+        const nsSymbol = checker.getSymbolAtLocation(namespaceImport);
+        if (nsSymbol) {
+            const { line } = sourceFile.getLineAndCharacterOfPosition(namespaceImport.getStart());
+            trackedImports.set(nsSymbol, {
+                file: sourceFile.fileName,
+                line: line + 1,
+                start: namespaceImport.getStart(),
+                end: namespaceImport.getEnd(),
+                module: moduleName,
+                member: '* as ' + namespaceImport.text
+            });
+        }
     }
-    // Check Named Imports
-    if (node.importClause && node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+    // Named Imports
+    if (node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
         node.importClause.namedBindings.elements.forEach(element => {
             const importName = element.propertyName?.text || element.name.text;
-            const importSymbol = checker.getSymbolAtLocation(element.name);
+            const localName = element.name; // The identifier in the code
+            const importSymbol = checker.getSymbolAtLocation(localName);
             const { line } = sourceFile.getLineAndCharacterOfPosition(element.getStart());
             if (importSymbol) {
-                const aliasedSymbol = checker.getAliasedSymbol(importSymbol);
+                // Hallucination Check for Named Exports
+                let aliasedSymbol;
+                if (importSymbol.flags & ts.SymbolFlags.Alias) {
+                    aliasedSymbol = checker.getAliasedSymbol(importSymbol);
+                }
                 if (aliasedSymbol) {
-                    // Check for "unknown" symbol or missing declarations which indicates a hallucination
                     if (aliasedSymbol.escapedName === 'unknown' || !aliasedSymbol.declarations || aliasedSymbol.declarations.length === 0) {
                         report.hallucinations.push({
                             file: sourceFile.fileName,
                             line: line + 1,
+                            start: element.getStart(),
+                            end: element.getEnd(),
                             module: moduleName,
                             member: importName
                         });
+                        return; // Don't track unused if it's a hallucination
                     }
                 }
-                else {
-                    // If no aliased symbol, it might be a direct interface/type or something we couldn't resolve deeply
-                    // For now, if we have a symbol, we assume it exists to avoid false positives unless we are sure.
-                    // But in our prototype `ghost` gave a symbol that resolved to `unknown`.
-                    // If `getAliasedSymbol` throws or returns undefined, it might be a local symbol.
-                    // Double check with module exports if possible
-                    // const moduleExports = checker.getExportsOfModule(symbol);
-                    // if (!moduleExports.some(e => e.name === importName)) {
-                    //      // Potential hallucination or just a type?
-                    // }
-                }
+                // Add to tracked imports for usage check
+                trackedImports.set(importSymbol, {
+                    file: sourceFile.fileName,
+                    line: line + 1,
+                    start: element.getStart(),
+                    end: element.getEnd(),
+                    module: moduleName,
+                    member: importName
+                });
             }
             else {
-                // No symbol found at location - definitely a hallucination
+                // Hallucination
                 report.hallucinations.push({
                     file: sourceFile.fileName,
                     line: line + 1,
+                    start: element.getStart(),
+                    end: element.getEnd(),
                     module: moduleName,
                     member: importName
                 });

package/dist/index.js

@@ -1,30 +1,98 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const readline = __importStar(require("readline"));
 const analyzer_1 = require("./analyzer");
 const program = new commander_1.Command();
 program
-    .name('ghost-hunter')
+    .name('ghost-import-hunter')
     .description('A deterministic tool to find AI hallucinations and unused code')
-    .version('1.0.0')
+    .version('3.0.1')
     .argument('[directory]', 'Directory to scan', '.')
-    .action(async (directory) => {
-    console.log(chalk_1.default.blue(`👻 Ghost Hunter scanning: ${directory}...`));
+    .option('--fix', 'Automatically fix unused imports')
+    .option('--interactive', 'Interactively fix unused imports and hallucinations')
+    .option('--prune', 'Uninstall completely unused dependencies from package.json')
+    .option('--uninstall-self', 'Uninstall ghost-import-hunter globally from your system')
+    .action(async (directory, options) => {
+    if (options.uninstallSelf) {
+        console.log(chalk_1.default.red('\n⚠️ WARNING: This will completely remove ghost-import-hunter from your system.'));
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const answer = await new Promise(resolve => {
+            rl.question(chalk_1.default.yellow(`❓ Are you sure you want to uninstall ghost-import-hunter? (y/N) `), resolve);
+        });
+        rl.close();
+        if (answer.toLowerCase() === 'y') {
+            console.log(chalk_1.default.blue('\n🗑️ Uninstalling ghost-import-hunter...'));
+            try {
+                const { execSync } = require('child_process');
+                execSync('npm uninstall -g ghost-import-hunter', { stdio: 'inherit' });
+                console.log(chalk_1.default.green('✨ Successfully uninstalled ghost-import-hunter. Goodbye! 👋'));
+            }
+            catch (err) {
+                console.error(chalk_1.default.red('❌ Failed to uninstall:'), err);
+            }
+        }
+        else {
+            console.log(chalk_1.default.green('ℹ️ Uninstall cancelled. Thank you for keeping me around! 👻'));
+        }
+        return;
+    }
+    console.log(chalk_1.default.blue(`👻 Ghost Import Hunter scanning: ${directory}...`));
     try {
         // New v2 Engine using TS Compiler API
         const report = await (0, analyzer_1.analyzeProject)(directory);
+        let hasError = false;
         if (report.hallucinations.length > 0) {
             console.log(chalk_1.default.red('\n🚨 Hallucinations Detected (AI Lied!):'));
             report.hallucinations.forEach(h => {
                 console.log(`  - ${chalk_1.default.bold(h.module)}: Used member ${chalk_1.default.bold(h.member)} does not exist.`);
                 console.log(`    File: ${h.file}:${h.line}`);
             });
-            process.exit(1); // Fail the build
+            hasError = true;
         }
         else {
             console.log(chalk_1.default.green('\n✅ No Hallucinations detected.'));
@@ -36,10 +104,240 @@ program
                 console.log(`    File: ${u.file}:${u.line}`);
             });
         }
+        if (options.interactive) {
+            const fixes = [];
+            const allIssues = [...report.hallucinations, ...report.unused];
+            if (allIssues.length === 0) {
+                console.log(chalk_1.default.green('\n✨ No issues to fix!'));
+                return;
+            }
+            console.log(chalk_1.default.blue(`\n🕵️ Interactive Mode: Found ${allIssues.length} issues.`));
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            for (const issue of allIssues) {
+                const isHallucination = 'member' in issue && report.hallucinations.includes(issue);
+                const type = isHallucination ? chalk_1.default.red('Hallucination') : chalk_1.default.yellow('Unused');
+                console.log(chalk_1.default.gray('--------------------------------------------------'));
+                console.log(`${type}: ${chalk_1.default.bold(issue.module)} (${issue.member})`);
+                console.log(`  File: ${issue.file}:${issue.line}`);
+                const answer = await new Promise(resolve => {
+                    rl.question(chalk_1.default.cyan('  Action? [d]elete, [s]kip (default: skip): '), resolve);
+                });
+                if (answer.toLowerCase() === 'd') {
+                    fixes.push(issue);
+                    console.log(chalk_1.default.green('  -> Marked for deletion.'));
+                }
+                else {
+                    console.log(chalk_1.default.gray('  -> Skipped.'));
+                }
+            }
+            rl.close();
+            if (fixes.length > 0) {
+                console.log(chalk_1.default.blue(`\n🔧 Applying ${fixes.length} fixes...`));
+                await fixImports(fixes);
+                console.log(chalk_1.default.green('✨ Fixes applied!'));
+            }
+            else {
+                console.log(chalk_1.default.yellow('\nℹ️ No changes made.'));
+            }
+            // Skip the batch block below if we ran interactive
+            return;
+        }
+        if (options.fix && report.unused.length > 0) {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const answer = await new Promise(resolve => {
+                rl.question(chalk_1.default.yellow(`\n❓ Found ${report.unused.length} unused imports. Do you want to fix them? (y/N) `), resolve);
+            });
+            rl.close();
+            if (answer.toLowerCase() === 'y') {
+                console.log(chalk_1.default.blue('\n🔧 Fixing unused imports...'));
+                await fixImports(report.unused);
+                console.log(chalk_1.default.green('✨ Auto-fix complete!'));
+            }
+            else {
+                console.log(chalk_1.default.yellow('ℹ️ Auto-fix cancelled.'));
+            }
+        }
+        if (options.prune) {
+            const packageJsonPath = path.join(directory, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                console.log(chalk_1.default.blue('\n🔍 Checking for completely unused dependencies...'));
+                const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+                const deps = Object.keys(pkg.dependencies || {});
+                // Filter out types and our own tool just in case
+                const projectDeps = deps.filter(d => !d.startsWith('@types/') && d !== 'ghost-import-hunter');
+                const toRemove = projectDeps.filter(dep => !report.usedModules.includes(dep));
+                if (toRemove.length > 0) {
+                    console.log(chalk_1.default.yellow(`\n🗑️ Found ${toRemove.length} unused dependencies:`));
+                    toRemove.forEach(d => console.log(`  - ${chalk_1.default.bold(d)}`));
+                    const rl = readline.createInterface({
+                        input: process.stdin,
+                        output: process.stdout
+                    });
+                    const answer = await new Promise(resolve => {
+                        rl.question(chalk_1.default.red(`\n❓ Are you sure you want to uninstall these packages? (y/N) `), resolve);
+                    });
+                    rl.close();
+                    if (answer.toLowerCase() === 'y') {
+                        console.log(chalk_1.default.blue(`\n📦 Uninstalling ${toRemove.join(', ')}...`));
+                        try {
+                            const { execSync } = require('child_process');
+                            execSync(`npm uninstall ${toRemove.join(' ')}`, { stdio: 'inherit', cwd: directory });
+                            console.log(chalk_1.default.green('✨ Pruning complete!'));
+                        }
+                        catch (err) {
+                            console.error(chalk_1.default.red('❌ Failed to uninstall packages:'), err);
+                        }
+                    }
+                    else {
+                        console.log(chalk_1.default.yellow('ℹ️ Pruning cancelled.'));
+                    }
+                }
+                else {
+                    console.log(chalk_1.default.green('\n✨ No unused dependencies found in package.json!'));
+                }
+            }
+            else {
+                console.log(chalk_1.default.yellow('\n⚠️ No package.json found in the specified directory. Cannot prune dependencies.'));
+            }
+        }
+        if (hasError) {
+            process.exit(1);
+        }
     }
     catch (error) {
         console.error(chalk_1.default.red('Error scanning project:'), error);
         process.exit(1);
     }
 });
+async function fixImports(unused) {
+    // Group by file
+    const fileMap = new Map();
+    unused.forEach(u => {
+        if (!fileMap.has(u.file))
+            fileMap.set(u.file, []);
+        fileMap.get(u.file).push(u);
+    });
+    for (const [file, items] of fileMap) {
+        if (!fs.existsSync(file))
+            continue;
+        const content = fs.readFileSync(file, 'utf-8');
+        const sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+        const replacements = [];
+        // Helper: Check usage
+        // usage is defined by matching line and member
+        // items contains the UNUSED ones.
+        ts.forEachChild(sourceFile, (node) => {
+            if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+                const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                const lineNum = line + 1;
+                const moduleName = node.moduleSpecifier.text;
+                // Find unused items for this import declaration
+                // (Note: duplicate logic with analyzer?) a bit, but we are fixing now.
+                // We assume strict line match is safe enough.
+                const unusedItems = items.filter(u => u.line === lineNum && u.module === moduleName);
+                if (unusedItems.length === 0)
+                    return;
+                // Determine what to remove
+                let shouldRemoveWhole = false;
+                const importClause = node.importClause;
+                if (!importClause) {
+                    // Import "mod"; -> side effect.
+                    // If analyzer reported it as unused, it means it's unused. (Wait, analyzer skips side effects? No, visitImportDeclaration checks string literal.)
+                    // But our Unused logic tracks SYMBOLS. Side effect imports usually don't introduce symbols.
+                    // If analyzer reported it, we should remove it.
+                    // Check if member is '*'?
+                    if (unusedItems.some(u => u.member === '*')) {
+                        shouldRemoveWhole = true;
+                    }
+                }
+                else {
+                    // Check Default
+                    let removeDefault = false;
+                    if (importClause.name) {
+                        // Check if default is unused
+                        if (unusedItems.some(u => u.member === 'default')) {
+                            removeDefault = true;
+                        }
+                    }
+                    // Check Namespace
+                    let removeNamespace = false;
+                    if (importClause.namedBindings && ts.isNamespaceImport(importClause.namedBindings)) {
+                        const txt = '* as ' + importClause.namedBindings.name.text;
+                        if (unusedItems.some(u => u.member === txt)) {
+                            removeNamespace = true;
+                        }
+                    }
+                    // Check Named
+                    let newNamedElements = [];
+                    let hasNamed = false;
+                    if (importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
+                        hasNamed = true;
+                        importClause.namedBindings.elements.forEach(el => {
+                            const name = el.propertyName?.text || el.name.text;
+                            // Is this specific named import unused?
+                            const isUnused = unusedItems.some(u => u.member === name);
+                            if (!isUnused) {
+                                newNamedElements.push(el);
+                            }
+                        });
+                    }
+                    // Decision Logic
+                    const keptDefault = importClause.name && !removeDefault;
+                    const keptNamespace = importClause.namedBindings && ts.isNamespaceImport(importClause.namedBindings) && !removeNamespace;
+                    const keptNamed = hasNamed && newNamedElements.length > 0;
+                    // If nothing kept, remove whole
+                    if (!keptDefault && !keptNamespace && !keptNamed) {
+                        shouldRemoveWhole = true;
+                    }
+                    else {
+                        // Reconstruct Import
+                        // We use ts.factory to create a new node
+                        // But we need to handle "Default, Named" vs "Default" vs "Named"
+                        const newImportClause = ts.factory.updateImportClause(importClause, importClause.isTypeOnly, keptDefault ? importClause.name : undefined, keptNamespace
+                            ? importClause.namedBindings
+                            // Mixed default + named?
+                            : (keptNamed
+                                ? ts.factory.createNamedImports(newNamedElements)
+                                : undefined));
+                        // Create new declaration
+                        const newDecl = ts.factory.updateImportDeclaration(node, node.modifiers, newImportClause, node.moduleSpecifier, node.assertClause);
+                        // Print
+                        const printer = ts.createPrinter();
+                        const newText = printer.printNode(ts.EmitHint.Unspecified, newDecl, sourceFile);
+                        replacements.push({
+                            start: node.getStart(),
+                            end: node.getEnd(),
+                            text: newText
+                        });
+                        return; // Done with this node
+                    }
+                }
+                if (shouldRemoveWhole) {
+                    // Remove the whole line(s) to avoid empty gaps
+                    // node.getFullStart() includes previous newlines?
+                    // Safe approach: remove node.getStart() to node.getEnd(), then cleanup empty lines later or just leave usage of prettier to user?
+                    // "getFullStart" keeps leading trivia.
+                    replacements.push({
+                        start: node.getFullStart(),
+                        end: node.getEnd(),
+                        text: '' // Delete
+                    });
+                }
+            }
+        });
+        // Apply replacements from bottom to top
+        replacements.sort((a, b) => b.start - a.start);
+        let newContent = content;
+        for (const r of replacements) {
+            newContent = newContent.substring(0, r.start) + r.text + newContent.substring(r.end);
+        }
+        fs.writeFileSync(file, newContent);
+    }
+}
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ghost-import-hunter",
-    "version": "2.0.2",
+    "version": "3.0.1",
     "description": "Deterministic tool to detect AI hallucinations and code bloat by verifying import safety against installed node_modules",
     "repository": {
         "type": "git",