packagepurge 1.0.0 → 1.0.1

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)
-	}
-}

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(())
-}