packagepurge 1.0.0 → 2.0.0

package/core/src/symlink.rs

@@ -1,223 +0,0 @@
-use anyhow::{Context, Result};
-use std::fs;
-use std::path::{Path, PathBuf};
-
-#[cfg(windows)]
-use std::os::windows::fs as win_fs;
-
-#[cfg(unix)]
-use std::os::unix::fs as unix_fs;
-
-/// Global store path (platform-specific)
-pub fn get_global_store_path() -> Result<PathBuf> {
-    let home = dirs::home_dir().context("Could not determine home directory")?;
-    Ok(home.join(".packagepurge").join("global_store"))
-}
-
-/// Initialize global store directory
-pub fn ensure_global_store() -> Result<PathBuf> {
-    let store_path = get_global_store_path()?;
-    fs::create_dir_all(&store_path)
-        .with_context(|| format!("Failed to create global store at {:?}", store_path))?;
-    Ok(store_path)
-}
-
-/// Generate content-addressable path for a package
-/// Format: global_store/{name}/{version}/{hash}
-pub fn get_canonical_path(store_path: &Path, name: &str, version: &str) -> Result<PathBuf> {
-    // Use a simple hash of name@version for content addressing
-    use sha2::{Digest, Sha256};
-    let mut hasher = Sha256::new();
-    hasher.update(format!("{}@{}", name, version).as_bytes());
-    let hash = hex::encode(&hasher.finalize()[..8]);
-    
-    Ok(store_path
-        .join(sanitize_name(name))
-        .join(version)
-        .join(&hash))
-}
-
-fn sanitize_name(name: &str) -> String {
-    name.replace("/", "_").replace("\\", "_").replace(":", "_")
-}
-
-/// Check if a path is a symlink (or junction on Windows)
-pub fn is_symlink(path: &Path) -> bool {
-    #[cfg(windows)]
-    {
-        // On Windows, try to read the link - if it succeeds, it's a symlink
-        if fs::read_link(path).is_ok() {
-            return true;
-        }
-        // Also check metadata for symlink file type
-        if let Ok(meta) = fs::symlink_metadata(path) {
-            return meta.file_type().is_symlink();
-        }
-        false
-    }
-    
-    #[cfg(unix)]
-    {
-        if let Ok(meta) = fs::symlink_metadata(path) {
-            meta.file_type().is_symlink()
-        } else {
-            false
-        }
-    }
-}
-
-/// Create hard links for all files in source directory to target directory
-pub fn hard_link_directory(src: &Path, dst: &Path) -> Result<()> {
-    if dst.exists() {
-        fs::remove_dir_all(dst)
-            .with_context(|| format!("Failed to remove existing directory {:?}", dst))?;
-    }
-    fs::create_dir_all(dst)
-        .with_context(|| format!("Failed to create directory {:?}", dst))?;
-
-    // Recursively hard link all files
-    copy_directory_with_hard_links(src, dst)?;
-    Ok(())
-}
-
-fn copy_directory_with_hard_links(src: &Path, dst: &Path) -> Result<()> {
-    use walkdir::WalkDir;
-    
-    for entry in WalkDir::new(src).into_iter().filter_map(|e| e.ok()) {
-        let src_path = entry.path();
-        let rel_path = src_path.strip_prefix(src)
-            .with_context(|| format!("Failed to get relative path from {:?}", src))?;
-        let dst_path = dst.join(rel_path);
-
-        if src_path.is_dir() {
-            fs::create_dir_all(&dst_path)
-                .with_context(|| format!("Failed to create directory {:?}", dst_path))?;
-        } else if src_path.is_file() {
-            if let Some(parent) = dst_path.parent() {
-                fs::create_dir_all(parent)
-                    .with_context(|| format!("Failed to create parent directory {:?}", parent))?;
-            }
-            
-            #[cfg(unix)]
-            {
-                fs::hard_link(src_path, &dst_path)
-                    .with_context(|| format!("Failed to create hard link from {:?} to {:?}", src_path, dst_path))?;
-            }
-            
-            #[cfg(windows)]
-            {
-                // Windows: try hard link first, fall back to copy
-                if fs::hard_link(src_path, &dst_path).is_err() {
-                    // If hard link fails (e.g., different volumes), copy the file
-                    fs::copy(src_path, &dst_path)
-                        .with_context(|| format!("Failed to copy file from {:?} to {:?}", src_path, dst_path))?;
-                }
-            }
-        }
-    }
-    Ok(())
-}
-
-/// Create a symlink (or junction on Windows) from target to source
-pub fn create_symlink(target: &Path, source: &Path) -> Result<()> {
-    // Remove existing target if it exists
-    if target.exists() {
-        if target.is_dir() {
-            fs::remove_dir_all(target)
-                .with_context(|| format!("Failed to remove existing directory {:?}", target))?;
-        } else {
-            fs::remove_file(target)
-                .with_context(|| format!("Failed to remove existing file {:?}", target))?;
-        }
-    }
-    
-    // Ensure parent directory exists
-    if let Some(parent) = target.parent() {
-        fs::create_dir_all(parent)
-            .with_context(|| format!("Failed to create parent directory {:?}", parent))?;
-    }
-
-    #[cfg(windows)]
-    {
-        // On Windows, use directory symlink for directories, symlink for files
-        if source.is_dir() {
-            // Try to create a directory symlink (requires admin privileges or Developer Mode)
-            win_fs::symlink_dir(source, target)
-                .with_context(|| format!("Failed to create directory symlink from {:?} to {:?}. Note: On Windows, this may require administrator privileges or Developer Mode enabled.", target, source))?;
-        } else {
-            win_fs::symlink_file(source, target)
-                .with_context(|| format!("Failed to create file symlink from {:?} to {:?}", target, source))?;
-        }
-    }
-    
-    #[cfg(unix)]
-    {
-        unix_fs::symlink(source, target)
-            .with_context(|| format!("Failed to create symlink from {:?} to {:?}", target, source))?;
-    }
-    
-    Ok(())
-}
-
-/// Deduplicate packages by creating symlinks to global store
-#[allow(dead_code)]
-pub struct SemanticDeduplication {
-    store_path: PathBuf,
-}
-
-impl SemanticDeduplication {
-    pub fn new() -> Result<Self> {
-        let store_path = ensure_global_store()?;
-        Ok(Self { store_path })
-    }
-
-    /// Process a package: hard link to global store, then symlink from original location
-    pub fn deduplicate_package(&self, package_path: &Path, name: &str, version: &str) -> Result<()> {
-        let canonical_path = get_canonical_path(&self.store_path, name, version)?;
-        
-        // If canonical doesn't exist, create it by hard linking from package_path
-        if !canonical_path.exists() {
-            hard_link_directory(package_path, &canonical_path)
-                .with_context(|| format!("Failed to create canonical package at {:?}", canonical_path))?;
-        }
-        
-        // If package_path is not already a symlink, replace it with one
-        if !is_symlink(package_path) {
-            // Create a temporary path for safe replacement
-            let temp_path = package_path.with_extension(".packagepurge.tmp");
-            
-            // Create symlink at temp location first
-            create_symlink(&temp_path, &canonical_path)?;
-            
-            // Remove original and rename temp
-            if package_path.is_dir() {
-                fs::remove_dir_all(package_path)
-                    .with_context(|| format!("Failed to remove original directory {:?}", package_path))?;
-            } else {
-                fs::remove_file(package_path)
-                    .with_context(|| format!("Failed to remove original file {:?}", package_path))?;
-            }
-            
-            fs::rename(&temp_path, package_path)
-                .with_context(|| format!("Failed to rename temp symlink to {:?}", package_path))?;
-        }
-        
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs;
-    use tempfile::tempdir;
-
-    #[test]
-    fn test_get_canonical_path() {
-        let store = PathBuf::from("/tmp/store");
-        let path = get_canonical_path(&store, "react", "18.2.0").unwrap();
-        assert!(path.to_string_lossy().contains("react"));
-        assert!(path.to_string_lossy().contains("18.2.0"));
-    }
-}
-

package/core/src/types.rs

@@ -1,87 +0,0 @@
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum PackageManager { Npm, Yarn, Pnpm }
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PackageRecord {
-    pub name: String,
-    pub version: String,
-    pub path: String,
-    pub size_bytes: u64,
-    pub atime: DateTime<Utc>,
-    pub mtime: DateTime<Utc>,
-    pub manager: Option<PackageManager>,
-    pub project_paths: Vec<String>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ProjectRecord {
-    pub path: String,
-    pub manager: Option<PackageManager>,
-    pub dependencies: Vec<(String, String)>,
-    pub mtime: DateTime<Utc>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ScanOutput {
-    pub packages: Vec<PackageRecord>,
-    pub projects: Vec<ProjectRecord>,
-    pub edges: Vec<(String, String)>, // parent -> dependency
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PlanItem {
-    pub target_path: String,
-    pub estimated_size_bytes: u64,
-    pub reason: String,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DryRunReport {
-    pub items: Vec<PlanItem>,
-    pub total_estimated_bytes: u64,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct QuarantineRecord {
-    pub id: String,
-    pub original_path: String,
-    pub quarantine_path: String,
-    pub sha256: String,
-    pub size_bytes: u64,
-    pub created_at: DateTime<Utc>,
-}
-
-/// Usage metrics for a package
-#[allow(dead_code)]
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct PackageUsageMetrics {
-    pub package_key: String, // Format: "name@version"
-    pub last_access_time: DateTime<Utc>,
-    pub last_script_execution: Option<DateTime<Utc>>,
-    pub access_count: u64,
-    pub script_execution_count: u64,
-    pub last_successful_build: Option<DateTime<Utc>>,
-}
-
-/// Project metadata for ML features
-#[allow(dead_code)]
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ProjectMetadata {
-    pub path: String,
-    pub project_type: String, // e.g., "react", "node", "typescript"
-    pub last_commit_date: Option<DateTime<Utc>>,
-    pub dependency_count: usize,
-    pub last_modified: DateTime<Utc>,
-}
-
-/// Developer behavior metrics
-#[allow(dead_code)]
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DeveloperBehavior {
-    pub npm_commands_executed: Vec<(String, DateTime<Utc>)>, // (command, timestamp)
-    pub file_access_frequency: u64,
-    pub days_since_last_build: Option<i64>,
-}

package/core/src/usage_tracker.rs

@@ -1,107 +0,0 @@
-#![allow(dead_code)]
-use anyhow::{Context, Result};
-use std::collections::HashMap;
-use std::fs;
-use std::path::{Path, PathBuf};
-
-use crate::types::PackageUsageMetrics;
-use crate::cache::PackageLruCache;
-
-/// Tracks and persists package usage metrics across runs
-pub struct UsageTracker {
-    cache_path: PathBuf,
-    lru_cache: PackageLruCache,
-}
-
-impl UsageTracker {
-    pub fn new(cache_path: PathBuf, max_packages: usize, max_size_bytes: u64) -> Result<Self> {
-        // Ensure cache directory exists
-        if let Some(parent) = cache_path.parent() {
-            fs::create_dir_all(parent)
-                .with_context(|| format!("Failed to create cache directory {:?}", parent))?;
-        }
-
-        let mut tracker = Self {
-            cache_path: cache_path.clone(),
-            lru_cache: PackageLruCache::new(max_packages, max_size_bytes),
-        };
-
-        // Load existing metrics if available
-        if cache_path.exists() {
-            if let Ok(metrics) = tracker.load_metrics() {
-                for (key, _metric) in metrics {
-                    tracker.lru_cache.record_access(&key, 0); // Size will be updated on scan
-                }
-            }
-        }
-
-        Ok(tracker)
-    }
-
-    /// Load persisted metrics from disk
-    fn load_metrics(&self) -> Result<HashMap<String, PackageUsageMetrics>> {
-        let content = fs::read_to_string(&self.cache_path)
-            .with_context(|| format!("Failed to read cache file {:?}", self.cache_path))?;
-        let metrics: HashMap<String, PackageUsageMetrics> = serde_json::from_str(&content)
-            .with_context(|| "Failed to parse metrics cache")?;
-        Ok(metrics)
-    }
-
-    /// Persist metrics to disk
-    pub fn save_metrics(&self) -> Result<()> {
-        // In a full implementation, we'd collect all metrics from the LRU cache
-        // For now, this is a placeholder that would be called after optimization runs
-        Ok(())
-    }
-
-    /// Record a script execution (e.g., npm run build, npm test)
-    /// This should be called when monitoring detects script execution
-    pub fn record_script_execution(&mut self, package_key: &str) {
-        self.lru_cache.record_script_execution(package_key);
-    }
-
-    /// Record a successful build
-    pub fn record_build(&mut self, package_key: &str) {
-        self.lru_cache.record_build(package_key);
-    }
-
-    /// Get the LRU cache for direct access
-    pub fn lru_cache_mut(&mut self) -> &mut PackageLruCache {
-        &mut self.lru_cache
-    }
-}
-
-/// Helper to detect script execution from package.json scripts
-/// This would be integrated with npm/yarn execution monitoring
-pub fn detect_script_execution(project_path: &Path, script_name: &str) -> Vec<String> {
-    use std::fs;
-    use serde_json::Value;
-
-    let package_json = project_path.join("package.json");
-    if !package_json.exists() {
-        return Vec::new();
-    }
-
-    let mut affected_packages = Vec::new();
-
-    if let Ok(content) = fs::read_to_string(&package_json) {
-        if let Ok(json) = serde_json::from_str::<Value>(&content) {
-            // Check if script exists
-            if let Some(scripts) = json.get("scripts").and_then(|s| s.as_object()) {
-                if scripts.contains_key(script_name) {
-                    // In a full implementation, we'd parse the script to find dependencies
-                    // For now, we'll extract direct dependencies
-                    if let Some(deps) = json.get("dependencies").and_then(|d| d.as_object()) {
-                        for (name, version) in deps {
-                            if let Some(ver_str) = version.as_str() {
-                                affected_packages.push(format!("{}@{}", name, ver_str));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    affected_packages
-}

package/src/cli/index.ts

@@ -1,212 +0,0 @@
-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);