packagepurge 1.0.0

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAKA,oBAAY,QAAQ;IAClB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;CACV;AAED,cAAM,MAAM;IACV,OAAO,CAAC,KAAK,CAA2B;IAExC,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAM5C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAM3C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAM3C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAM5C,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;CAG/C;AAED,eAAO,MAAM,MAAM,QAAe,CAAC"}

package/dist/utils/logger.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.LogLevel = void 0;
+/**
+ * Logger utility for PackagePurge
+ */
+const chalk_1 = __importDefault(require("chalk"));
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger {
+    constructor() {
+        this.level = LogLevel.INFO;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    debug(message, ...args) {
+        if (this.level <= LogLevel.DEBUG) {
+            console.log(chalk_1.default.gray(`[DEBUG] ${message}`), ...args);
+        }
+    }
+    info(message, ...args) {
+        if (this.level <= LogLevel.INFO) {
+            console.log(chalk_1.default.blue(`[INFO] ${message}`), ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.level <= LogLevel.WARN) {
+            console.warn(chalk_1.default.yellow(`[WARN] ${message}`), ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.level <= LogLevel.ERROR) {
+            console.error(chalk_1.default.red(`[ERROR] ${message}`), ...args);
+        }
+    }
+    success(message, ...args) {
+        console.log(chalk_1.default.green(`[SUCCESS] ${message}`), ...args);
+    }
+}
+exports.logger = new Logger();
+//# sourceMappingURL=logger.js.map

package/dist/utils/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":";;;;;;AAAA;;GAEG;AACH,kDAA0B;AAE1B,IAAY,QAKX;AALD,WAAY,QAAQ;IAClB,yCAAS,CAAA;IACT,uCAAQ,CAAA;IACR,uCAAQ,CAAA;IACR,yCAAS,CAAA;AACX,CAAC,EALW,QAAQ,wBAAR,QAAQ,QAKnB;AAED,MAAM,MAAM;IAAZ;QACU,UAAK,GAAa,QAAQ,CAAC,IAAI,CAAC;IAiC1C,CAAC;IA/BC,QAAQ,CAAC,KAAe;QACtB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,GAAG,IAAW;QACnC,IAAI,IAAI,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC;YACjC,OAAO,CAAC,GAAG,CAAC,eAAK,CAAC,IAAI,CAAC,WAAW,OAAO,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;QACzD,CAAC;IACH,CAAC;IAED,IAAI,CAAC,OAAe,EAAE,GAAG,IAAW;QAClC,IAAI,IAAI,CAAC,KAAK,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;YAChC,OAAO,CAAC,GAAG,CAAC,eAAK,CAAC,IAAI,CAAC,UAAU,OAAO,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;IAED,IAAI,CAAC,OAAe,EAAE,GAAG,IAAW;QAClC,IAAI,IAAI,CAAC,KAAK,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;YAChC,OAAO,CAAC,IAAI,CAAC,eAAK,CAAC,MAAM,CAAC,UAAU,OAAO,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;QAC3D,CAAC;IACH,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,GAAG,IAAW;QACnC,IAAI,IAAI,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,EAAE,CAAC;YACjC,OAAO,CAAC,KAAK,CAAC,eAAK,CAAC,GAAG,CAAC,WAAW,OAAO,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;QAC1D,CAAC;IACH,CAAC;IAED,OAAO,CAAC,OAAe,EAAE,GAAG,IAAW;QACrC,OAAO,CAAC,GAAG,CAAC,eAAK,CAAC,KAAK,CAAC,aAAa,OAAO,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;IAC5D,CAAC;CACF;AAEY,QAAA,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "packagepurge",
+  "version": "1.0.0",
+  "description": "Intelligent package manager cache cleanup service with project-aware optimization",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "packagepurge": "dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "npm run build:core && tsc",
+    "build:core": "cd core && cargo build --release",
+    "build:core:debug": "cd core && cargo build",
+    "dev": "npm run build:core:debug && ts-node src/cli/index.ts",
+    "start": "node dist/cli/index.js",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "clean": "rimraf dist",
+    "clean:core": "cd core && cargo clean"
+  },
+  "keywords": [
+    "npm",
+    "yarn",
+    "pnpm",
+    "cache",
+    "cleanup",
+    "optimization",
+    "storage",
+    "deduplication"
+  ],
+  "author": "Eng. Onyango Benard",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "chalk": "^4.1.2",
+    "inquirer": "^8.2.6",
+    "fs-extra": "^11.2.0",
+    "tar": "^6.2.1",
+    "glob": "^10.3.10",
+    "semver": "^7.5.4",
+    "@types/node": "^20.10.6",
+    "node-machine-id": "^1.1.12",
+    "yaml": "^2.4.5"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^8.2.10",
+    "@types/node": "^20.10.6",
+    "@types/semver": "^7.5.4",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "@types/jest": "^29.5.11",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3",
+    "rimraf": "^5.0.5"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}
+

package/src/cli/index.ts

@@ -0,0 +1,212 @@
+import { Command } from 'commander';
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import { logger } from '../utils/logger';
+import YAML from 'yaml';
+import { optimize, executeSymlinking } from '../core/bindings';
+
+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 }));
+	});
+}
+
+async function output(data: string, format: 'json' | 'yaml') {
+	if (format === 'yaml') {
+		try {
+			const obj = JSON.parse(data);
+			console.log(YAML.stringify(obj));
+			return;
+		} catch {
+			// Fallback to raw
+		}
+	}
+	console.log(data);
+}
+
+const program = new Command();
+program
+	.name('packagepurge')
+	.description('Intelligent package manager cache cleanup service with project-aware optimization')
+	.version('1.0.0')
+	.option('-q, --quiet', 'Minimal output', false)
+	.option('-v, --verbose', 'Verbose logging', false)
+	.option('-f, --format <format>', 'Output format: json|yaml', 'json');
+
+program.hook('preAction', (_, actionCommand) => {
+	const opts = actionCommand.optsWithGlobals();
+	if (opts.verbose) logger.setLevel(0);
+});
+
+program
+	.command('scan')
+	.description('Scan filesystem and output results')
+	.option('-p, --paths <paths...>', 'Paths to scan', [])
+	.action(async (opts, cmd) => {
+		const g = cmd.parent?.opts?.() || {};
+		const args = ['scan', ...(opts.paths?.length ? ['--paths', ...opts.paths] : [])];
+		const res = await runCore(args);
+		if (res.code !== 0) {
+			if (!g.quiet) logger.error(res.stderr || 'Scan failed');
+			process.exit(res.code);
+		}
+		await output(res.stdout, (g.format || 'json'));
+	});
+
+program
+	.command('analyze')
+	.description('Dry-run cleanup plan (no changes)')
+	.option('-p, --paths <paths...>', 'Paths to analyze', [])
+	.option('-d, --preserve-days <days>', 'Preserve days for recency', '90')
+	.action(async (opts, cmd) => {
+		const g = cmd.parent?.opts?.() || {};
+		const preserve = String(opts.preserveDays ?? opts['preserve-days'] ?? opts.d ?? 90);
+		const args = ['dry-run', '--preserve-days', preserve, ...(opts.paths?.length ? ['--paths', ...opts.paths] : [])];
+		const res = await runCore(args);
+		if (res.code !== 0) {
+			if (!g.quiet) logger.error(res.stderr || 'Analyze failed');
+			process.exit(res.code);
+		}
+		await output(res.stdout, (g.format || 'json'));
+	});
+
+program
+	.command('clean')
+	.description('Quarantine targets (Move-and-Delete transaction). Defaults to dry-run via analyze.')
+	.option('-t, --targets <targets...>', 'Paths to quarantine (from analyze)')
+	.action(async (opts, cmd) => {
+		const g = cmd.parent?.opts?.() || {};
+		if (!opts.targets || !opts.targets.length) {
+			if (!g.quiet) logger.warn('No targets provided. Run analyze first to produce a plan.');
+			process.exit(2);
+		}
+		const res = await runCore(['quarantine', ...opts.targets]);
+		if (res.code !== 0) {
+			if (!g.quiet) logger.error(res.stderr || 'Clean failed');
+			process.exit(res.code);
+		}
+		await output(res.stdout, (g.format || 'json'));
+	});
+
+program
+	.command('rollback')
+	.description('Rollback quarantine by id or latest')
+	.option('--id <id>', 'Quarantine record id')
+	.option('--latest', 'Rollback the most recent quarantine', false)
+	.action(async (opts, cmd) => {
+		const g = cmd.parent?.opts?.() || {};
+		const args = ['rollback'];
+		const finalArgs = opts.id ? args.concat(['--id', opts.id]) : (opts.latest ? args.concat(['--latest']) : args);
+		const res = await runCore(finalArgs);
+		if (res.code !== 0) {
+			if (!g.quiet) logger.error(res.stderr || 'Rollback failed');
+			process.exit(res.code);
+		}
+		await output(res.stdout, (g.format || 'json'));
+	});
+
+program
+	.command('optimize')
+	.description('Optimize with ML/LRU prediction and symlinking (dry run)')
+	.option('-p, --paths <paths...>', 'Paths to optimize', [])
+	.option('-d, --preserve-days <days>', 'Days to preserve packages', '90')
+	.option('--enable-symlinking', 'Enable cross-project symlinking', false)
+	.option('--enable-ml', 'Enable ML-based predictions', false)
+	.option('--lru-max-packages <count>', 'Maximum packages in LRU cache', '1000')
+	.option('--lru-max-size-bytes <bytes>', 'Maximum size of LRU cache in bytes', '10000000000')
+	.action(async (opts, cmd) => {
+		const g = cmd.parent?.opts?.() || {};
+		const preserve = String(opts.preserveDays ?? opts['preserve-days'] ?? opts.d ?? 90);
+		const lruPackages = String(opts.lruMaxPackages ?? opts['lru-max-packages'] ?? 1000);
+		const lruSize = String(opts.lruMaxSizeBytes ?? opts['lru-max-size-bytes'] ?? 10000000000);
+		
+		const args = [
+			'optimize',
+			'--preserve-days', preserve,
+			'--lru-max-packages', lruPackages,
+			'--lru-max-size-bytes', lruSize,
+		];
+		
+		if (opts.enableSymlinking || opts['enable-symlinking']) {
+			args.push('--enable-symlinking');
+		}
+		if (opts.enableMl || opts['enable-ml']) {
+			args.push('--enable-ml');
+		}
+		
+		if (opts.paths?.length) {
+			args.push('--paths', ...opts.paths);
+		}
+		
+		const res = await runCore(args);
+		if (res.code !== 0) {
+			if (!g.quiet) logger.error(res.stderr || 'Optimize failed');
+			process.exit(res.code);
+		}
+		await output(res.stdout, (g.format || 'json'));
+	});
+
+program
+	.command('symlink')
+	.description('Execute symlinking for duplicate packages across projects')
+	.option('-p, --paths <paths...>', 'Paths to process', [])
+	.action(async (opts, cmd) => {
+		const g = cmd.parent?.opts?.() || {};
+		const args = ['symlink'];
+		if (opts.paths?.length) {
+			args.push('--paths', ...opts.paths);
+		}
+		const res = await runCore(args);
+		if (res.code !== 0) {
+			if (!g.quiet) logger.error(res.stderr || 'Symlink failed');
+			process.exit(res.code);
+		}
+		await output(res.stdout, (g.format || 'json'));
+	});
+
+program.parse(process.argv);

package/src/core/bindings.ts

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

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

@@ -0,0 +1,32 @@
+/**
+ * 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(),
+  ];
+}
+