packagepurge 1.0.0 → 2.0.0

package/core/src/optimization.rs

@@ -1,314 +0,0 @@
-use anyhow::Result;
-use chrono::{Duration, Utc};
-use std::collections::{HashMap, HashSet};
-use std::path::PathBuf;
-
-use crate::types::{DryRunReport, PlanItem, ScanOutput, PackageUsageMetrics, ProjectMetadata, DeveloperBehavior};
-use crate::symlink::SemanticDeduplication;
-use crate::cache::PackageLruCache;
-use crate::ml::{MlRecommender, PredictiveOptimizer};
-
-#[allow(dead_code)]
-pub enum EvictionPolicy {
-	MlThenArcThenLru,
-	LruOnly,
-}
-
-#[allow(dead_code)]
-pub struct RulesConfig {
-	pub preserve_days: i64,
-	#[allow(dead_code)]
-	pub enable_symlinking: bool,
-	#[allow(dead_code)]
-	pub enable_ml_prediction: bool,
-	#[allow(dead_code)]
-	pub lru_max_packages: usize,
-	#[allow(dead_code)]
-	pub lru_max_size_bytes: u64,
-}
-
-pub fn plan_basic_cleanup(scan: &ScanOutput, cfg: &RulesConfig) -> Result<DryRunReport> {
-	let cutoff = Utc::now() - Duration::days(cfg.preserve_days);
-
-	let mut used: HashSet<(String, String)> = HashSet::new();
-	for proj in &scan.projects {
-		for (n, v) in &proj.dependencies {
-			used.insert((n.clone(), v.clone()));
-		}
-	}
-
-	let mut seen_locations: HashMap<(String, String), Vec<PathBuf>> = HashMap::new();
-
-	let mut items: Vec<PlanItem> = Vec::new();
-	for pkg in &scan.packages {
-		let key = (pkg.name.clone(), pkg.version.clone());
-		seen_locations.entry(key.clone()).or_default().push(PathBuf::from(&pkg.path));
-
-		let is_orphan = !used.contains(&key);
-		let is_old = pkg.mtime < cutoff;
-
-		if is_orphan || is_old {
-			items.push(PlanItem {
-				target_path: pkg.path.clone(),
-				estimated_size_bytes: pkg.size_bytes,
-				reason: if is_orphan { "orphaned".into() } else { "old".into() },
-			});
-		}
-	}
-
-	for (_key, paths) in seen_locations.into_iter() {
-		if paths.len() > 1 {
-			for p in paths.into_iter().skip(1) {
-				items.push(PlanItem { target_path: p.to_string_lossy().to_string(), estimated_size_bytes: 0, reason: "duplicate".into() });
-			}
-		}
-	}
-
-	let total = items.iter().map(|i| i.estimated_size_bytes).sum();
-	Ok(DryRunReport { items, total_estimated_bytes: total })
-}
-
-/// Optimization engine with symlinking and ML/LRU strategies
-#[allow(dead_code)]
-pub struct OptimizationEngine {
-	deduplication: Option<SemanticDeduplication>,
-	lru_cache: Option<PackageLruCache>,
-	ml_predictor: Option<PredictiveOptimizer>,
-	config: RulesConfig,
-}
-
-#[allow(dead_code)]
-impl OptimizationEngine {
-	pub fn new(config: RulesConfig) -> Result<Self> {
-		let deduplication = if config.enable_symlinking {
-			Some(SemanticDeduplication::new()?)
-		} else {
-			None
-		};
-
-		let lru_cache = Some(PackageLruCache::new(
-			config.lru_max_packages,
-			config.lru_max_size_bytes,
-		));
-
-		let ml_predictor = if config.enable_ml_prediction {
-			Some(PredictiveOptimizer::new(config.preserve_days))
-		} else {
-			None
-		};
-
-		Ok(Self {
-			deduplication,
-			lru_cache,
-			ml_predictor,
-			config,
-		})
-	}
-
-	/// Plan cleanup with symlinking and ML/LRU optimization
-	pub fn plan_optimized_cleanup(
-		&mut self,
-		scan: &ScanOutput,
-	) -> Result<DryRunReport> {
-		let cutoff = Utc::now() - Duration::days(self.config.preserve_days);
-
-		// Build usage metrics map from scan
-		let mut usage_map: HashMap<String, PackageUsageMetrics> = HashMap::new();
-		for pkg in &scan.packages {
-			let key = format!("{}@{}", pkg.name, pkg.version);
-			let metrics = PackageUsageMetrics {
-				package_key: key.clone(),
-				last_access_time: pkg.atime,
-				last_script_execution: None, // Would be populated from execution tracking
-				access_count: 1, // Would be tracked over time
-				script_execution_count: 0,
-				last_successful_build: None,
-			};
-			usage_map.insert(key, metrics);
-		}
-
-		// Build project metadata map
-		let mut project_map: HashMap<String, ProjectMetadata> = HashMap::new();
-		for proj in &scan.projects {
-			let metadata = ProjectMetadata {
-				path: proj.path.clone(),
-				project_type: detect_project_type(&proj.path),
-				last_commit_date: None, // Would be populated from git
-				dependency_count: proj.dependencies.len(),
-				last_modified: proj.mtime,
-			};
-			project_map.insert(proj.path.clone(), metadata);
-		}
-
-		let mut used: HashSet<(String, String)> = HashSet::new();
-		for proj in &scan.projects {
-			for (n, v) in &proj.dependencies {
-				used.insert((n.clone(), v.clone()));
-			}
-		}
-
-		let mut seen_locations: HashMap<(String, String), Vec<PathBuf>> = HashMap::new();
-		let mut items: Vec<PlanItem> = Vec::new();
-		let mut symlink_candidates: Vec<(PathBuf, String, String)> = Vec::new();
-
-		for pkg in &scan.packages {
-			let key = (pkg.name.clone(), pkg.version.clone());
-			seen_locations.entry(key.clone()).or_default().push(PathBuf::from(&pkg.path));
-
-			let package_key = format!("{}@{}", pkg.name, pkg.version);
-			let is_orphan = !used.contains(&key);
-			let is_old = pkg.mtime < cutoff;
-
-			// Record access in LRU cache
-			if let Some(ref mut cache) = self.lru_cache {
-				cache.record_access(&package_key, pkg.size_bytes);
-			}
-
-			// Check ML prediction
-			let should_keep_ml = if let Some(ref predictor) = self.ml_predictor {
-				if let (Some(metrics), Some(proj_path)) = (usage_map.get(&package_key), pkg.project_paths.first()) {
-					if let Some(project_meta) = project_map.get(proj_path) {
-						let behavior = DeveloperBehavior {
-							npm_commands_executed: Vec::new(), // Would be populated from tracking
-							file_access_frequency: 0,
-							days_since_last_build: None,
-						};
-						predictor.should_keep(&package_key, metrics, project_meta, &behavior)
-					} else {
-						true // Conservative: keep if no project metadata
-					}
-				} else {
-					true
-				}
-			} else {
-				true
-			};
-
-			// Check LRU strategy
-			let should_keep_lru = if let Some(ref mut cache) = self.lru_cache {
-				cache.should_keep_lru(&package_key, self.config.preserve_days)
-			} else {
-				true
-			};
-
-			// Determine if package should be removed
-			if is_orphan || (is_old && !should_keep_ml && !should_keep_lru) {
-				items.push(PlanItem {
-					target_path: pkg.path.clone(),
-					estimated_size_bytes: pkg.size_bytes,
-					reason: if is_orphan {
-						"orphaned".into()
-					} else if !should_keep_ml {
-						"ml_predicted_unused".into()
-					} else {
-						"old".into()
-					},
-				});
-			}
-
-			// Collect symlink candidates (duplicates)
-			if let Some(ref _dedup) = self.deduplication {
-				if seen_locations.get(&key).map(|v| v.len()).unwrap_or(0) > 1 {
-					symlink_candidates.push((PathBuf::from(&pkg.path), pkg.name.clone(), pkg.version.clone()));
-				}
-			}
-		}
-
-		// Process symlink candidates (in dry run, just mark them)
-		for (path, _name, _version) in symlink_candidates {
-			items.push(PlanItem {
-				target_path: path.to_string_lossy().to_string(),
-				estimated_size_bytes: 0,
-				reason: "duplicate_symlink_candidate".into(),
-			});
-		}
-
-		let total = items.iter().map(|i| i.estimated_size_bytes).sum();
-		Ok(DryRunReport { items, total_estimated_bytes: total })
-	}
-
-	/// Execute symlinking for duplicate packages
-	pub fn execute_symlinking(&self, scan: &ScanOutput) -> Result<usize> {
-		if let Some(ref dedup) = self.deduplication {
-			let mut seen: HashMap<(String, String), PathBuf> = HashMap::new();
-			let mut symlinked_count = 0;
-
-			for pkg in &scan.packages {
-				let key = (pkg.name.clone(), pkg.version.clone());
-				
-				// Keep first occurrence as canonical
-				let canonical = seen.entry(key.clone()).or_insert_with(|| PathBuf::from(&pkg.path));
-				
-				// Symlink duplicates
-				if canonical.to_string_lossy() != pkg.path {
-					let pkg_path = PathBuf::from(&pkg.path);
-					if let Err(e) = dedup.deduplicate_package(&pkg_path, &pkg.name, &pkg.version) {
-						eprintln!("Failed to symlink {:?}: {}", pkg_path, e);
-					} else {
-						symlinked_count += 1;
-					}
-				}
-			}
-
-			Ok(symlinked_count)
-		} else {
-			Ok(0)
-		}
-	}
-}
-
-fn detect_project_type(project_path: &str) -> String {
-	use std::fs;
-	use std::path::Path;
-	
-	let path = Path::new(project_path);
-	let package_json = path.join("package.json");
-	
-	// Check package.json for project type indicators
-	if package_json.exists() {
-		if let Ok(content) = fs::read_to_string(&package_json) {
-			if let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) {
-				// Check for framework-specific dependencies
-				if let Some(deps) = json.get("dependencies").and_then(|d| d.as_object()) {
-					if deps.contains_key("react") || deps.contains_key("next") {
-						return "react".into();
-					}
-					if deps.contains_key("vue") || deps.contains_key("nuxt") {
-						return "vue".into();
-					}
-					if deps.contains_key("angular") || deps.contains_key("@angular/core") {
-						return "angular".into();
-					}
-				}
-				
-				// Check devDependencies
-				if let Some(dev_deps) = json.get("devDependencies").and_then(|d| d.as_object()) {
-					if dev_deps.contains_key("typescript") || dev_deps.contains_key("tsc") {
-						return "typescript".into();
-					}
-				}
-			}
-		}
-		
-		// Check for TypeScript config files
-		if path.join("tsconfig.json").exists() {
-			return "typescript".into();
-		}
-		
-		// Check for Next.js
-		if path.join("next.config.js").exists() || path.join("next.config.ts").exists() {
-			return "nextjs".into();
-		}
-		
-		// Check path-based heuristics as fallback
-		let path_lower = project_path.to_lowercase();
-		if path_lower.contains("react") || path_lower.contains("next") {
-			return "react".into();
-		}
-		if path_lower.contains("typescript") || path_lower.contains("ts") {
-			return "typescript".into();
-		}
-	}
-	
-	"node".into()
-}

