packagepurge 1.0.0

package/src/managers/npm-manager.ts

@@ -0,0 +1,96 @@
+/**
+ * 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

@@ -0,0 +1,107 @@
+/**
+ * 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

@@ -0,0 +1,112 @@
+/**
+ * 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;
+  }
+}
+

package/src/types/index.ts

@@ -0,0 +1,97 @@
+/**
+ * Core type definitions for PackagePurge service
+ */
+
+export enum PackageManager {
+  NPM = 'npm',
+  YARN = 'yarn',
+  PNPM = 'pnpm',
+}
+
+export interface PackageInfo {
+  name: string;
+  version: string;
+  path: string;
+  lastAccessed: Date;
+  size: number; // in bytes
+  manager: PackageManager;
+  projectPaths: string[]; // projects that use this package
+}
+
+export interface ProjectInfo {
+  path: string;
+  manager: PackageManager;
+  dependencies: Map<string, string>; // package -> version
+  lastModified: Date;
+  lockFilePath?: string;
+}
+
+export interface CleanupStrategy {
+  name: string;
+  rules: CleanupRule[];
+  mlEnabled: boolean;
+}
+
+export interface CleanupRule {
+  name: string;
+  condition: (packageInfo: PackageInfo) => boolean;
+  priority: number;
+}
+
+export interface CleanupResult {
+  packagesDeleted: PackageInfo[];
+  spaceSaved: number; // in bytes
+  rollbackId?: string;
+  timestamp: Date;
+}
+
+export interface BackupInfo {
+  id: string;
+  timestamp: Date;
+  packages: PackageInfo[];
+  totalSize: number;
+  archivePath: string;
+}
+
+export interface Analytics {
+  totalSpaceSaved: number; // in bytes
+  totalRollbacks: number;
+  totalReinstalls: number;
+  savingsToRiskRatio: number;
+  cacheHitRate: number;
+  projectsAnalyzed: number;
+  lastCleanup: Date | null;
+}
+
+export interface OptimizationConfig {
+  preserveDays: number;
+  keepVersions: number;
+  enableML: boolean;
+  enableSymlinking: boolean;
+  backupEnabled: boolean;
+  managers: PackageManager[];
+  dryRun: boolean;
+  lruMaxPackages?: number;
+  lruMaxSizeBytes?: number;
+}
+
+export interface OptimizeResult {
+  items: Array<{
+    target_path: string;
+    estimated_size_bytes: number;
+    reason: string;
+  }>;
+  total_estimated_bytes: number;
+}
+
+export interface SymlinkResult {
+  status: string;
+  symlinked_count: number;
+}
+
+export interface DependencyGraph {
+  nodes: Map<string, PackageInfo>;
+  edges: Map<string, string[]>; // package -> dependencies
+  rootProjects: ProjectInfo[];
+}
+

package/src/utils/logger.ts

@@ -0,0 +1,50 @@
+/**
+ * Logger utility for PackagePurge
+ */
+import chalk from 'chalk';
+
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+}
+
+class Logger {
+  private level: LogLevel = LogLevel.INFO;
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  debug(message: string, ...args: any[]): void {
+    if (this.level <= LogLevel.DEBUG) {
+      console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
+    }
+  }
+
+  info(message: string, ...args: any[]): void {
+    if (this.level <= LogLevel.INFO) {
+      console.log(chalk.blue(`[INFO] ${message}`), ...args);
+    }
+  }
+
+  warn(message: string, ...args: any[]): void {
+    if (this.level <= LogLevel.WARN) {
+      console.warn(chalk.yellow(`[WARN] ${message}`), ...args);
+    }
+  }
+
+  error(message: string, ...args: any[]): void {
+    if (this.level <= LogLevel.ERROR) {
+      console.error(chalk.red(`[ERROR] ${message}`), ...args);
+    }
+  }
+
+  success(message: string, ...args: any[]): void {
+    console.log(chalk.green(`[SUCCESS] ${message}`), ...args);
+  }
+}
+
+export const logger = new Logger();
+

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "types": ["node", "jest"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}
+