appclean 1.8.0

package/src/core/duplicateFileFinder.ts

@@ -0,0 +1,113 @@
+/**
+ * Duplicate File Finder
+ * Scans system for duplicate files by hash and size
+ * v1.3.0 Feature
+ */
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { Logger } from '../utils/logger';
+
+export interface DuplicateFile {
+  hash: string;
+  size: number;
+  paths: string[];
+  potentialSavings: number;
+}
+
+export class DuplicateFileFinder {
+  /**
+   * Find duplicate files in specified directories
+   */
+  async findDuplicates(directories: string[]): Promise<DuplicateFile[]> {
+    Logger.info('Scanning for duplicate files...');
+
+    const fileHashes = new Map<string, { size: number; paths: string[] }>();
+
+    for (const directory of directories) {
+      await this.scanDirectory(directory, fileHashes);
+    }
+
+    // Filter duplicates
+    const duplicates: DuplicateFile[] = [];
+    for (const [hash, data] of fileHashes.entries()) {
+      if (data.paths.length > 1) {
+        duplicates.push({
+          hash,
+          size: data.size,
+          paths: data.paths,
+          potentialSavings: data.size * (data.paths.length - 1),
+        });
+      }
+    }
+
+    return duplicates.sort((a, b) => b.potentialSavings - a.potentialSavings);
+  }
+
+  /**
+   * Calculate file hash
+   */
+  private async calculateHash(filePath: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const hash = crypto.createHash('sha256');
+      const stream = fs.createReadStream(filePath);
+
+      stream.on('data', (data) => hash.update(data));
+      stream.on('end', () => resolve(hash.digest('hex')));
+      stream.on('error', reject);
+    });
+  }
+
+  /**
+   * Recursively scan directory
+   */
+  private async scanDirectory(
+    directory: string,
+    fileHashes: Map<string, { size: number; paths: string[] }>
+  ): Promise<void> {
+    try {
+      const entries = fs.readdirSync(directory);
+
+      for (const entry of entries) {
+        const fullPath = path.join(directory, entry);
+        const stats = fs.statSync(fullPath);
+
+        if (stats.isDirectory()) {
+          await this.scanDirectory(fullPath, fileHashes);
+        } else if (stats.isFile()) {
+          const hash = await this.calculateHash(fullPath);
+
+          if (!fileHashes.has(hash)) {
+            fileHashes.set(hash, { size: stats.size, paths: [] });
+          }
+
+          fileHashes.get(hash)!.paths.push(fullPath);
+        }
+      }
+    } catch (error) {
+      Logger.debug(`Error scanning directory ${directory}: ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Get duplicate summary
+   */
+  getSummary(duplicates: DuplicateFile[]): string {
+    const totalSize = duplicates.reduce((sum, d) => sum + d.potentialSavings, 0);
+    const totalFiles = duplicates.reduce((sum, d) => sum + (d.paths.length - 1), 0);
+
+    return `
+Found ${duplicates.length} duplicate groups with ${totalFiles} duplicate files
+Potential space savings: ${this.formatBytes(totalSize)}
+    `;
+  }
+
+  private formatBytes(bytes: number): string {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+  }
+}

package/src/core/orphanedDependencyDetector.ts

@@ -0,0 +1,195 @@
+/**
+ * Orphaned Dependency Detector
+ * Identifies npm packages that are no longer referenced by any project
+ * v1.4.0 Feature
+ */
+
+import { execSync } from 'child_process';
+import { getHomeDir } from '../utils/platform';
+import path from 'path';
+import fs from 'fs';
+import { Logger } from '../utils/logger';
+
+export interface OrphanedPackage {
+  name: string;
+  version: string;
+  location: string;
+  size: number;
+  lastModified: Date;
+  isOrphaned: boolean;
+  dependedBy: string[];
+}
+
+export class OrphanedDependencyDetector {
+  /**
+   * Detect orphaned npm packages
+   */
+  async detectOrphanedPackages(): Promise<OrphanedPackage[]> {
+    Logger.info('Scanning for orphaned dependencies...');
+
+    try {
+      const globalPackages = this.getGlobalPackages();
+      const projectPackages = this.getProjectPackages();
+
+      const orphaned: OrphanedPackage[] = [];
+
+      for (const pkg of globalPackages) {
+        const dependedBy = this.checkDependencies(pkg.name, projectPackages);
+
+        if (dependedBy.length === 0) {
+          orphaned.push({
+            ...pkg,
+            isOrphaned: true,
+            dependedBy: [],
+          });
+        } else {
+          orphaned.push({
+            ...pkg,
+            isOrphaned: false,
+            dependedBy,
+          });
+        }
+      }
+
+      return orphaned.filter((p) => p.isOrphaned);
+    } catch (error) {
+      Logger.error(`Error detecting orphaned packages: ${(error as Error).message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Get globally installed packages
+   */
+  private getGlobalPackages(): OrphanedPackage[] {
+    try {
+      const output = execSync('npm list -g --json 2>/dev/null || echo "{}"').toString();
+      const data = JSON.parse(output);
+
+      const packages: OrphanedPackage[] = [];
+
+      if (data.dependencies) {
+        for (const [name, pkg] of Object.entries(data.dependencies)) {
+          const location = this.findPackageLocation(name);
+          if (location) {
+            const stats = fs.statSync(location);
+            packages.push({
+              name,
+              version: (pkg as any).version || 'unknown',
+              location,
+              size: this.getDirectorySize(location),
+              lastModified: stats.mtime,
+              isOrphaned: false,
+              dependedBy: [],
+            });
+          }
+        }
+      }
+
+      return packages;
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Get project packages from package.json files
+   */
+  private getProjectPackages(): Set<string> {
+    const packages = new Set<string>();
+
+    try {
+      const home = getHomeDir();
+      const searchPaths = [home, '/usr/local'];
+
+      for (const searchPath of searchPaths) {
+        this.findPackageJsonFiles(searchPath, packages);
+      }
+    } catch {
+      // Ignore errors during project scanning
+    }
+
+    return packages;
+  }
+
+  /**
+   * Find package.json files recursively
+   */
+  private findPackageJsonFiles(dir: string, packages: Set<string>, depth: number = 0): void {
+    if (depth > 3) return; // Limit depth to avoid scanning too deep
+
+    try {
+      const entries = fs.readdirSync(dir);
+
+      for (const entry of entries) {
+        if (entry === 'package.json') {
+          try {
+            const content = fs.readFileSync(path.join(dir, entry), 'utf-8');
+            const json = JSON.parse(content);
+
+            if (json.dependencies) {
+              Object.keys(json.dependencies).forEach((dep) => packages.add(dep));
+            }
+            if (json.devDependencies) {
+              Object.keys(json.devDependencies).forEach((dep) => packages.add(dep));
+            }
+          } catch {
+            // Skip invalid package.json
+          }
+        }
+
+        const fullPath = path.join(dir, entry);
+        if (fs.statSync(fullPath).isDirectory() && !entry.startsWith('.')) {
+          this.findPackageJsonFiles(fullPath, packages, depth + 1);
+        }
+      }
+    } catch {
+      // Ignore read errors
+    }
+  }
+
+  /**
+   * Check if package is depended by any project
+   */
+  private checkDependencies(packageName: string, projectPackages: Set<string>): string[] {
+    return Array.from(projectPackages).filter((p) => p === packageName);
+  }
+
+  /**
+   * Find package location
+   */
+  private findPackageLocation(packageName: string): string | null {
+    try {
+      const result = execSync(`npm list -g ${packageName} --json 2>/dev/null || echo "{}"`).toString();
+      const data = JSON.parse(result);
+      return data.dependencies?.[packageName]?.resolved || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get directory size
+   */
+  private getDirectorySize(dir: string): number {
+    try {
+      let size = 0;
+      const entries = fs.readdirSync(dir);
+
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        const stats = fs.statSync(fullPath);
+
+        if (stats.isDirectory()) {
+          size += this.getDirectorySize(fullPath);
+        } else {
+          size += stats.size;
+        }
+      }
+
+      return size;
+    } catch {
+      return 0;
+    }
+  }
+}

package/src/core/performanceOptimizer.ts

@@ -0,0 +1,209 @@
+/**
+ * Performance Optimizer
+ * Optimizes scanning performance for large systems
+ * v1.8.0 Feature
+ */
+
+import { Logger } from '../utils/logger';
+
+export interface ScanMetrics {
+  startTime: Date;
+  endTime?: Date;
+  filesScanned: number;
+  directoriesScanned: number;
+  totalSize: number;
+  duration?: number; // milliseconds
+  averageFileSize: number;
+  scanSpeed: number; // files per second
+}
+
+export interface OptimizationSettings {
+  parallelScanThreads: number;
+  cacheResults: boolean;
+  skipSymlinks: boolean;
+  maxDirectoryDepth: number;
+  excludePatterns: string[];
+  indexSystemDirectories: boolean;
+}
+
+export class PerformanceOptimizer {
+  private metrics: Map<string, ScanMetrics> = new Map();
+  private cache: Map<string, any> = new Map();
+  private settings: OptimizationSettings;
+
+  constructor(settings?: Partial<OptimizationSettings>) {
+    this.settings = {
+      parallelScanThreads: 4,
+      cacheResults: true,
+      skipSymlinks: true,
+      maxDirectoryDepth: 10,
+      excludePatterns: ['.git', 'node_modules', '.cache'],
+      indexSystemDirectories: true,
+      ...settings,
+    };
+  }
+
+  /**
+   * Start performance metrics tracking
+   */
+  startMetrics(scanId: string): ScanMetrics {
+    const metrics: ScanMetrics = {
+      startTime: new Date(),
+      filesScanned: 0,
+      directoriesScanned: 0,
+      totalSize: 0,
+      averageFileSize: 0,
+      scanSpeed: 0,
+    };
+
+    this.metrics.set(scanId, metrics);
+    Logger.debug(`Performance metrics started: ${scanId}`);
+    return metrics;
+  }
+
+  /**
+   * End performance metrics tracking
+   */
+  endMetrics(scanId: string): ScanMetrics | null {
+    const metrics = this.metrics.get(scanId);
+    if (metrics) {
+      metrics.endTime = new Date();
+      metrics.duration = metrics.endTime.getTime() - metrics.startTime.getTime();
+      metrics.averageFileSize = metrics.filesScanned > 0 ? metrics.totalSize / metrics.filesScanned : 0;
+      metrics.scanSpeed = metrics.duration > 0 ? (metrics.filesScanned / metrics.duration) * 1000 : 0;
+
+      Logger.info(`
+Performance Report: ${scanId}
+  Duration: ${(metrics.duration / 1000).toFixed(2)}s
+  Files scanned: ${metrics.filesScanned}
+  Directories scanned: ${metrics.directoriesScanned}
+  Total size: ${this.formatBytes(metrics.totalSize)}
+  Scan speed: ${metrics.scanSpeed.toFixed(2)} files/sec
+      `);
+
+      return metrics;
+    }
+    return null;
+  }
+
+  /**
+   * Get metrics for a scan
+   */
+  getMetrics(scanId: string): ScanMetrics | null {
+    return this.metrics.get(scanId) || null;
+  }
+
+  /**
+   * Update metrics during scan
+   */
+  updateMetrics(scanId: string, data: Partial<ScanMetrics>): void {
+    const metrics = this.metrics.get(scanId);
+    if (metrics) {
+      Object.assign(metrics, data);
+    }
+  }
+
+  /**
+   * Cache scan result
+   */
+  cacheResult(key: string, value: any, ttl?: number): void {
+    if (this.settings.cacheResults) {
+      this.cache.set(key, {
+        value,
+        timestamp: Date.now(),
+        ttl: ttl || 3600000, // 1 hour default
+      });
+    }
+  }
+
+  /**
+   * Get cached result
+   */
+  getCachedResult(key: string): any | null {
+    const cached = this.cache.get(key);
+    if (cached) {
+      const age = Date.now() - cached.timestamp;
+      if (age < cached.ttl) {
+        return cached.value;
+      }
+      // Expired, delete it
+      this.cache.delete(key);
+    }
+    return null;
+  }
+
+  /**
+   * Clear cache
+   */
+  clearCache(): void {
+    this.cache.clear();
+    Logger.debug('Performance cache cleared');
+  }
+
+  /**
+   * Update optimization settings
+   */
+  updateSettings(settings: Partial<OptimizationSettings>): void {
+    Object.assign(this.settings, settings);
+    Logger.debug('Performance optimization settings updated');
+  }
+
+  /**
+   * Get optimization settings
+   */
+  getSettings(): OptimizationSettings {
+    return { ...this.settings };
+  }
+
+  /**
+   * Check if path should be scanned
+   */
+  shouldScanPath(path: string, depth: number): boolean {
+    // Check max depth
+    if (depth > this.settings.maxDirectoryDepth) {
+      return false;
+    }
+
+    // Check exclusions
+    for (const pattern of this.settings.excludePatterns) {
+      if (path.includes(pattern)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Get optimization recommendations
+   */
+  getRecommendations(metrics: ScanMetrics): string[] {
+    const recommendations: string[] = [];
+
+    if (!metrics.duration || metrics.duration > 30000) {
+      recommendations.push('Consider increasing parallel scan threads for faster scans');
+    }
+
+    if (metrics.averageFileSize > 10000000) {
+      recommendations.push('Large average file size detected, consider excluding large files');
+    }
+
+    if (metrics.filesScanned > 100000) {
+      recommendations.push('Large scan detected, consider using caching to speed up subsequent scans');
+    }
+
+    if (metrics.directoriesScanned > 1000 && this.settings.maxDirectoryDepth > 8) {
+      recommendations.push('Consider reducing max directory depth to improve performance');
+    }
+
+    return recommendations;
+  }
+
+  private formatBytes(bytes: number): string {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+  }
+}

package/src/core/permissionHandler.ts

@@ -0,0 +1,121 @@
+import { execSync } from 'child_process';
+import { isMacOS, isLinux, isWindows } from '../utils/platform';
+import { Logger } from '../utils/logger';
+
+export class PermissionHandler {
+  /**
+   * Check if current process has elevated privileges
+   */
+  static isElevated(): boolean {
+    try {
+      if (isMacOS() || isLinux()) {
+        // Check if running as root
+        const uid = execSync('id -u').toString().trim();
+        return uid === '0';
+      }
+
+      if (isWindows()) {
+        // Check if running with admin privileges
+        const output = execSync('net session').toString().trim();
+        return output.length > 0;
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Request elevated permissions using sudo or UAC
+   */
+  static async requestElevatedPermissions(): Promise<boolean> {
+    try {
+      if (isMacOS() || isLinux()) {
+        Logger.warn('This operation requires elevated permissions');
+        Logger.info('You may be prompted for your password (sudo)');
+        return true;
+      }
+
+      if (isWindows()) {
+        Logger.warn('This operation requires administrator privileges');
+        Logger.info('Please run AppClean as Administrator');
+        return false;
+      }
+
+      return false;
+    } catch (error) {
+      Logger.error(`Permission request failed: ${(error as Error).message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check if path requires elevated access
+   */
+  static pathRequiresElevation(path: string): boolean {
+    const systemPaths = [
+      '/etc',
+      '/sys',
+      '/var',
+      '/usr/bin',
+      '/usr/local/bin',
+      '/Library',
+      'C:\\Program Files',
+      'C:\\Windows',
+      'C:\\ProgramData',
+    ];
+
+    return systemPaths.some((sysPath) => path.startsWith(sysPath));
+  }
+
+  /**
+   * Check if app installation requires elevated permissions for removal
+   */
+  static installationRequiresElevation(installMethod: string, paths: string[]): boolean {
+    if (installMethod === 'brew' || installMethod === 'apt' || installMethod === 'yum' || installMethod === 'dnf') {
+      return true;
+    }
+
+    // Check if any path requires elevation
+    return paths.some((path) => this.pathRequiresElevation(path));
+  }
+
+  /**
+   * Get the appropriate sudo command based on platform
+   */
+  static getSudoCommand(): string {
+    if (isMacOS() || isLinux()) {
+      return 'sudo';
+    }
+
+    if (isWindows()) {
+      return 'runas /user:Administrator';
+    }
+
+    return '';
+  }
+
+  /**
+   * Execute command with elevated permissions
+   */
+  static executeWithElevation(command: string): string {
+    try {
+      if (isMacOS() || isLinux()) {
+        // For sudo, we need to use -S to read password from stdin
+        // This is more complex in practice, so we'll ask user to run with sudo
+        return '';
+      }
+
+      if (isWindows()) {
+        // Windows requires special handling with runas
+        return execSync(`runas /noprofile /user:Administrator "${command}"`).toString();
+      }
+
+      return '';
+    } catch (error) {
+      Logger.error(`Elevated execution failed: ${(error as Error).message}`);
+      return '';
+    }
+  }
+}