packagepurge 1.0.0 → 2.0.0

package/core/src/cache.rs

@@ -1,205 +0,0 @@
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::hash::Hash;
-use std::rc::Rc;
-use chrono::Utc;
-use crate::types::PackageUsageMetrics;
-
-// Doubly-linked list node
-struct Node<K, V> {
-	key: K,
-	value: V,
-	prev: Option<Rc<RefCell<Node<K, V>>>>,
-	next: Option<Rc<RefCell<Node<K, V>>>>,
-}
-
-pub struct LruCache<K, V> where K: Eq + Hash + Clone {
-	capacity: usize,
-	map: HashMap<K, Rc<RefCell<Node<K, V>>>>,
-	head: Option<Rc<RefCell<Node<K, V>>>>, // MRU
-	tail: Option<Rc<RefCell<Node<K, V>>>>, // LRU
-}
-
-impl<K, V> LruCache<K, V> where K: Eq + Hash + Clone {
-	pub fn new(capacity: usize) -> Self {
-		Self { capacity, map: HashMap::new(), head: None, tail: None }
-	}
-
-	#[allow(dead_code)]
-	pub fn len(&self) -> usize { self.map.len() }
-	#[allow(dead_code)]
-	pub fn is_empty(&self) -> bool { self.map.is_empty() }
-
-	pub fn get(&mut self, key: &K) -> Option<V> where V: Clone {
-		if let Some(node_rc) = self.map.get(key).cloned() {
-			self.move_to_head(node_rc.clone());
-			return Some(node_rc.borrow().value.clone());
-		}
-		None
-	}
-
-	pub fn put(&mut self, key: K, value: V) -> Option<(K, V)> where V: Clone {
-		if let Some(node_rc) = self.map.get(&key).cloned() {
-			// Update value and move to head
-			node_rc.borrow_mut().value = value;
-			self.move_to_head(node_rc);
-			return None;
-		}
-		// Insert new
-		let node = Rc::new(RefCell::new(Node { key: key.clone(), value, prev: None, next: None }));
-		self.attach_head(node.clone());
-		self.map.insert(key.clone(), node);
-		// Evict if over capacity
-		if self.map.len() > self.capacity {
-			if let Some(lru) = self.pop_tail() {
-				let k = lru.borrow().key.clone();
-				let v = lru.borrow().value.clone();
-				self.map.remove(&k);
-				return Some((k, v));
-			}
-		}
-		None
-	}
-
-	fn detach(&mut self, node: Rc<RefCell<Node<K, V>>>) {
-		let prev = node.borrow().prev.clone();
-		let next = node.borrow().next.clone();
-		if let Some(p) = prev.clone() { p.borrow_mut().next = next.clone(); } else { self.head = next.clone(); }
-		if let Some(n) = next.clone() { n.borrow_mut().prev = prev.clone(); } else { self.tail = prev.clone(); }
-		node.borrow_mut().prev = None;
-		node.borrow_mut().next = None;
-	}
-
-	fn attach_head(&mut self, node: Rc<RefCell<Node<K, V>>>) {
-		node.borrow_mut().prev = None;
-		node.borrow_mut().next = self.head.clone();
-		if let Some(h) = self.head.clone() { h.borrow_mut().prev = Some(node.clone()); }
-		self.head = Some(node.clone());
-		if self.tail.is_none() { self.tail = Some(node); }
-	}
-
-	fn move_to_head(&mut self, node: Rc<RefCell<Node<K, V>>>) {
-		self.detach(node.clone());
-		self.attach_head(node);
-	}
-
-	fn pop_tail(&mut self) -> Option<Rc<RefCell<Node<K, V>>>> {
-		if let Some(t) = self.tail.clone() {
-			self.detach(t.clone());
-			return Some(t);
-		}
-		None
-	}
-}
-
-/// LRU cache specialized for package versions with usage tracking
-#[allow(dead_code)]
-pub struct PackageLruCache {
-	cache: LruCache<String, PackageUsageMetrics>,
-	max_size_bytes: u64,
-	current_size_bytes: u64,
-}
-
-impl PackageLruCache {
-	pub fn new(max_packages: usize, max_size_bytes: u64) -> Self {
-		Self {
-			cache: LruCache::new(max_packages),
-			max_size_bytes,
-			current_size_bytes: 0,
-		}
-	}
-
-	/// Record package access (updates atime and increments access count)
-	pub fn record_access(&mut self, package_key: &str, size_bytes: u64) {
-		let now = Utc::now();
-		if let Some(metrics) = self.cache.get(&package_key.to_string()) {
-			// Update existing metrics
-			let mut updated = metrics;
-			updated.last_access_time = now;
-			updated.access_count += 1;
-			self.cache.put(package_key.to_string(), updated);
-		} else {
-			// Create new metrics
-			let metrics = PackageUsageMetrics {
-				package_key: package_key.to_string(),
-				last_access_time: now,
-				last_script_execution: None,
-				access_count: 1,
-				script_execution_count: 0,
-				last_successful_build: None,
-			};
-			if let Some((_evicted_key, _evicted_metrics)) = self.cache.put(package_key.to_string(), metrics) {
-				// Handle eviction if needed
-				// In a full implementation, we'd track size_bytes per package
-			}
-			self.current_size_bytes += size_bytes;
-		}
-	}
-
-	/// Record successful script execution
-	#[allow(dead_code)]
-	pub fn record_script_execution(&mut self, package_key: &str) {
-		let now = Utc::now();
-		if let Some(metrics) = self.cache.get(&package_key.to_string()) {
-			let mut updated = metrics;
-			updated.last_script_execution = Some(now);
-			updated.script_execution_count += 1;
-			self.cache.put(package_key.to_string(), updated);
-		}
-	}
-
-	/// Record successful build
-	#[allow(dead_code)]
-	pub fn record_build(&mut self, package_key: &str) {
-		let now = Utc::now();
-		if let Some(metrics) = self.cache.get(&package_key.to_string()) {
-			let mut updated = metrics;
-			updated.last_successful_build = Some(now);
-			self.cache.put(package_key.to_string(), updated);
-		}
-	}
-
-	/// Get metrics for a package (updates LRU position)
-	pub fn get_metrics(&mut self, package_key: &str) -> Option<PackageUsageMetrics> {
-		self.cache.get(&package_key.to_string())
-	}
-
-	/// Get least recently used packages (for eviction candidates)
-	#[allow(dead_code)]
-	pub fn get_lru_packages(&self, _count: usize) -> Vec<String> {
-		// This is a simplified version - in a full implementation,
-		// we'd need to iterate through the tail of the LRU cache
-		Vec::new() // Placeholder
-	}
-
-	/// Check if package should be kept based on LRU strategy
-	pub fn should_keep_lru(&mut self, package_key: &str, days_threshold: i64) -> bool {
-		if let Some(metrics) = self.get_metrics(package_key) {
-			let days_since_access = (Utc::now() - metrics.last_access_time).num_days();
-			return days_since_access < days_threshold;
-		}
-		false
-	}
-}
-
-#[cfg(test)]
-mod tests {
-	use super::LruCache;
-	#[test]
-	fn test_lru_basic() {
-		let mut lru = LruCache::new(2);
-		assert!(lru.get(&"a").is_none());
-		assert!(lru.put("a", 1).is_none());
-		assert_eq!(lru.get(&"a"), Some(1));
-		assert!(lru.put("b", 2).is_none());
-		assert_eq!(lru.len(), 2);
-		// Insert c -> evict LRU (which should be 'a' after accessing 'a' it's MRU; LRU is 'b'?)
-		// Access changes MRU; sequence ensures eviction is correct
-		lru.get(&"a"); // 'a' MRU, 'b' LRU
-		let evicted = lru.put("c", 3);
-		assert!(evicted.is_some());
-		let (k, v) = evicted.unwrap();
-		assert_eq!(k, "b");
-		assert_eq!(v, 2);
-	}
-}

