packagepurge 1.0.0

package/core/src/ml.rs

@@ -0,0 +1,188 @@
+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)
+	}
+}

package/core/src/optimization.rs

@@ -0,0 +1,314 @@
+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

@@ -0,0 +1,103 @@
+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(())
+}