package/core/src/safety.rs

@@ -1,103 +0,0 @@
-use anyhow::{Context, Result};
-use chrono::Utc;
-use sha2::{Digest, Sha256};
-use std::{fs, path::{Path, PathBuf}};
-
-use crate::types::QuarantineRecord;
-
-fn quarantine_dir() -> PathBuf {
-    let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
-    home.join(".packagepurge").join("quarantine")
-}
-
-fn index_path() -> PathBuf {
-    quarantine_dir().join("index.json")
-}
-
-fn read_index() -> Vec<QuarantineRecord> {
-    let p = index_path();
-    if let Ok(text) = fs::read_to_string(&p) {
-        if let Ok(list) = serde_json::from_str::<Vec<QuarantineRecord>>(&text) { return list; }
-    }
-    Vec::new()
-}
-
-fn write_index(mut list: Vec<QuarantineRecord>) -> Result<()> {
-    // keep only recent N entries (e.g., 200) to bound file size
-    if list.len() > 200 { let keep = list.split_off(list.len() - 200); list = keep; }
-    let data = serde_json::to_string_pretty(&list)?;
-    fs::write(index_path(), data).context("Failed to write quarantine index")?;
-    Ok(())
-}
-
-fn sha256_dir(path: &Path) -> Result<(String, u64)> {
-    let mut hasher = Sha256::new();
-    let mut total: u64 = 0;
-    for entry in walkdir::WalkDir::new(path).into_iter().filter_map(|e| e.ok()) {
-        let p = entry.path();
-        hasher.update(p.to_string_lossy().as_bytes());
-        if entry.file_type().is_file() {
-            let data = fs::read(p)?;
-            total += data.len() as u64;
-            hasher.update(&data);
-        }
-    }
-    Ok((hex::encode(hasher.finalize()), total))
-}
-
-pub fn move_to_quarantine(target: &Path) -> Result<QuarantineRecord> {
-    let qdir = quarantine_dir();
-    fs::create_dir_all(&qdir).ok();
-    let id = format!("{}", Utc::now().timestamp_nanos_opt().unwrap_or(0));
-    let (checksum, size) = sha256_dir(target)?;
-    let qpath = qdir.join(format!("{}_{}", id, target.file_name().unwrap_or_default().to_string_lossy()));
-    if let Err(e) = fs::rename(target, &qpath) {
-        // Handle cross-device link errors (os error 17 or 18 on Unix, or similar on Windows)
-        // We simply try copy-and-delete as fallback for any rename failure
-        if let Err(copy_err) = fs_extra::dir::copy(target, &qpath, &fs_extra::dir::CopyOptions::new().content_only(true)) {
-             return Err(anyhow::anyhow!("Failed to move {:?} to quarantine (rename failed: {}, copy failed: {})", target, e, copy_err));
-        }
-        if let Err(rm_err) = fs::remove_dir_all(target) {
-            // If we can't remove original, we should probably clean up the quarantine copy
-            fs::remove_dir_all(&qpath).ok();
-            return Err(anyhow::anyhow!("Failed to remove original {:?} after copy to quarantine: {}", target, rm_err));
-        }
-    }
-    let rec = QuarantineRecord {
-        id,
-        original_path: target.to_string_lossy().to_string(),
-        quarantine_path: qpath.to_string_lossy().to_string(),
-        sha256: checksum,
-        size_bytes: size,
-        created_at: Utc::now(),
-    };
-    let mut list = read_index();
-    list.push(rec.clone());
-    write_index(list)?;
-    Ok(rec)
-}
-
-#[allow(dead_code)]
-pub fn list_quarantine() -> Vec<QuarantineRecord> { read_index() }
-
-pub fn latest_quarantine() -> Option<QuarantineRecord> {
-    let mut list = read_index();
-    list.sort_by_key(|r| r.created_at);
-    list.pop()
-}
-
-pub fn find_quarantine_by_id(id: &str) -> Option<QuarantineRecord> {
-    read_index().into_iter().find(|r| r.id == id)
-}
-
-pub fn rollback_record(rec: &QuarantineRecord) -> Result<()> {
-    let orig = PathBuf::from(&rec.original_path);
-    let q = PathBuf::from(&rec.quarantine_path);
-    if let Some(parent) = orig.parent() { fs::create_dir_all(parent).ok(); }
-    fs::rename(&q, &orig).with_context(|| "Failed to rollback from quarantine")?;
-    // remove from index
-    let mut list = read_index();
-    list.retain(|r| r.id != rec.id);
-    write_index(list)?;
-    Ok(())
-}