package/core/src/lockfiles.rs

@@ -1,112 +0,0 @@
-use std::fs;
-use std::path::Path;
-
-pub type DepList = Vec<(String, String)>; // (name, version)
-
-pub fn parse_npm_package_lock(path: &Path) -> DepList {
-	let mut deps_list: DepList = Vec::new();
-	let text = match fs::read_to_string(path) { Ok(t) => t, Err(_) => return deps_list };
-	let json: serde_json::Value = match serde_json::from_str(&text) { Ok(v) => v, Err(_) => return deps_list };
-	
-	fn walk(node: &serde_json::Value, list: &mut DepList) {
-		if let Some(deps) = node.get("dependencies").and_then(|d| d.as_object()) {
-			for (name, dep_node) in deps {
-				if let Some(ver) = dep_node.get("version").and_then(|v| v.as_str()) {
-					list.push((name.clone(), ver.to_string()));
-				}
-				walk(dep_node, list);
-			}
-		}
-        // Handle 'packages' in lockfile v2/v3
-        if let Some(packages) = node.get("packages").and_then(|d| d.as_object()) {
-            for (key, pkg_node) in packages {
-                if key.is_empty() { continue; } // Root
-                
-                // Key is path like "node_modules/pkg" or "node_modules/a/node_modules/b"
-                // We want the package name, which is after the last "node_modules/"
-                let name = if let Some(idx) = key.rfind("node_modules/") {
-                    key[idx + "node_modules/".len()..].to_string()
-                } else {
-                    key.clone()
-                };
-
-                if let Some(ver) = pkg_node.get("version").and_then(|v| v.as_str()) {
-                    list.push((name, ver.to_string()));
-                }
-            }
-        }
-	}
-    
-	walk(&json, &mut deps_list);
-	deps_list
-}
-
-pub fn parse_yarn_lock(path: &Path) -> DepList {
-	let mut list: DepList = Vec::new();
-	let text = match fs::read_to_string(path) { Ok(t) => t, Err(_) => return list };
-	
-	let mut current_name: Option<String> = None;
-    
-	for line in text.lines() {
-		let trimmed = line.trim();
-        if trimmed.is_empty() || trimmed.starts_with('#') { continue; }
-        
-		if !line.starts_with(' ') {
-            // Start of a block: "pkg@ver, pkg@ver:"
-            let parts: Vec<&str> = trimmed.trim_end_matches(':').split(',').collect();
-            if let Some(first) = parts.first() {
-                // Extract name from "name@range"
-                // This is heuristic; yarn lock keys are complex.
-                // Simpler: wait for "version" line.
-                // But we need the name.
-                // Pattern: name@^1.2.3
-                // Last '@' separates name and version range, but scoped packages start with @.
-                let s = first.trim().trim_matches('"');
-                if let Some(idx) = s.rfind('@') {
-                    if idx > 0 {
-                        current_name = Some(s[..idx].to_string());
-                    } else {
-                        current_name = None;
-                    }
-                }
-            }
-		} else if let Some(name) = &current_name {
-            if trimmed.starts_with("version") {
-                // version "1.2.3"
-                let parts: Vec<&str> = trimmed.split_whitespace().collect();
-                if parts.len() >= 2 {
-                    let ver = parts[1].trim_matches('"');
-                    list.push((name.clone(), ver.to_string()));
-                    current_name = None; // Reset so we don't duplicate
-                }
-            }
-        }
-	}
-	list
-}
-
-pub fn parse_pnpm_lock(path: &Path) -> DepList {
-	let mut list: DepList = Vec::new();
-	let text = match fs::read_to_string(path) { Ok(t) => t, Err(_) => return list };
-	
-	for line in text.lines() {
-		let l = line.trim();
-        // /name/version:
-		if l.starts_with('/') && l.ends_with(':') {
-            let content = l.trim_end_matches(':');
-            // content is like /@babel/core/7.2.0
-            // extract name and version.
-            // Split by '/'
-            let parts: Vec<&str> = content.split('/').collect();
-            // parts[0] is empty
-            // if scoped: "", "@scope", "pkg", "ver" -> len 4
-            // if unscoped: "", "pkg", "ver" -> len 3
-            if parts.len() >= 3 {
-                let ver = parts.last().unwrap().to_string();
-                let name = parts[1..parts.len()-1].join("/");
-                list.push((name, ver));
-            }
-		}
-	}
-	list
-}

