packagepurge 1.0.0 → 2.0.0

package/src/core/bindings.ts

@@ -1,157 +0,0 @@
-/**
- * TypeScript bindings for Rust core functionality
- * Provides type-safe interfaces to the Rust binary
- */
-
-import { spawn } from 'child_process';
-import * as path from 'path';
-import * as fs from 'fs';
-import { OptimizeResult, SymlinkResult } from '../types';
-
-function isWindows(): boolean {
-	return process.platform === 'win32';
-}
-
-function fileExists(p: string): boolean {
-	try { return fs.existsSync(p); } catch { return false; }
-}
-
-function resolveFromPATH(name: string): string | null {
-	const exts = isWindows() ? ['.exe', '.cmd', ''] : [''];
-	const parts = (process.env.PATH || '').split(path.delimiter);
-	for (const dir of parts) {
-		for (const ext of exts) {
-			const candidate = path.join(dir, name + ext);
-			if (fileExists(candidate)) return candidate;
-		}
-	}
-	return null;
-}
-
-function coreBinary(): string {
-	// 1) Env override
-	const envPath = process.env.PACKAGEPURGE_CORE;
-	if (envPath && fileExists(envPath)) return envPath;
-	// 2) Local release/debug
-	const exe = isWindows() ? 'packagepurge_core.exe' : 'packagepurge-core';
-	const rel = path.join(process.cwd(), 'core', 'target', 'release', exe);
-	if (fileExists(rel)) return rel;
-	const dbg = path.join(process.cwd(), 'core', 'target', 'debug', exe);
-	if (fileExists(dbg)) return dbg;
-	// 3) PATH
-	const fromPath = resolveFromPATH(isWindows() ? 'packagepurge_core' : 'packagepurge-core');
-	if (fromPath) return fromPath;
-	throw new Error('packagepurge-core binary not found. Build with "npm run build:core" or set PACKAGEPURGE_CORE.');
-}
-
-function runCore(args: string[]): Promise<{ stdout: string; stderr: string; code: number }> {
-	return new Promise((resolve, reject) => {
-		const bin = coreBinary();
-		const child = spawn(bin, args, { stdio: ['ignore', 'pipe', 'pipe'], env: process.env });
-		let out = '';
-		let err = '';
-		child.stdout.on('data', (d) => out += d.toString());
-		child.stderr.on('data', (d) => err += d.toString());
-		child.on('error', reject);
-		child.on('close', (code) => resolve({ stdout: out, stderr: err, code: code ?? 1 }));
-	});
-}
-
-export interface OptimizeOptions {
-	paths?: string[];
-	preserveDays?: number;
-	enableSymlinking?: boolean;
-	enableML?: boolean;
-	lruMaxPackages?: number;
-	lruMaxSizeBytes?: number;
-}
-
-export interface SymlinkOptions {
-	paths?: string[];
-}
-
-/**
- * Optimize packages with ML/LRU prediction and symlinking
- */
-export async function optimize(options: OptimizeOptions = {}): Promise<OptimizeResult> {
-	const args = ['optimize'];
-	
-	if (options.preserveDays !== undefined) {
-		args.push('--preserve-days', String(options.preserveDays));
-	}
-	if (options.enableSymlinking) {
-		args.push('--enable-symlinking');
-	}
-	if (options.enableML) {
-		args.push('--enable-ml');
-	}
-	if (options.lruMaxPackages !== undefined) {
-		args.push('--lru-max-packages', String(options.lruMaxPackages));
-	}
-	if (options.lruMaxSizeBytes !== undefined) {
-		args.push('--lru-max-size-bytes', String(options.lruMaxSizeBytes));
-	}
-	if (options.paths && options.paths.length > 0) {
-		args.push('--paths', ...options.paths);
-	}
-	
-	const res = await runCore(args);
-	if (res.code !== 0) {
-		throw new Error(`Optimize failed: ${res.stderr || 'Unknown error'}`);
-	}
-	
-	return JSON.parse(res.stdout) as OptimizeResult;
-}
-
-/**
- * Execute symlinking for duplicate packages
- */
-export async function executeSymlinking(options: SymlinkOptions = {}): Promise<SymlinkResult> {
-	const args = ['symlink'];
-	
-	if (options.paths && options.paths.length > 0) {
-		args.push('--paths', ...options.paths);
-	}
-	
-	const res = await runCore(args);
-	if (res.code !== 0) {
-		throw new Error(`Symlink failed: ${res.stderr || 'Unknown error'}`);
-	}
-	
-	return JSON.parse(res.stdout) as SymlinkResult;
-}
-
-/**
- * Scan filesystem for packages and projects
- */
-export async function scan(paths: string[] = []): Promise<any> {
-	const args = ['scan'];
-	if (paths.length > 0) {
-		args.push('--paths', ...paths);
-	}
-	
-	const res = await runCore(args);
-	if (res.code !== 0) {
-		throw new Error(`Scan failed: ${res.stderr || 'Unknown error'}`);
-	}
-	
-	return JSON.parse(res.stdout);
-}
-
-/**
- * Analyze (dry run) cleanup plan
- */
-export async function analyze(paths: string[] = [], preserveDays: number = 90): Promise<any> {
-	const args = ['dry-run', '--preserve-days', String(preserveDays)];
-	if (paths.length > 0) {
-		args.push('--paths', ...paths);
-	}
-	
-	const res = await runCore(args);
-	if (res.code !== 0) {
-		throw new Error(`Analyze failed: ${res.stderr || 'Unknown error'}`);
-	}
-	
-	return JSON.parse(res.stdout);
-}
-

