packagepurge 1.0.0 → 1.0.1

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

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