package/core/src/scanner.rs

@@ -1,136 +0,0 @@
-use anyhow::Result;
-use chrono::{DateTime, Utc};
-use rayon::prelude::*;
-use std::{fs, path::{Path, PathBuf}, time::SystemTime};
-use walkdir::WalkDir;
-
-use crate::types::{PackageRecord, ProjectRecord, ScanOutput, PackageManager};
-use crate::lockfiles::{parse_npm_package_lock, parse_yarn_lock, parse_pnpm_lock};
-
-fn to_utc(st: SystemTime) -> DateTime<Utc> { st.into() }
-
-fn dir_size(path: &Path) -> u64 {
-    let mut total: u64 = 0;
-    for entry in WalkDir::new(path).into_iter().filter_map(|e| e.ok()) {
-        if entry.file_type().is_file() {
-            if let Ok(meta) = entry.metadata() {
-                total += meta.len();
-            }
-        }
-    }
-    total
-}
-
-fn detect_manager_from_lock(dir: &Path) -> Option<PackageManager> {
-    if dir.join("package-lock.json").exists() { return Some(PackageManager::Npm); }
-    if dir.join("yarn.lock").exists() { return Some(PackageManager::Yarn); }
-    if dir.join("pnpm-lock.yaml").exists() { return Some(PackageManager::Pnpm); }
-    None
-}
-
-fn collect_projects_and_edges(root: &Path) -> (Vec<ProjectRecord>, Vec<(String, String)>) {
-    let mut projects = Vec::new();
-    let edges: Vec<(String, String)> = Vec::new();
-    for entry in WalkDir::new(root).max_depth(6).into_iter().filter_map(|e| e.ok()) {
-        if entry.file_type().is_file() && entry.file_name() == "package.json" {
-            let dir = entry.path().parent().unwrap_or(root);
-            let manager = detect_manager_from_lock(dir);
-            let mtime = fs::metadata(entry.path()).and_then(|m| m.modified()).ok()
-                .map(to_utc).unwrap_or_else(|| Utc::now());
-            // Basic dependency extraction from package.json
-            let mut deps: Vec<(String, String)> = Vec::new();
-            if let Ok(content) = fs::read_to_string(entry.path()) {
-                if let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) {
-                    for key in ["dependencies", "devDependencies", "peerDependencies"] {
-                        if let Some(obj) = json.get(key).and_then(|v| v.as_object()) {
-                            for (name, ver) in obj {
-                                if let Some(ver_str) = ver.as_str() {
-                                    deps.push((name.clone(), ver_str.to_string()));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            // Lockfile dependencies
-            let lock_deps = match manager {
-                Some(PackageManager::Npm) => parse_npm_package_lock(&dir.join("package-lock.json")),
-                Some(PackageManager::Yarn) => parse_yarn_lock(&dir.join("yarn.lock")),
-                Some(PackageManager::Pnpm) => parse_pnpm_lock(&dir.join("pnpm-lock.yaml")),
-                None => Vec::new(),
-            };
-            deps.extend(lock_deps);
-
-            projects.push(ProjectRecord {
-                path: dir.to_string_lossy().to_string(),
-                manager,
-                dependencies: deps,
-                mtime,
-            });
-        }
-    }
-    (projects, edges)
-}
-
-fn is_cache_dir(path: &Path) -> bool {
-    let p = path.to_string_lossy().to_lowercase();
-    p.ends_with(".npm") || p.contains("yarn/cache") || p.contains("pnpm/store")
-}
-
-pub fn scan(paths: &[PathBuf]) -> Result<ScanOutput> {
-    let roots: Vec<PathBuf> = if paths.is_empty() { vec![std::env::current_dir()?] } else { paths.to_vec() };
-
-    let mut all_projects: Vec<ProjectRecord> = Vec::new();
-    let mut all_edges: Vec<(String, String)> = Vec::new();
-    for root in &roots {
-        let (projects, edges) = collect_projects_and_edges(root);
-        all_projects.extend(projects);
-        all_edges.extend(edges);
-    }
-
-    // Collect packages in node_modules and caches
-    let mut package_dirs: Vec<PathBuf> = Vec::new();
-    for root in &roots {
-        for entry in WalkDir::new(root).into_iter().filter_map(|e| e.ok()) {
-            if entry.file_type().is_dir() {
-                let name = entry.file_name().to_string_lossy();
-                if name == "node_modules" || is_cache_dir(entry.path()) {
-                    package_dirs.push(entry.into_path());
-                }
-            }
-        }
-    }
-
-    let packages: Vec<PackageRecord> = package_dirs.par_iter().flat_map(|dir| {
-        WalkDir::new(dir).min_depth(1).max_depth(3).into_iter().filter_map(|e| e.ok())
-            .filter(|e| e.file_type().is_dir())
-            .filter_map(|pkg_dir| {
-                let pkg_path = pkg_dir.path().to_path_buf();
-                let package_json = pkg_path.join("package.json");
-                if !package_json.exists() { return None; }
-                let meta = fs::metadata(&pkg_path).ok()?;
-                let atime = meta.accessed().ok().map(to_utc).unwrap_or_else(|| Utc::now());
-                let mtime = meta.modified().ok().map(to_utc).unwrap_or_else(|| Utc::now());
-                let size = dir_size(&pkg_path);
-                let (name, version) = if let Ok(text) = fs::read_to_string(&package_json) {
-                    if let Ok(json) = serde_json::from_str::<serde_json::Value>(&text) {
-                        let n = json.get("name").and_then(|v| v.as_str()).unwrap_or("unknown").to_string();
-                        let v = json.get("version").and_then(|v| v.as_str()).unwrap_or("unknown").to_string();
-                        (n, v)
-                    } else { ("unknown".into(), "unknown".into()) }
-                } else { ("unknown".into(), "unknown".into()) };
-                Some(PackageRecord {
-                    name,
-                    version,
-                    path: pkg_path.to_string_lossy().to_string(),
-                    size_bytes: size,
-                    atime,
-                    mtime,
-                    manager: None,
-                    project_paths: Vec::new(),
-                })
-            }).collect::<Vec<_>>()
-    }).collect();
-
-    Ok(ScanOutput { packages, projects: all_projects, edges: all_edges })
-}