package/core/src/main.rs

@@ -1,125 +0,0 @@
-mod types;
-mod scanner;
-mod safety;
-mod optimization;
-mod cache;
-mod ml;
-mod arc_lfu;
-mod lockfiles;
-mod symlink;
-mod usage_tracker;
-
-use anyhow::Result;
-use clap::{Parser, Subcommand};
-use std::path::PathBuf;
-
-use optimization::{plan_basic_cleanup, RulesConfig, OptimizationEngine};
-
-#[derive(Parser)]
-#[command(name = "packagepurge-core", version)]
-struct Cli {
-    #[command(subcommand)]
-    command: Commands,
-}
-
-#[derive(Subcommand)]
-enum Commands {
-    /// Scan filesystem and output dependency/caches JSON
-    Scan { #[arg(short, long)] paths: Vec<PathBuf> },
-    /// Produce cleanup plan without mutating filesystem
-    DryRun { #[arg(short, long, default_value_t = 90)] preserve_days: i64, #[arg(short, long)] paths: Vec<PathBuf> },
-    /// Move targets to quarantine (atomic move) based on paths provided
-    Quarantine { #[arg(required=true)] targets: Vec<PathBuf> },
-    /// Rollback by id or latest
-    Rollback {
-        #[arg(long)] id: Option<String>,
-        #[arg(long)] latest: bool,
-    },
-    /// Optimize with ML/LRU and symlinking (dry run)
-    Optimize {
-        #[arg(short, long, default_value_t = 90)] preserve_days: i64,
-        #[arg(short, long)] paths: Vec<PathBuf>,
-        #[arg(long)] enable_symlinking: bool,
-        #[arg(long)] enable_ml: bool,
-        #[arg(long, default_value_t = 1000)] lru_max_packages: usize,
-        #[arg(long, default_value_t = 10_000_000_000)] lru_max_size_bytes: u64,
-    },
-    /// Execute symlinking for duplicate packages
-    Symlink {
-        #[arg(short, long)] paths: Vec<PathBuf>,
-    },
-}
-
-fn main() -> Result<()> {
-    let cli = Cli::parse();
-    match cli.command {
-        Commands::Scan { paths } => {
-            let out = scanner::scan(&paths)?;
-            println!("{}", serde_json::to_string_pretty(&out)?);
-        }
-        Commands::DryRun { preserve_days, paths } => {
-            let scan = scanner::scan(&paths)?;
-            let report = plan_basic_cleanup(&scan, &RulesConfig {
-                preserve_days,
-                enable_symlinking: false,
-                enable_ml_prediction: false,
-                lru_max_packages: 1000,
-                lru_max_size_bytes: 10_000_000_000, // 10GB default
-            })?;
-            println!("{}", serde_json::to_string_pretty(&report)?);
-        }
-        Commands::Quarantine { targets } => {
-            let mut recs = Vec::new();
-            for t in targets {
-                match safety::move_to_quarantine(&t) {
-                    Ok(r) => recs.push(r),
-                    Err(e) => eprintln!("Failed to quarantine {:?}: {}", t, e),
-                }
-            }
-            println!("{}", serde_json::to_string_pretty(&recs)?);
-        }
-        Commands::Rollback { id, latest } => {
-            let rec = if let Some(i) = id { safety::find_quarantine_by_id(&i) } else if latest { safety::latest_quarantine() } else { None };
-            if let Some(r) = rec {
-                if let Err(e) = safety::rollback_record(&r) {
-                    eprintln!("{}", e);
-                    std::process::exit(1);
-                }
-                println!("{}", serde_json::to_string_pretty(&serde_json::json!({"status":"ok","id": r.id}))?);
-            } else {
-                eprintln!("No matching quarantine record found");
-                std::process::exit(2);
-            }
-        }
-        Commands::Optimize { preserve_days, paths, enable_symlinking, enable_ml, lru_max_packages, lru_max_size_bytes } => {
-            let scan = scanner::scan(&paths)?;
-            let config = RulesConfig {
-                preserve_days,
-                enable_symlinking,
-                enable_ml_prediction: enable_ml,
-                lru_max_packages,
-                lru_max_size_bytes,
-            };
-            let mut engine = OptimizationEngine::new(config)?;
-            let report = engine.plan_optimized_cleanup(&scan)?;
-            println!("{}", serde_json::to_string_pretty(&report)?);
-        }
-        Commands::Symlink { paths } => {
-            let scan = scanner::scan(&paths)?;
-            let config = RulesConfig {
-                preserve_days: 90,
-                enable_symlinking: true,
-                enable_ml_prediction: false,
-                lru_max_packages: 1000,
-                lru_max_size_bytes: 10_000_000_000,
-            };
-            let engine = OptimizationEngine::new(config)?;
-            let count = engine.execute_symlinking(&scan)?;
-            println!("{}", serde_json::to_string_pretty(&serde_json::json!({
-                "status": "ok",
-                "symlinked_count": count
-            }))?);
-        }
-    }
-    Ok(())
-}

package/core/src/ml.rs

@@ -1,188 +0,0 @@
-use chrono::Utc;
-use crate::types::{PackageUsageMetrics, ProjectMetadata, DeveloperBehavior};
-
-#[allow(dead_code)]
-pub trait MlRecommender {
-	fn is_safe_to_evict(&self, package_id: &str) -> Option<bool>;
-	fn should_keep(&self, package_id: &str, metrics: &PackageUsageMetrics, project: &ProjectMetadata, behavior: &DeveloperBehavior) -> bool;
-}
-
-#[allow(dead_code)]
-pub struct NoopRecommender;
-impl MlRecommender for NoopRecommender {
-	fn is_safe_to_evict(&self, _package_id: &str) -> Option<bool> { None }
-	fn should_keep(&self, _package_id: &str, _metrics: &PackageUsageMetrics, _project: &ProjectMetadata, _behavior: &DeveloperBehavior) -> bool {
-		true // Conservative: keep by default
-	}
-}
-
-/// Predictive Optimizer using rule-based ML (can be extended with actual ML models)
-#[allow(dead_code)]
-pub struct PredictiveOptimizer {
-	/// Keep threshold in days (packages used within this period are likely needed)
-	prediction_window_days: i64,
-}
-
-impl PredictiveOptimizer {
-	pub fn new(prediction_window_days: i64) -> Self {
-		Self { prediction_window_days }
-	}
-
-	/// Extract features from package metadata for ML prediction
-	fn extract_features(
-		&self,
-		metrics: &PackageUsageMetrics,
-		project: &ProjectMetadata,
-		behavior: &DeveloperBehavior,
-	) -> Vec<f64> {
-		let now = Utc::now();
-		
-		// Feature 1: Days since last access
-		let days_since_access = (now - metrics.last_access_time).num_days() as f64;
-		
-		// Feature 2: Days since last script execution
-		let days_since_script = metrics.last_script_execution
-			.map(|t| (now - t).num_days() as f64)
-			.unwrap_or(365.0); // High value if never executed
-		
-		// Feature 3: Days since last successful build
-		let days_since_build = metrics.last_successful_build
-			.map(|t| (now - t).num_days() as f64)
-			.unwrap_or(365.0);
-		
-		// Feature 4: Access frequency (normalized)
-		let access_frequency = metrics.access_count as f64 / 100.0; // Normalize
-		
-		// Feature 5: Script execution frequency
-		let script_frequency = metrics.script_execution_count as f64 / 10.0;
-		
-		// Feature 6: Project activity (days since last commit)
-		let days_since_commit = project.last_commit_date
-			.map(|t| (now - t).num_days() as f64)
-			.unwrap_or(365.0);
-		
-		// Feature 7: Project type score (higher for active project types)
-		let project_type_score = match project.project_type.as_str() {
-			"react" | "typescript" | "nextjs" => 1.0,
-			"node" => 0.8,
-			_ => 0.5,
-		};
-		
-		// Feature 8: Dependency count (more deps = more likely to need packages)
-		let dep_score = (project.dependency_count as f64 / 100.0).min(1.0);
-		
-		// Feature 9: Days since last build (from behavior)
-		let behavior_days_since_build = behavior.days_since_last_build
-			.map(|d| d as f64)
-			.unwrap_or(365.0);
-		
-		// Feature 10: File access frequency
-		let file_access_score = (behavior.file_access_frequency as f64 / 1000.0).min(1.0);
-		
-		vec![
-			days_since_access,
-			days_since_script,
-			days_since_build,
-			access_frequency,
-			script_frequency,
-			days_since_commit,
-			project_type_score,
-			dep_score,
-			behavior_days_since_build,
-			file_access_score,
-		]
-	}
-
-	/// Predict whether package should be kept (binary classification)
-	/// Returns true if package is likely needed in the next prediction_window_days
-	pub fn predict_keep(
-		&self,
-		metrics: &PackageUsageMetrics,
-		project: &ProjectMetadata,
-		behavior: &DeveloperBehavior,
-	) -> bool {
-		let features = self.extract_features(metrics, project, behavior);
-		
-		// Simple rule-based classifier (can be replaced with actual ML model)
-		// This implements a heuristic that mimics what a trained model would do
-		
-		// Rule 1: Recently accessed packages are likely needed
-		let days_since_access = features[0];
-		if days_since_access < 7.0 {
-			return true; // Keep if accessed in last week
-		}
-		
-		// Rule 2: Recently used in scripts
-		let days_since_script = features[1];
-		if days_since_script < 14.0 {
-			return true; // Keep if used in script in last 2 weeks
-		}
-		
-		// Rule 3: Recently built successfully
-		let days_since_build = features[2];
-		if days_since_build < 30.0 {
-			return true; // Keep if built in last month
-		}
-		
-		// Rule 4: High access frequency
-		let access_frequency = features[3];
-		if access_frequency > 0.5 {
-			return true; // Keep if frequently accessed
-		}
-		
-		// Rule 5: Active project with recent commits
-		let days_since_commit = features[5];
-		let project_type_score = features[6];
-		if days_since_commit < 30.0 && project_type_score > 0.7 {
-			return true; // Keep if project is active
-		}
-		
-		// Rule 6: Weighted score combining all features
-		// This is a simplified logistic regression-like decision
-		let score = self.compute_keep_score(&features);
-		score > 0.5
-	}
-
-	/// Compute a keep score (0.0 to 1.0) based on features
-	/// This mimics a logistic regression output
-	fn compute_keep_score(&self, features: &[f64]) -> f64 {
-		// Weighted combination of features (weights learned from training data in real ML)
-		// For now, use heuristic weights
-		let weights = vec![
-			-0.1,  // days_since_access (negative: more days = lower score)
-			-0.05, // days_since_script
-			-0.03, // days_since_build
-			0.3,   // access_frequency (positive: more access = higher score)
-			0.2,   // script_frequency
-			-0.02, // days_since_commit
-			0.15,  // project_type_score
-			0.1,   // dep_score
-			-0.03, // behavior_days_since_build
-			0.1,   // file_access_score
-		];
-		
-		let mut score = 0.5; // Base score
-		for (feature, weight) in features.iter().zip(weights.iter()) {
-			score += feature * weight;
-		}
-		
-		// Apply sigmoid-like function to bound between 0 and 1
-		1.0 / (1.0 + (-score).exp())
-	}
-}
-
-impl MlRecommender for PredictiveOptimizer {
-	fn is_safe_to_evict(&self, _package_id: &str) -> Option<bool> {
-		None // Use should_keep instead
-	}
-
-	fn should_keep(
-		&self,
-		_package_id: &str,
-		metrics: &PackageUsageMetrics,
-		project: &ProjectMetadata,
-		behavior: &DeveloperBehavior,
-	) -> bool {
-		self.predict_keep(metrics, project, behavior)
-	}
-}