package/src/managers/base-manager.ts

@@ -1,117 +0,0 @@
-/**
- * Base class for package manager integrations
- */
-import { PackageManager, PackageInfo, ProjectInfo } from '../types';
-import * as fs from 'fs-extra';
-import * as path from 'path';
-
-export abstract class BasePackageManager {
-  abstract readonly manager: PackageManager;
-  abstract readonly lockFileName: string;
-
-  /**
-   * Get the cache directory path for this manager
-   */
-  abstract getCachePath(): Promise<string>;
-
-  /**
-   * Parse lock file to extract dependency information
-   */
-  abstract parseLockFile(lockFilePath: string): Promise<Map<string, string>>;
-
-  /**
-   * Scan for all packages in cache
-   */
-  async scanPackages(): Promise<PackageInfo[]> {
-    const cachePath = await this.getCachePath();
-    if (!(await fs.pathExists(cachePath))) {
-      return [];
-    }
-
-    const packages: PackageInfo[] = [];
-    const entries = await fs.readdir(cachePath);
-
-    for (const entry of entries) {
-      const entryPath = path.join(cachePath, entry);
-      const stat = await fs.stat(entryPath);
-
-      if (stat.isDirectory()) {
-        const packageInfo = await this.analyzePackage(entryPath);
-        if (packageInfo) {
-          packages.push(packageInfo);
-        }
-      }
-    }
-
-    return packages;
-  }
-
-  /**
-   * Analyze a single package directory
-   */
-  protected abstract analyzePackage(packagePath: string): Promise<PackageInfo | null>;
-
-  /**
-   * Find all projects using this manager
-   */
-  async findProjects(rootDir: string = process.cwd()): Promise<ProjectInfo[]> {
-    const projects: ProjectInfo[] = [];
-    const lockFilePattern = this.lockFileName;
-
-    const searchDir = async (dir: string, depth: number = 0): Promise<void> => {
-      if (depth > 10) return; // Limit depth to prevent infinite recursion
-
-      try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        const entryNames = entries.map(e => e.name);
-        const hasLockFile = entryNames.includes(lockFilePattern);
-        const hasPackageJson = entryNames.includes('package.json');
-
-        if (hasLockFile && hasPackageJson) {
-          const packageJsonPath = path.join(dir, 'package.json');
-          const lockFilePath = path.join(dir, lockFilePattern);
-          const packageJson = await fs.readJson(packageJsonPath);
-          const dependencies = await this.parseLockFile(lockFilePath);
-          const stat = await fs.stat(packageJsonPath);
-
-          projects.push({
-            path: dir,
-            manager: this.manager,
-            dependencies,
-            lastModified: stat.mtime,
-            lockFilePath,
-          });
-        }
-
-        // Recursively search subdirectories
-        for (const entry of entries) {
-          if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-             await searchDir(path.join(dir, entry.name), depth + 1);
-          }
-        }
-      } catch (error) {
-        // Skip directories we can't read
-      }
-    };
-
-    await searchDir(rootDir);
-    return projects;
-  }
-
-  /**
-   * Get package version from directory name or package.json
-   */
-  protected async getPackageVersion(packagePath: string): Promise<string | null> {
-    const packageJsonPath = path.join(packagePath, 'package.json');
-    if (await fs.pathExists(packageJsonPath)) {
-      try {
-        const packageJson = await fs.readJson(packageJsonPath);
-        return packageJson.version || null;
-      } catch {
-        return null;
-      }
-    }
-    return null;
-  }
-}
-

