myspace-cli 1.4.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

{myspace_cli-1.4.0.dist-info → myspace_cli-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myspace-cli
-Version: 1.4.0
+Version: 1.6.0
 Summary: A macOS disk space analysis CLI: health, index, app usage, big files.
 Author-email: Your Name <you@example.com>
 License: MIT
@@ -38,7 +38,6 @@ space-cli是一个开源的macOS命令行小工具，用于分析磁盘空间健
 - 🗑️ **一键删除应用** - 在应用分析列表中输入序号即可一键删除所选应用及其缓存（含二次确认）
 - 🏠 **用户目录深度分析** - 针对 `~/Library`、`~/Downloads`、`~/Documents` 分别下探并展示Top N目录
 - 🗄️ **大文件分析** - 扫描并列出指定路径下最大的文件，支持数量和最小体积阈值
-- 🔄 **返回上一级** - 在下探分析中支持选择0返回上一级目录
 - ⏱️ **支持MCP调用** - 支持你自己的AI Agent无缝调用磁盘空间信息
 
 ## 安装
@@ -62,6 +61,9 @@ python3 -m space_cli
 # 如果要使用高级的功能，请使用更复杂的命令行参数，可以运行help
 space-cli --help
 
+# 升级到最新的版本
+pip install --upgrade myspace-cli
+
 ```
 
 ### 方法2：直接使用

myspace_cli-1.6.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+space_cli/__init__.py,sha256=lWtTRBahXp0sPSpoN6V5Oviv6k5gXVlEkM4iw0l-dZY,232
+space_cli/index_store.py,sha256=E6THjLgTbH-mOLu8s619-dW8ikto6CyNcizhvVoX5lY,2967
+space_cli/space_analyzer.py,sha256=ax-faTP_4UNqTFDEzvkuN9hJ4T8KrJbvNpR1CEbKqk8,18737
+space_cli/space_cli.py,sha256=6IgUzPguU-MW4rG7z2VqreJEn4ReQh6usuHYkHNME7Y,26917
+myspace_cli-1.6.0.dist-info/METADATA,sha256=B4IZ05IhRUKLtH3L0IBc-0nsV6SyMZ2DCXYcVXjNIOk,12727
+myspace_cli-1.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+myspace_cli-1.6.0.dist-info/entry_points.txt,sha256=sIVEmPf6W8aNa7KiqOwAI6JrsgHlQciO5xH2G29tKPQ,45
+myspace_cli-1.6.0.dist-info/top_level.txt,sha256=lnUfbQX9h-9ZjecMVCOWucS2kx69FwTndlrb48S20Sc,10
+myspace_cli-1.6.0.dist-info/RECORD,,

space_cli/__init__.py

@@ -0,0 +1,10 @@
+"""
+SpaceCli - macOS 磁盘空间分析工具
+模块化版本
+"""
+
+from .index_store import IndexStore
+from .space_analyzer import SpaceAnalyzer
+from .space_cli import SpaceCli
+
+__all__ = ['IndexStore', 'SpaceAnalyzer', 'SpaceCli']

space_cli/index_store.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+IndexStore - 目录大小索引缓存管理器
+"""
+
+import os
+import json
+from pathlib import Path
+from typing import List, Tuple, Dict
+from datetime import datetime, timedelta
+
+
+class IndexStore:
+    """简单的目录大小索引缓存管理器"""
+
+    def __init__(self, index_file: str = None):
+        home = str(Path.home())
+        cache_dir = os.path.join(home, ".spacecli")
+        os.makedirs(cache_dir, exist_ok=True)
+        self.index_file = index_file or os.path.join(cache_dir, "index.json")
+        self._data: Dict = {}
+        self._loaded = False
+
+    def load(self) -> None:
+        if self._loaded:
+            return
+        if os.path.exists(self.index_file):
+            try:
+                with open(self.index_file, "r", encoding="utf-8") as f:
+                    self._data = json.load(f)
+            except Exception:
+                self._data = {}
+        self._loaded = True
+
+    def save(self) -> None:
+        try:
+            with open(self.index_file, "w", encoding="utf-8") as f:
+                json.dump(self._data, f, ensure_ascii=False, indent=2)
+        except Exception:
+            pass
+
+    def _key(self, root_path: str) -> str:
+        return os.path.abspath(root_path)
+
+    def get(self, root_path: str) -> Dict:
+        self.load()
+        return self._data.get(self._key(root_path))
+
+    def set(self, root_path: str, entries: List[Tuple[str, int]]) -> None:
+        self.load()
+        now_iso = datetime.utcnow().isoformat()
+        self._data[self._key(root_path)] = {
+            "updated_at": now_iso,
+            "entries": [{"path": p, "size": s} for p, s in entries],
+        }
+        self.save()
+
+    def is_fresh(self, root_path: str, ttl_hours: int) -> bool:
+        self.load()
+        rec = self._data.get(self._key(root_path))
+        if not rec:
+            return False
+        try:
+            updated_at = datetime.fromisoformat(rec.get("updated_at"))
+            return datetime.utcnow() - updated_at <= timedelta(hours=ttl_hours)
+        except Exception:
+            return False
+
+    # 命名缓存（非路径键），适合应用分析等聚合结果
+    def get_named(self, name: str) -> Dict:
+        self.load()
+        return self._data.get(name)
+
+    def set_named(self, name: str, entries: List[Tuple[str, int]]) -> None:
+        self.load()
+        now_iso = datetime.utcnow().isoformat()
+        self._data[name] = {
+            "updated_at": now_iso,
+            "entries": [{"name": p, "size": s} for p, s in entries],
+        }
+        self.save()
+
+    def is_fresh_named(self, name: str, ttl_hours: int) -> bool:
+        self.load()
+        rec = self._data.get(name)
+        if not rec:
+            return False
+        try:
+            updated_at = datetime.fromisoformat(rec.get("updated_at"))
+            return datetime.utcnow() - updated_at <= timedelta(hours=ttl_hours)
+        except Exception:
+            return False

space_cli/space_analyzer.py

@@ -0,0 +1,419 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+SpaceAnalyzer - 磁盘空间分析器
+"""
+
+import os
+import sys
+import subprocess
+import heapq
+import time
+from pathlib import Path
+from typing import List, Tuple, Dict
+from .index_store import IndexStore
+
+
+class SpaceAnalyzer:
+    """磁盘空间分析器"""
+    
+    def __init__(self):
+        self.warning_threshold = 80  # 警告阈值百分比
+        self.critical_threshold = 90  # 严重阈值百分比
+        # 忽略的目录列表, 这些目录时系统目录，不需要分析
+        self.ignore_dir_list = [
+            "/System",  # 系统目录
+            "/Volumes", # 外部挂载卷
+            "/private", # 私有目录            
+            ".Trash", # 垃圾桶
+            ".localized", # 本地化目录
+        ]
+
+    
+    def get_disk_usage(self, path: str = "/") -> Dict:
+        """获取磁盘使用情况"""
+        try:
+            statvfs = os.statvfs(path)
+            
+            # 计算磁盘空间信息
+            total_bytes = statvfs.f_frsize * statvfs.f_blocks
+            free_bytes = statvfs.f_frsize * statvfs.f_bavail
+            used_bytes = total_bytes - free_bytes
+            
+            # 计算百分比
+            usage_percent = (used_bytes / total_bytes) * 100
+            
+            return {
+                'total': total_bytes,
+                'used': used_bytes,
+                'free': free_bytes,
+                'usage_percent': usage_percent,
+                'path': path
+            }
+        except Exception as e:
+            print(f"错误：无法获取磁盘使用情况 - {e}")
+            return None
+    
+    def get_disk_health_status(self, usage_info: Dict) -> Tuple[str, str]:
+        """评估磁盘健康状态"""
+        if not usage_info:
+            return "未知", "无法获取磁盘信息"
+        
+        usage_percent = usage_info['usage_percent']
+        
+        if usage_percent >= self.critical_threshold:
+            return "严重", "磁盘空间严重不足！请立即清理磁盘空间"
+        elif usage_percent >= self.warning_threshold:
+            return "警告", "磁盘空间不足，建议清理一些文件"
+        else:
+            return "良好", "磁盘空间充足"
+    
+    def format_bytes(self, bytes_value: int) -> str:
+        """格式化字节数为人类可读格式"""
+        for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+            if bytes_value < 1024.0:
+                return f"{bytes_value:.1f} {unit}"
+            bytes_value /= 1024.0
+        return f"{bytes_value:.1f} PB"
+    
+    def get_directory_size(self, path: str) -> int:
+        """高性能计算目录大小。
+
+        优先使用 macOS 的 du -sk（以 KiB 为单位，速度快，原生命令可处理边界情况），
+        若 du 调用失败则回退到基于 os.scandir 的非递归遍历实现（避免 os.walk 的函数调用开销）。
+        """
+        # 优先尝试 du -sk（BSD du 在 macOS 可用）。
+        try:
+            # du 输出形如: "<kib>\t<path>\n"
+            result = subprocess.run([
+                'du', '-sk', path
+            ], capture_output=True, text=True, check=True)
+            out = result.stdout.strip().split('\t', 1)[0].strip()
+            kib = int(out)
+            return kib * 1024
+        except Exception:
+            # du 不可用或失败时回退到 Python 实现
+            pass
+
+        total_size = 0
+        # 基于栈的迭代遍历，避免递归栈与 os.walk 的额外开销
+        stack = [path]
+        while stack:
+            current = stack.pop()
+            try:
+                with os.scandir(current) as it:
+                    for entry in it:
+                        # 跳过符号链接，避免循环与跨文件系统问题
+                        try:
+                            if entry.is_symlink():
+                                continue
+                            if entry.is_file(follow_symlinks=False):
+                                try:
+                                    total_size += entry.stat(follow_symlinks=False).st_size
+                                except (OSError, FileNotFoundError, PermissionError):
+                                    continue
+                            elif entry.is_dir(follow_symlinks=False):
+                                stack.append(entry.path)
+                        except (OSError, FileNotFoundError, PermissionError):
+                            continue
+            except (OSError, FileNotFoundError, PermissionError):
+                # 无法进入该目录则跳过
+                continue
+        return total_size
+
+    def analyze_largest_files(self, root_path: str = "/", top_n: int = 50,
+                               min_size_bytes: int = 0) -> List[Tuple[str, int]]:
+        """扫描并返回体积最大的文件列表"""
+        print("正在扫描大文件，这可能需要一些时间...")
+        heap: List[Tuple[int, str]] = []  # 最小堆 (size, path)
+        scanned = 0
+        try:
+            for dirpath, dirnames, filenames in os.walk(root_path):
+
+                # 过滤以ignore_dir_list中的目录开头的文件
+                if any(dirpath.startswith(dir) for dir in self.ignore_dir_list):
+                    continue
+
+                # 进度提示：单行覆盖当前目录
+                dirpath_display = dirpath[-80:] # 截取最后50个字符
+                if dirpath_display == "":
+                    dirpath_display = dirpath
+                sys.stdout.write(f"\r\033[K-> 正在读取: \033[36m{dirpath_display}\033[0m")
+                sys.stdout.flush()
+                for filename in filenames:
+                    filepath = os.path.join(dirpath, filename)
+                    try:
+                        size = os.path.getsize(filepath)
+                    except (OSError, FileNotFoundError, PermissionError):
+                        continue
+                    if size < min_size_bytes:
+                        continue
+                    if len(heap) < top_n:
+                        heapq.heappush(heap, (size, filepath))
+                    else:
+                        if size > heap[0][0]:
+                            heapq.heapreplace(heap, (size, filepath))
+                    scanned += 1
+                    if scanned % 500 == 0:
+                        dirpath_display = dirpath[-80:] # 截取最后50个字符
+                        if dirpath_display == "":
+                            dirpath_display = dirpath
+                        # 间隔性进度输出（单行覆盖）
+                        sys.stdout.write(f"\r\033[K-> 正在读取: \033[36m{dirpath_display}\033[0m    已扫描: \033[32m{scanned}\033[0m")
+                        sys.stdout.flush()
+        except KeyboardInterrupt:
+            print("\n用户中断扫描，返回当前结果...")
+        except Exception as e:
+            print(f"扫描时出错: {e}")
+        finally:
+            sys.stdout.write("\n")
+            sys.stdout.flush()
+        # 转换为按体积降序列表
+        result = sorted([(p, s) for s, p in heap], key=lambda x: x[1], reverse=False)
+        result.sort(key=lambda x: x[1])
+        result = sorted([(p, s) for s, p in heap], key=lambda x: x[1])
+        # 正确：按 size 降序
+        result = sorted([(p, s) for s, p in heap], key=lambda x: x[1], reverse=True)
+        # 以上为了避免编辑器误合并，最终以最后一行排序为准
+        return result
+    
+    def analyze_largest_directories(self, root_path: str = "/", max_depth: int = 2, top_n: int = 20,
+                                    index: IndexStore = None, use_index: bool = True,
+                                    reindex: bool = False, index_ttl_hours: int = 24,
+                                    prompt: bool = True) -> List[Tuple[str, int]]:
+        """分析占用空间最大的目录（支持索引缓存）"""
+        # 索引命中
+        if use_index and index and not reindex and index.is_fresh(root_path, index_ttl_hours):
+            cached = index.get(root_path)
+            if cached and cached.get("entries"):
+                if prompt and sys.stdin.isatty():
+                    try:
+                        ans = input("检测到最近索引，是否使用缓存结果而不重新索引？[Y/n]: ").strip().lower()
+                        if ans in ("", "y", "yes"):
+                            return [(e["path"], int(e["size"])) for e in cached["entries"]][:top_n]
+                    except EOFError:
+                        pass
+                else:
+                    return [(e["path"], int(e["size"])) for e in cached["entries"]][:top_n]
+
+        print("正在分析目录大小，这可能需要一些时间...")
+
+        
+        
+        directory_sizes = []
+        
+        try:
+            # 获取根目录下的直接子目录
+            for item in os.listdir(root_path):
+                item_path = os.path.join(root_path, item)
+                
+                # 跳过隐藏文件和系统文件
+                if item.startswith('.') and item not in ['.Trash', '.localized']:
+                    continue
+
+                if item_path in self.ignore_dir_list:
+                    continue
+                
+                if os.path.isdir(item_path):
+                    try:
+                        # 进度提示：当前正在读取的目录（单行覆盖）
+                        sys.stdout.write(f"\r\033[K-> 正在读取: \033[36m{item_path}\033[0m")
+                        sys.stdout.flush()
+                        size = self.get_directory_size(item_path)
+                        directory_sizes.append((item_path, size))
+                        #print(f"已分析: {item_path} ({self.format_bytes(size)})")
+                        print(f" ({self.format_bytes(size)})\033[0m")
+                    except (OSError, PermissionError):
+                        print(f"跳过无法访问的目录: {item_path}")
+                        continue
+            # 结束时换行，避免后续输出粘连在同一行
+            sys.stdout.write("\n")
+            sys.stdout.flush()
+            
+            # 按大小排序
+            directory_sizes.sort(key=lambda x: x[1], reverse=True)
+            # 写入索引
+            if index:
+                try:
+                    index.set(root_path, directory_sizes)
+                except Exception:
+                    pass
+            return directory_sizes[:top_n]
+            
+        except Exception as e:
+            print(f"分析目录时出错: {e}")
+            return []
+    
+    def get_system_info(self) -> Dict:
+        """获取系统信息（包括 CPU、内存、GPU、硬盘等硬件信息）"""
+        system_info = {}
+        
+        try:
+            # 获取系统版本信息
+            result = subprocess.run(['sw_vers'], capture_output=True, text=True)
+            for line in result.stdout.split('\n'):
+                if ':' in line:
+                    key, value = line.split(':', 1)
+                    system_info[key.strip()] = value.strip()
+        except Exception:
+            system_info["ProductName"] = "macOS"
+            system_info["ProductVersion"] = "未知"
+        
+        try:
+            # 获取 CPU 信息
+            cpu_result = subprocess.run(['sysctl', '-n', 'machdep.cpu.brand_string'], 
+                                     capture_output=True, text=True)
+            if cpu_result.returncode == 0:
+                system_info["CPU"] = cpu_result.stdout.strip()
+            
+            # 获取 CPU 核心数
+            cores_result = subprocess.run(['sysctl', '-n', 'hw.ncpu'], 
+                                        capture_output=True, text=True)
+            if cores_result.returncode == 0:
+                system_info["CPU核心数"] = cores_result.stdout.strip()
+                
+        except Exception:
+            system_info["CPU"] = "未知"
+            system_info["CPU核心数"] = "未知"
+        
+        try:
+            # 获取内存信息
+            mem_result = subprocess.run(['sysctl', '-n', 'hw.memsize'], 
+                                     capture_output=True, text=True)
+            if mem_result.returncode == 0:
+                mem_bytes = int(mem_result.stdout.strip())
+                system_info["内存"] = self.format_bytes(mem_bytes)
+            # 计算内存使用率（基于 vm_stat 与页面大小）
+            try:
+                pagesize_res = subprocess.run(['sysctl', '-n', 'hw.pagesize'], capture_output=True, text=True)
+                pagesize = int(pagesize_res.stdout.strip()) if pagesize_res.returncode == 0 else 4096
+                vm_res = subprocess.run(['vm_stat'], capture_output=True, text=True)
+                if vm_res.returncode == 0:
+                    import re
+                    page_counts = {}
+                    for line in vm_res.stdout.splitlines():
+                        if ':' not in line:
+                            continue
+                        key, val = line.split(':', 1)
+                        m = re.search(r"(\d+)", val.replace('.', ''))
+                        if not m:
+                            continue
+                        count = int(m.group(1))
+                        page_counts[key.strip()] = count
+
+                    free_pages = page_counts.get('Pages free', 0) + page_counts.get('Pages speculative', 0)
+                    active_pages = page_counts.get('Pages active', 0)
+                    inactive_pages = page_counts.get('Pages inactive', 0)
+                    wired_pages = page_counts.get('Pages wired down', 0) or page_counts.get('Pages wired', 0)
+                    compressed_pages = page_counts.get('Pages occupied by compressor', 0)
+
+                    used_pages = active_pages + inactive_pages + wired_pages + compressed_pages
+                    total_pages = used_pages + free_pages
+                    if total_pages > 0:
+                        usage_percent = (used_pages / total_pages) * 100.0
+                        system_info["内存使用率"] = f"{usage_percent:.1f}%"
+            except Exception:
+                # 安静失败，不影响主流程
+                print("计算内存使用率失败")
+                pass
+        except Exception:
+            system_info["内存"] = "未知"
+                
+        
+        try:
+            # 获取启动时间
+            boot_result = subprocess.run(['uptime'], capture_output=True, text=True)
+            if boot_result.returncode == 0:
+                uptime_line = boot_result.stdout.strip()
+                system_info["运行时间"] = uptime_line
+        except Exception:
+            system_info["运行时间"] = "未知"
+        
+        # 添加 space-cli 版本信息
+        try:
+            # 简单解析 pyproject.toml 文件中的版本号
+            with open('pyproject.toml', 'r', encoding='utf-8') as f:
+                content = f.read()
+                # 查找 version = "x.x.x" 行
+                import re
+                version_match = re.search(r'version\s*=\s*["\']([^"\']+)["\']', content)
+                if version_match:
+                    system_info['SpaceCli Version'] = version_match.group(1)
+                else:
+                    system_info['SpaceCli Version'] = '未知'
+        except Exception:
+            system_info['SpaceCli Version'] = '未知'
+        
+        return system_info
+    
+    def memory_cleanup(self) -> Dict:
+        """执行内存释放优化"""
+        cleanup_results = {
+            "purged_memory": 0,
+            "cleared_caches": [],
+            "freed_swap": 0,
+            "errors": []
+        }
+        
+        try:
+            
+            # 2. 强制垃圾回收
+            print("🔄 正在执行垃圾回收...")
+            import gc
+            collected = gc.collect()
+            cleanup_results["purged_memory"] += collected
+            
+            # 3. 清理 Python 缓存
+            print("🗑️ 正在清理 Python 缓存...")
+            try:
+                # 清理 __pycache__ 目录
+                import shutil
+                for root, dirs, files in os.walk('/tmp'):
+                    for dir_name in dirs:
+                        if dir_name == '__pycache__':
+                            cache_path = os.path.join(root, dir_name)
+                            try:
+                                shutil.rmtree(cache_path)
+                                cleanup_results["cleared_caches"].append(f"Python缓存: {cache_path}")
+                            except Exception:
+                                pass
+            except Exception as e:
+                cleanup_results["errors"].append(f"Python缓存清理失败: {e}")
+            
+            # 4. 清理临时文件
+            print("📁 正在清理临时文件...")
+            temp_dirs = ['/tmp', '/var/tmp']
+            for temp_dir in temp_dirs:
+                if os.path.exists(temp_dir):
+                    try:
+                        for item in os.listdir(temp_dir):
+                            item_path = os.path.join(temp_dir, item)
+                            # 只清理超过1小时的文件
+                            if os.path.isfile(item_path):
+                                file_age = time.time() - os.path.getmtime(item_path)
+                                if file_age > 3600:  # 1小时
+                                    try:
+                                        os.remove(item_path)
+                                        cleanup_results["cleared_caches"].append(f"临时文件: {item_path}")
+                                    except Exception:
+                                        pass
+                    except Exception as e:
+                        cleanup_results["errors"].append(f"临时文件清理失败: {e}")
+            
+            # 5. 尝试释放交换空间（需要管理员权限）
+            print("💾 正在尝试释放交换空间...（需要登录密码授权此操作，此操作不会保存密码）")
+            try:
+                # 检查交换使用情况
+                swap_result = subprocess.run(['sysctl', 'vm.swapusage'], 
+                                           capture_output=True, text=True)
+                if swap_result.returncode == 0:
+                    # 尝试释放未使用的交换空间
+                    subprocess.run(['sudo', 'purge'], capture_output=True, text=True)
+                    cleanup_results["freed_swap"] = 1
+            except Exception as e:
+                cleanup_results["errors"].append(f"交换空间释放失败: {e}")
+            
+        except Exception as e:
+            cleanup_results["errors"].append(f"内存清理过程出错: {e}")
+        
+        return cleanup_results

space_cli.py → space_cli/space_cli.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
 SpaceCli - Mac OS 磁盘空间分析工具
@@ -17,364 +16,9 @@ import time
 from datetime import datetime, timedelta
 import heapq
 
+from .space_analyzer import SpaceAnalyzer
+from .index_store import IndexStore
 
-class IndexStore:
-    """简单的目录大小索引缓存管理器"""
-
-    def __init__(self, index_file: str = None):
-        home = str(Path.home())
-        cache_dir = os.path.join(home, ".spacecli")
-        os.makedirs(cache_dir, exist_ok=True)
-        self.index_file = index_file or os.path.join(cache_dir, "index.json")
-        self._data: Dict = {}
-        self._loaded = False
-
-    def load(self) -> None:
-        if self._loaded:
-            return
-        if os.path.exists(self.index_file):
-            try:
-                with open(self.index_file, "r", encoding="utf-8") as f:
-                    self._data = json.load(f)
-            except Exception:
-                self._data = {}
-        self._loaded = True
-
-    def save(self) -> None:
-        try:
-            with open(self.index_file, "w", encoding="utf-8") as f:
-                json.dump(self._data, f, ensure_ascii=False, indent=2)
-        except Exception:
-            pass
-
-    def _key(self, root_path: str) -> str:
-        return os.path.abspath(root_path)
-
-    def get(self, root_path: str) -> Dict:
-        self.load()
-        return self._data.get(self._key(root_path))
-
-    def set(self, root_path: str, entries: List[Tuple[str, int]]) -> None:
-        self.load()
-        now_iso = datetime.utcnow().isoformat()
-        self._data[self._key(root_path)] = {
-            "updated_at": now_iso,
-            "entries": [{"path": p, "size": s} for p, s in entries],
-        }
-        self.save()
-
-    def is_fresh(self, root_path: str, ttl_hours: int) -> bool:
-        self.load()
-        rec = self._data.get(self._key(root_path))
-        if not rec:
-            return False
-        try:
-            updated_at = datetime.fromisoformat(rec.get("updated_at"))
-            return datetime.utcnow() - updated_at <= timedelta(hours=ttl_hours)
-        except Exception:
-            return False
-
-    # 命名缓存（非路径键），适合应用分析等聚合结果
-    def get_named(self, name: str) -> Dict:
-        self.load()
-        return self._data.get(name)
-
-    def set_named(self, name: str, entries: List[Tuple[str, int]]) -> None:
-        self.load()
-        now_iso = datetime.utcnow().isoformat()
-        self._data[name] = {
-            "updated_at": now_iso,
-            "entries": [{"name": p, "size": s} for p, s in entries],
-        }
-        self.save()
-
-    def is_fresh_named(self, name: str, ttl_hours: int) -> bool:
-        self.load()
-        rec = self._data.get(name)
-        if not rec:
-            return False
-        try:
-            updated_at = datetime.fromisoformat(rec.get("updated_at"))
-            return datetime.utcnow() - updated_at <= timedelta(hours=ttl_hours)
-        except Exception:
-            return False
-
-
-class SpaceAnalyzer:
-    """磁盘空间分析器"""
-    
-    def __init__(self):
-        self.warning_threshold = 80  # 警告阈值百分比
-        self.critical_threshold = 90  # 严重阈值百分比
-    
-    def get_disk_usage(self, path: str = "/") -> Dict:
-        """获取磁盘使用情况"""
-        try:
-            statvfs = os.statvfs(path)
-            
-            # 计算磁盘空间信息
-            total_bytes = statvfs.f_frsize * statvfs.f_blocks
-            free_bytes = statvfs.f_frsize * statvfs.f_bavail
-            used_bytes = total_bytes - free_bytes
-            
-            # 计算百分比
-            usage_percent = (used_bytes / total_bytes) * 100
-            
-            return {
-                'total': total_bytes,
-                'used': used_bytes,
-                'free': free_bytes,
-                'usage_percent': usage_percent,
-                'path': path
-            }
-        except Exception as e:
-            print(f"错误：无法获取磁盘使用情况 - {e}")
-            return None
-    
-    def get_disk_health_status(self, usage_info: Dict) -> Tuple[str, str]:
-        """评估磁盘健康状态"""
-        if not usage_info:
-            return "未知", "无法获取磁盘信息"
-        
-        usage_percent = usage_info['usage_percent']
-        
-        if usage_percent >= self.critical_threshold:
-            return "严重", "磁盘空间严重不足！请立即清理磁盘空间"
-        elif usage_percent >= self.warning_threshold:
-            return "警告", "磁盘空间不足，建议清理一些文件"
-        else:
-            return "良好", "磁盘空间充足"
-    
-    def format_bytes(self, bytes_value: int) -> str:
-        """格式化字节数为人类可读格式"""
-        for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
-            if bytes_value < 1024.0:
-                return f"{bytes_value:.1f} {unit}"
-            bytes_value /= 1024.0
-        return f"{bytes_value:.1f} PB"
-    
-    def get_directory_size(self, path: str) -> int:
-        """高性能计算目录大小。
-
-        优先使用 macOS 的 du -sk（以 KiB 为单位，速度快，原生命令可处理边界情况），
-        若 du 调用失败则回退到基于 os.scandir 的非递归遍历实现（避免 os.walk 的函数调用开销）。
-        """
-        # 优先尝试 du -sk（BSD du 在 macOS 可用）。
-        try:
-            # du 输出形如: "<kib>\t<path>\n"
-            result = subprocess.run([
-                'du', '-sk', path
-            ], capture_output=True, text=True, check=True)
-            out = result.stdout.strip().split('\t', 1)[0].strip()
-            kib = int(out)
-            return kib * 1024
-        except Exception:
-            # du 不可用或失败时回退到 Python 实现
-            pass
-
-        total_size = 0
-        # 基于栈的迭代遍历，避免递归栈与 os.walk 的额外开销
-        stack = [path]
-        while stack:
-            current = stack.pop()
-            try:
-                with os.scandir(current) as it:
-                    for entry in it:
-                        # 跳过符号链接，避免循环与跨文件系统问题
-                        try:
-                            if entry.is_symlink():
-                                continue
-                            if entry.is_file(follow_symlinks=False):
-                                try:
-                                    total_size += entry.stat(follow_symlinks=False).st_size
-                                except (OSError, FileNotFoundError, PermissionError):
-                                    continue
-                            elif entry.is_dir(follow_symlinks=False):
-                                stack.append(entry.path)
-                        except (OSError, FileNotFoundError, PermissionError):
-                            continue
-            except (OSError, FileNotFoundError, PermissionError):
-                # 无法进入该目录则跳过
-                continue
-        return total_size
-
-    def analyze_largest_files(self, root_path: str = "/", top_n: int = 50,
-                               min_size_bytes: int = 0) -> List[Tuple[str, int]]:
-        """扫描并返回体积最大的文件列表"""
-        print("正在扫描大文件，这可能需要一些时间...")
-        heap: List[Tuple[int, str]] = []  # 最小堆 (size, path)
-        scanned = 0
-        try:
-            for dirpath, dirnames, filenames in os.walk(root_path):
-                # 进度提示：单行覆盖当前目录
-                dirpath_display = dirpath[-80:] # 截取最后50个字符
-                if dirpath_display == "":
-                    dirpath_display = dirpath
-                sys.stdout.write(f"\r\033[K-> 正在读取: \033[36m{dirpath_display}\033[0m")
-                sys.stdout.flush()
-                for filename in filenames:
-                    filepath = os.path.join(dirpath, filename)
-                    try:
-                        size = os.path.getsize(filepath)
-                    except (OSError, FileNotFoundError, PermissionError):
-                        continue
-                    if size < min_size_bytes:
-                        continue
-                    if len(heap) < top_n:
-                        heapq.heappush(heap, (size, filepath))
-                    else:
-                        if size > heap[0][0]:
-                            heapq.heapreplace(heap, (size, filepath))
-                    scanned += 1
-                    if scanned % 500 == 0:
-                        dirpath_display = dirpath[-80:] # 截取最后50个字符
-                        if dirpath_display == "":
-                            dirpath_display = dirpath
-                        # 间隔性进度输出（单行覆盖）
-                        sys.stdout.write(f"\r\033[K-> 正在读取: \033[36m{dirpath_display}\033[0m    已扫描文件数: \033[32m{scanned}\033[0m")
-                        sys.stdout.flush()
-        except KeyboardInterrupt:
-            print("\n用户中断扫描，返回当前结果...")
-        except Exception as e:
-            print(f"扫描时出错: {e}")
-        finally:
-            sys.stdout.write("\n")
-            sys.stdout.flush()
-        # 转换为按体积降序列表
-        result = sorted([(p, s) for s, p in heap], key=lambda x: x[1], reverse=False)
-        result.sort(key=lambda x: x[1])
-        result = sorted([(p, s) for s, p in heap], key=lambda x: x[1])
-        # 正确：按 size 降序
-        result = sorted([(p, s) for s, p in heap], key=lambda x: x[1], reverse=True)
-        # 以上为了避免编辑器误合并，最终以最后一行排序为准
-        return result
-    
-    def analyze_largest_directories(self, root_path: str = "/", max_depth: int = 2, top_n: int = 20,
-                                    index: IndexStore = None, use_index: bool = True,
-                                    reindex: bool = False, index_ttl_hours: int = 24,
-                                    prompt: bool = True) -> List[Tuple[str, int]]:
-        """分析占用空间最大的目录（支持索引缓存）"""
-        # 索引命中
-        if use_index and index and not reindex and index.is_fresh(root_path, index_ttl_hours):
-            cached = index.get(root_path)
-            if cached and cached.get("entries"):
-                if prompt and sys.stdin.isatty():
-                    try:
-                        ans = input("检测到最近索引，是否使用缓存结果而不重新索引？[Y/n]: ").strip().lower()
-                        if ans in ("", "y", "yes"):
-                            return [(e["path"], int(e["size"])) for e in cached["entries"]][:top_n]
-                    except EOFError:
-                        pass
-                else:
-                    return [(e["path"], int(e["size"])) for e in cached["entries"]][:top_n]
-
-        print("正在分析目录大小，这可能需要一些时间...")
-
-        # 忽略的目录列表, 这些目录时系统目录，不需要分析
-        ignore_dir_list = [
-            "/System",  # 系统目录
-            "/Volumes", # 外部挂载卷
-            "/private", # 私有目录
-        ]
-
-        
-        directory_sizes = []
-        
-        try:
-            # 获取根目录下的直接子目录
-            for item in os.listdir(root_path):
-                item_path = os.path.join(root_path, item)
-                
-                # 跳过隐藏文件和系统文件
-                if item.startswith('.') and item not in ['.Trash', '.localized']:
-                    continue
-
-                if item_path in ignore_dir_list:
-                    continue
-                
-                if os.path.isdir(item_path):
-                    try:
-                        # 进度提示：当前正在读取的目录（单行覆盖）
-                        sys.stdout.write(f"\r\033[K-> 正在读取: \033[36m{item_path}\033[0m")
-                        sys.stdout.flush()
-                        size = self.get_directory_size(item_path)
-                        directory_sizes.append((item_path, size))
-                        #print(f"已分析: {item_path} ({self.format_bytes(size)})")
-                        print(f" ({self.format_bytes(size)})\033[0m")
-                    except (OSError, PermissionError):
-                        print(f"跳过无法访问的目录: {item_path}")
-                        continue
-            # 结束时换行，避免后续输出粘连在同一行
-            sys.stdout.write("\n")
-            sys.stdout.flush()
-            
-            # 按大小排序
-            directory_sizes.sort(key=lambda x: x[1], reverse=True)
-            # 写入索引
-            if index:
-                try:
-                    index.set(root_path, directory_sizes)
-                except Exception:
-                    pass
-            return directory_sizes[:top_n]
-            
-        except Exception as e:
-            print(f"分析目录时出错: {e}")
-            return []
-    
-    def get_system_info(self) -> Dict:
-        """获取系统信息（包括 CPU、内存、GPU、硬盘等硬件信息）"""
-        system_info = {}
-        
-        try:
-            # 获取系统版本信息
-            result = subprocess.run(['sw_vers'], capture_output=True, text=True)
-            for line in result.stdout.split('\n'):
-                if ':' in line:
-                    key, value = line.split(':', 1)
-                    system_info[key.strip()] = value.strip()
-        except Exception:
-            system_info["ProductName"] = "macOS"
-            system_info["ProductVersion"] = "未知"
-        
-        try:
-            # 获取 CPU 信息
-            cpu_result = subprocess.run(['sysctl', '-n', 'machdep.cpu.brand_string'], 
-                                     capture_output=True, text=True)
-            if cpu_result.returncode == 0:
-                system_info["CPU"] = cpu_result.stdout.strip()
-            
-            # 获取 CPU 核心数
-            cores_result = subprocess.run(['sysctl', '-n', 'hw.ncpu'], 
-                                        capture_output=True, text=True)
-            if cores_result.returncode == 0:
-                system_info["CPU核心数"] = cores_result.stdout.strip()
-                
-        except Exception:
-            system_info["CPU"] = "未知"
-            system_info["CPU核心数"] = "未知"
-        
-        try:
-            # 获取内存信息
-            mem_result = subprocess.run(['sysctl', '-n', 'hw.memsize'], 
-                                     capture_output=True, text=True)
-            if mem_result.returncode == 0:
-                mem_bytes = int(mem_result.stdout.strip())
-                system_info["内存"] = self.format_bytes(mem_bytes)
-        except Exception:
-            system_info["内存"] = "未知"
-                
-        
-        try:
-            # 获取启动时间
-            boot_result = subprocess.run(['uptime'], capture_output=True, text=True)
-            if boot_result.returncode == 0:
-                uptime_line = boot_result.stdout.strip()
-                system_info["运行时间"] = uptime_line
-        except Exception:
-            system_info["运行时间"] = "未知"
-        
-        return system_info
 
 
 class SpaceCli:
@@ -388,6 +32,13 @@ class SpaceCli:
         app_cache_dir = os.path.join(home, ".cache", "spacecli")
         os.makedirs(app_cache_dir, exist_ok=True)
         self.app_index = IndexStore(index_file=os.path.join(app_cache_dir, "apps.json"))
+        self.ignore_dir_list = [
+            "/System", # 系统目录
+            "/Volumes", # 外部挂载卷
+            "/private", # 私有目录            
+            ".Trash", # 垃圾桶
+            ".localized", # 本地化目录
+        ]
 
     # —— 应用删除相关 ——
     def _candidate_app_paths(self, app_name: str) -> List[str]:
@@ -880,6 +531,7 @@ class SpaceCli:
         total = self.analyzer.get_disk_usage("/")
         disk_total = total['total'] if total else 1
         for i, (file_path, size) in enumerate(files, 1):
+
             size_str = self.analyzer.format_bytes(size)
             pct = (size / disk_total) * 100
             color = "\033[31m" if size >= 5 * 1024**3 else ("\033[33m" if size >= 1024**3 else "\033[32m")
@@ -898,6 +550,33 @@ class SpaceCli:
             print(f"{key}: \033[36m{value}\033[0m")
         print()
     
+    def print_memory_cleanup(self):
+        """打印内存释放优化结果"""
+        print("=" * 60)
+        print("🧹 内存释放优化")
+        print("=" * 60)
+        
+        cleanup_results = self.analyzer.memory_cleanup()
+        
+        print(f"✅ 垃圾回收释放对象: {cleanup_results['purged_memory']} 个")
+        print(f"✅ 交换空间释放: {'成功' if cleanup_results['freed_swap'] else '跳过'}")
+        
+        if cleanup_results['cleared_caches']:
+            print("\n📋 已清理的缓存:")
+            for cache in cleanup_results['cleared_caches']:
+                print(f"  - {cache}")
+        
+        if cleanup_results['errors']:
+            print("\n⚠️ 清理过程中的警告:")
+            for error in cleanup_results['errors']:
+                print(f"  - {error}")
+        
+        print("\n💡 提示:")
+        print("  - 某些操作需要管理员权限，如遇权限错误属正常现象")
+        print("  - 建议定期执行内存清理以保持系统性能")
+        print("  - 重启系统可获得最佳内存释放效果")
+        print()
+    
     def export_report(self, output_file: str, path: str = "/"):
         """导出分析报告到JSON文件"""
         print(f"正在生成报告并保存到: {output_file}")
@@ -950,255 +629,4 @@ class SpaceCli:
                 json.dump(report, f, ensure_ascii=False, indent=2)
             print(f"✅ 报告已保存到: {output_file}")
         except Exception as e:
-            print(f"❌ 保存报告失败: {e}")
-
-
-def main():
-    """主函数"""
-    parser = argparse.ArgumentParser(
-        description="SpaceCli - Mac OS 磁盘空间分析工具",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-示例用法:
-  python space_cli.py                    # 分析根目录
-  python space_cli.py -p /Users          # 分析用户目录
-  python space_cli.py -n 10              # 显示前10个最大目录
-  python space_cli.py --export report.json  # 导出报告
-  python space_cli.py --health-only      # 只显示健康状态
-        """
-    )
-    
-    parser.add_argument(
-        '-p', '--path',
-        default='/',
-        help='要分析的路径 (默认: /)'
-    )
-
-    # 快捷：分析当前用户目录
-    parser.add_argument(
-        '--home',
-        action='store_true',
-        help='将分析路径设置为当前用户目录（$HOME）'
-    )
-    
-    parser.add_argument(
-        '-n', '--top-n',
-        type=int,
-        default=20,
-        help='显示前N个最大的目录 (默认: 20)'
-    )
-    
-    parser.add_argument(
-        '--health-only',
-        action='store_true',
-        help='只显示磁盘健康状态'
-    )
-    
-    parser.add_argument(
-        '--directories-only',
-        action='store_true',
-        help='只显示目录分析'
-    )
-
-    # 索引相关
-    parser.add_argument(
-        '--use-index',
-        dest='use_index',
-        action='store_true',
-        help='使用已存在的索引缓存（若存在）'
-    )
-    parser.add_argument(
-        '--no-index',
-        dest='use_index',
-        action='store_false',
-        help='不使用索引缓存'
-    )
-    parser.set_defaults(use_index=True)
-    parser.add_argument(
-        '--reindex',
-        action='store_true',
-        help='强制重建索引'
-    )
-    parser.add_argument(
-        '--index-ttl',
-        type=int,
-        default=24,
-        help='索引缓存有效期（小时），默认24小时'
-    )
-    parser.add_argument(
-        '--no-prompt',
-        action='store_true',
-        help='非交互模式：不提示是否使用缓存'
-    )
-
-    # 应用分析
-    parser.add_argument(
-        '--apps',
-        action='store_true',
-        help='显示应用目录空间分析与卸载建议'
-    )
-
-    # 大文件分析
-    parser.add_argument(
-        '--big-files',
-        action='store_true',
-        help='显示大文件分析结果'
-    )
-    parser.add_argument(
-        '--big-files-top',
-        type=int,
-        default=20,
-        help='大文件分析显示前N个（默认20）'
-    )
-    parser.add_argument(
-        '--big-files-min',
-        type=str,
-        default='0',
-        help='只显示大于该阈值的文件，支持K/M/G/T，如 500M、2G，默认0'
-    )
-    
-    parser.add_argument(
-        '--export',
-        metavar='FILE',
-        help='导出分析报告到JSON文件'
-    )
-    
-    parser.add_argument(
-        '--version',
-        action='version',
-        version='SpaceCli 1.0.0'
-    )
-    
-    args = parser.parse_args()
-
-    # 解析 --big-files-min 阈值字符串到字节
-    def parse_size(s: str) -> int:
-        s = (s or '0').strip().upper()
-        if s.endswith('K'):
-            return int(float(s[:-1]) * 1024)
-        if s.endswith('M'):
-            return int(float(s[:-1]) * 1024**2)
-        if s.endswith('G'):
-            return int(float(s[:-1]) * 1024**3)
-        if s.endswith('T'):
-            return int(float(s[:-1]) * 1024**4)
-        try:
-            return int(float(s))
-        except ValueError:
-            return 0
-    args.big_files_min_bytes = parse_size(getattr(args, 'big_files_min', '0'))
-    
-    # 交互式菜单：当未传入任何参数时触发（默认执行全部分析）
-    if len(sys.argv) == 1:
-        print("=" * 60)
-        print("🧭 SpaceCli 菜单（直接回车 = 执行全部项目）")
-        print("=" * 60)
-        home_path = str(Path.home())
-        print("1) \033[36m执行主要项目（系统信息 + 健康 +  应用）\033[0m")
-        print(f"2) \033[36m当前用户目录分析（路径: {home_path}）\033[0m")
-        print("3) \033[36m仅显示系统信息\033[0m")
-        print("4) \033[36m仅显示磁盘健康状态\033[0m")
-        print("5) \033[36m交互式目录空间分析\033[0m")
-        print("6) \033[36m仅分析程序应用目录空间\033[0m")
-        print("7) \033[36m仅进行大文件分析（很耗时，可随时终止）\033[0m")
-        print("0) \033[36m退出\033[0m")
-        try:
-            choice = input("请选择 [回车=1]: ").strip()
-        except EOFError:
-            choice = ""
-
-        if choice == "0": # 退出
-            sys.exit(0)
-        elif choice == "2": # 仅显示当前用户目录分析
-            args.path = home_path
-            args.apps = False
-            args.health_only = False
-            args.directories_only = False
-        elif choice == "3": # 仅显示系统信息
-            args.health_only = False
-            args.directories_only = False
-            args.apps = False
-            args.big_files = False
-        elif choice == "4": # 仅显示磁盘健康状态 
-            args.health_only = True
-            args.directories_only = False
-            args.apps = False
-            args.big_files = False
-        elif choice == "5": # 仅显示最大目录列表
-            args.health_only = False
-            args.directories_only = True
-            args.apps = False
-            args.big_files = False
-        elif choice == "6": # 仅显示应用目录分析与建议
-            args.health_only = False
-            args.directories_only = False
-            args.apps = True
-            args.big_files = False
-        elif choice == "7": # 仅显示大文件分析
-            args.health_only = False
-            args.directories_only = False
-            args.apps = False
-            args.big_files = True
-        else: # 默认执行全部（用户不选择，或者选择1）            
-            args.health_only = True
-            args.directories_only = False
-            args.big_files = False
-            args.apps = True            
-
-
-    # --home 优先设置路径
-    if getattr(args, 'home', False):
-        args.path = str(Path.home())
-
-    # 检查路径是否存在
-    if not os.path.exists(args.path):
-        print(f"❌ 错误: 路径 '{args.path}' 不存在")
-        sys.exit(1)
-    
-    # 创建SpaceCli实例
-    space_cli = SpaceCli()
-    # 让 SpaceCli 实例可访问参数（用于索引与提示控制）
-    space_cli.args = args
-    
-    try:
-        # 显示系统信息
-        space_cli.print_system_info()
-        
-        # 显示磁盘健康状态
-        if args.health_only:
-            space_cli.print_disk_health(args.path)
-        
-        # 显示目录分析
-        if args.directories_only or args.path !='/':
-            space_cli.print_largest_directories(args.path, args.top_n)
-            # 若分析路径为当前用户目录，做深度分析
-            if os.path.abspath(args.path) == os.path.abspath(str(Path.home())):
-                space_cli.print_home_deep_analysis(args.top_n)
-
-        # 应用目录分析
-        if args.apps:
-            space_cli.print_app_analysis(args.top_n)
-
-        # 大文件分析
-        #if getattr(args, 'big_files', False):
-        if args.big_files:
-            space_cli.print_big_files(args.path, top_n=args.big_files_top, min_size_bytes=args.big_files_min_bytes)
-        
-        # 导出报告
-        if args.export:
-            space_cli.export_report(args.export, args.path)
-        
-        print("=" * 60)
-        print("✅ 分析完成！")
-        print("=" * 60)
-        
-    except KeyboardInterrupt:
-        print("\n\n❌ 用户中断操作")
-        sys.exit(1)
-    except Exception as e:
-        print(f"\n❌ 发生错误: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
+            print(f"❌ 保存报告失败: {e}")

myspace_cli-1.4.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-space_cli.py,sha256=qEEhU_3nuiG--fWGbUDdQytrL9mL1CZTKGTMFpCyBNk,48380
-myspace_cli-1.4.0.dist-info/METADATA,sha256=DDp6iHPcaGr_nCmJg5GHqeVhfqY-2fpzuJQ-4izUlVg,12747
-myspace_cli-1.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-myspace_cli-1.4.0.dist-info/entry_points.txt,sha256=sIVEmPf6W8aNa7KiqOwAI6JrsgHlQciO5xH2G29tKPQ,45
-myspace_cli-1.4.0.dist-info/top_level.txt,sha256=lnUfbQX9h-9ZjecMVCOWucS2kx69FwTndlrb48S20Sc,10
-myspace_cli-1.4.0.dist-info/RECORD,,