package/src/managers/index.ts

@@ -1,32 +0,0 @@
-/**
- * Package manager factory and exports
- */
-import { BasePackageManager } from './base-manager';
-import { NpmManager } from './npm-manager';
-import { YarnManager } from './yarn-manager';
-import { PnpmManager } from './pnpm-manager';
-import { PackageManager } from '../types';
-
-export { BasePackageManager, NpmManager, YarnManager, PnpmManager };
-
-export function getManager(manager: PackageManager): BasePackageManager {
-  switch (manager) {
-    case PackageManager.NPM:
-      return new NpmManager();
-    case PackageManager.YARN:
-      return new YarnManager();
-    case PackageManager.PNPM:
-      return new PnpmManager();
-    default:
-      throw new Error(`Unsupported package manager: ${manager}`);
-  }
-}
-
-export function getAllManagers(): BasePackageManager[] {
-  return [
-    new NpmManager(),
-    new YarnManager(),
-    new PnpmManager(),
-  ];
-}
-

package/src/managers/npm-manager.ts

@@ -1,96 +0,0 @@
-/**
- * npm package manager integration
- */
-import { BasePackageManager } from './base-manager';
-import { PackageManager, PackageInfo } from '../types';
-import * as os from 'os';
-import * as path from 'path';
-import * as fs from 'fs-extra';
-
-export class NpmManager extends BasePackageManager {
-  readonly manager = PackageManager.NPM;
-  readonly lockFileName = 'package-lock.json';
-
-  async getCachePath(): Promise<string> {
-    // npm cache path: ~/.npm on Unix, %AppData%/npm-cache on Windows
-    if (process.platform === 'win32') {
-      return path.join(os.homedir(), 'AppData', 'Roaming', 'npm-cache');
-    }
-    return path.join(os.homedir(), '.npm');
-  }
-
-  async parseLockFile(lockFilePath: string): Promise<Map<string, string>> {
-    const dependencies = new Map<string, string>();
-
-    try {
-      const lockFile = await fs.readJson(lockFilePath);
-      
-      // Parse package-lock.json structure
-      function extractDependencies(obj: any, prefix: string = ''): void {
-        if (obj.dependencies) {
-          for (const [name, dep] of Object.entries(obj.dependencies as Record<string, any>)) {
-            const fullName = prefix ? `${prefix}/${name}` : name;
-            if (dep.version) {
-              dependencies.set(fullName, dep.version);
-            }
-            if (dep.dependencies) {
-              extractDependencies(dep, fullName);
-            }
-          }
-        }
-      }
-
-      extractDependencies(lockFile);
-    } catch (error) {
-      // If lock file parsing fails, return empty map
-    }
-
-    return dependencies;
-  }
-
-  protected async analyzePackage(packagePath: string): Promise<PackageInfo | null> {
-    try {
-      const stat = await fs.stat(packagePath);
-      const packageJsonPath = path.join(packagePath, 'package.json');
-      
-      if (!(await fs.pathExists(packageJsonPath))) {
-        return null;
-      }
-
-      const packageJson = await fs.readJson(packageJsonPath);
-      const size = await this.calculateDirectorySize(packagePath);
-
-      return {
-        name: packageJson.name || path.basename(packagePath),
-        version: packageJson.version || 'unknown',
-        path: packagePath,
-        lastAccessed: stat.atime,
-        size,
-        manager: this.manager,
-        projectPaths: [],
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  private async calculateDirectorySize(dirPath: string): Promise<number> {
-    let size = 0;
-    try {
-      const entries = await fs.readdir(dirPath);
-      for (const entry of entries) {
-        const entryPath = path.join(dirPath, entry);
-        const stat = await fs.stat(entryPath);
-        if (stat.isDirectory()) {
-          size += await this.calculateDirectorySize(entryPath);
-        } else {
-          size += stat.size;
-        }
-      }
-    } catch {
-      // Ignore errors
-    }
-    return size;
-  }
-}
-

package/src/managers/pnpm-manager.ts

@@ -1,107 +0,0 @@
-/**
- * pnpm package manager integration
- */
-import { BasePackageManager } from './base-manager';
-import { PackageManager, PackageInfo } from '../types';
-import * as os from 'os';
-import * as path from 'path';
-import * as fs from 'fs-extra';
-
-export class PnpmManager extends BasePackageManager {
-  readonly manager = PackageManager.PNPM;
-  readonly lockFileName = 'pnpm-lock.yaml';
-
-  async getCachePath(): Promise<string> {
-    // pnpm store path: ~/.pnpm-store on Unix, %LOCALAPPDATA%/pnpm/store on Windows
-    if (process.platform === 'win32') {
-      return path.join(os.homedir(), 'AppData', 'Local', 'pnpm', 'store');
-    }
-    return path.join(os.homedir(), '.pnpm-store');
-  }
-
-  async parseLockFile(lockFilePath: string): Promise<Map<string, string>> {
-    const dependencies = new Map<string, string>();
-
-    try {
-      const lockFileContent = await fs.readFile(lockFilePath, 'utf-8');
-      
-      // Parse pnpm-lock.yaml format (YAML)
-      const lines = lockFileContent.split('\n');
-      let currentPackage: string | null = null;
-      let currentVersion: string | null = null;
-
-      for (const line of lines) {
-        const trimmed = line.trim();
-        
-        // Package entry: "package-name:"
-        if (trimmed.endsWith(':') && !trimmed.startsWith(' ') && !trimmed.startsWith('#')) {
-          const match = trimmed.match(/^(.+?):$/);
-          if (match && !match[1].startsWith('lockfile')) {
-            currentPackage = match[1];
-          }
-        }
-        
-        // Version field
-        if (trimmed.startsWith('version:') && currentPackage) {
-          const match = trimmed.match(/version:\s*(.+?)$/);
-          if (match) {
-            currentVersion = match[1].replace(/["']/g, '');
-            dependencies.set(currentPackage, currentVersion);
-            currentPackage = null;
-            currentVersion = null;
-          }
-        }
-      }
-    } catch (error) {
-      // If lock file parsing fails, return empty map
-    }
-
-    return dependencies;
-  }
-
-  protected async analyzePackage(packagePath: string): Promise<PackageInfo | null> {
-    try {
-      const stat = await fs.stat(packagePath);
-      const packageJsonPath = path.join(packagePath, 'package.json');
-      
-      if (!(await fs.pathExists(packageJsonPath))) {
-        return null;
-      }
-
-      const packageJson = await fs.readJson(packageJsonPath);
-      const size = await this.calculateDirectorySize(packagePath);
-
-      return {
-        name: packageJson.name || path.basename(packagePath),
-        version: packageJson.version || 'unknown',
-        path: packagePath,
-        lastAccessed: stat.atime,
-        size,
-        manager: this.manager,
-        projectPaths: [],
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  private async calculateDirectorySize(dirPath: string): Promise<number> {
-    let size = 0;
-    try {
-      const entries = await fs.readdir(dirPath);
-      for (const entry of entries) {
-        const entryPath = path.join(dirPath, entry);
-        const stat = await fs.stat(entryPath);
-        if (stat.isDirectory()) {
-          size += await this.calculateDirectorySize(entryPath);
-        } else {
-          size += stat.size;
-        }
-      }
-    } catch {
-      // Ignore errors
-    }
-    return size;
-  }
-}
-

package/src/managers/yarn-manager.ts

@@ -1,112 +0,0 @@
-/**
- * yarn package manager integration
- */
-import { BasePackageManager } from './base-manager';
-import { PackageManager, PackageInfo } from '../types';
-import * as os from 'os';
-import * as path from 'path';
-import * as fs from 'fs-extra';
-
-export class YarnManager extends BasePackageManager {
-  readonly manager = PackageManager.YARN;
-  readonly lockFileName = 'yarn.lock';
-
-  async getCachePath(): Promise<string> {
-    // yarn cache path: ~/.yarn/cache on Unix, %LOCALAPPDATA%/Yarn/Cache on Windows
-    if (process.platform === 'win32') {
-      return path.join(os.homedir(), 'AppData', 'Local', 'Yarn', 'Cache');
-    }
-    return path.join(os.homedir(), '.yarn', 'cache');
-  }
-
-  async parseLockFile(lockFilePath: string): Promise<Map<string, string>> {
-    const dependencies = new Map<string, string>();
-
-    try {
-      const lockFileContent = await fs.readFile(lockFilePath, 'utf-8');
-      
-      // Parse yarn.lock format (YAML-like format)
-      const lines = lockFileContent.split('\n');
-      let currentPackage: string | null = null;
-      let currentVersion: string | null = null;
-
-      for (const line of lines) {
-        const trimmed = line.trim();
-        
-        // Package declaration: "package-name@version:"
-        if (trimmed.endsWith(':') && !trimmed.startsWith(' ')) {
-          const match = trimmed.match(/^"?(.+?)@(.+?)"?:$/);
-          if (match) {
-            currentPackage = match[1];
-            currentVersion = match[2];
-          }
-        }
-        
-        // Version field
-        if (trimmed.startsWith('version') && currentPackage) {
-          const match = trimmed.match(/version\s+"?(.+?)"?$/);
-          if (match) {
-            currentVersion = match[1];
-          }
-        }
-
-        // Store dependency
-        if (currentPackage && currentVersion && trimmed.startsWith('resolved')) {
-          dependencies.set(currentPackage, currentVersion);
-          currentPackage = null;
-          currentVersion = null;
-        }
-      }
-    } catch (error) {
-      // If lock file parsing fails, return empty map
-    }
-
-    return dependencies;
-  }
-
-  protected async analyzePackage(packagePath: string): Promise<PackageInfo | null> {
-    try {
-      const stat = await fs.stat(packagePath);
-      const packageJsonPath = path.join(packagePath, 'package.json');
-      
-      if (!(await fs.pathExists(packageJsonPath))) {
-        return null;
-      }
-
-      const packageJson = await fs.readJson(packageJsonPath);
-      const size = await this.calculateDirectorySize(packagePath);
-
-      return {
-        name: packageJson.name || path.basename(packagePath),
-        version: packageJson.version || 'unknown',
-        path: packagePath,
-        lastAccessed: stat.atime,
-        size,
-        manager: this.manager,
-        projectPaths: [],
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  private async calculateDirectorySize(dirPath: string): Promise<number> {
-    let size = 0;
-    try {
-      const entries = await fs.readdir(dirPath);
-      for (const entry of entries) {
-        const entryPath = path.join(dirPath, entry);
-        const stat = await fs.stat(entryPath);
-        if (stat.isDirectory()) {
-          size += await this.calculateDirectorySize(entryPath);
-        } else {
-          size += stat.size;
-        }
-      }
-    } catch {
-      // Ignore errors
-    }
-    return size;
-  }
-}
-