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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: myspace-cli
-Version: 1.2.0
+Version: 1.4.0
 Summary: A macOS disk space analysis CLI: health, index, app usage, big files.
 Author-email: Your Name <you@example.com>
 License: MIT
@@ -17,31 +17,54 @@ Description-Content-Type: text/markdown
 Provides-Extra: mcp
 Requires-Dist: mcp<2,>=1; extra == "mcp"
 
-# space-cli - Mac OS 磁盘空间分析工具
+# space-cli - macOS 磁盘空间优化工具
 
 很多人的Mac电脑都会出现磁盘空间不够用，付费软件太贵或者难以使用。
 
-space-cli是一个开源的Mac OS命令行小工具，用于分析磁盘空间健康度并找出占用空间最大的目录。
+space-cli是一个开源的macOS命令行小工具，用于分析磁盘空间健康度并找出占用空间大的目录，可选择针对单个应用进行一键清理。
 
-本软件采用**最严安全原则**，所有操作采用只读模式，不会尝试改写和破坏用户电脑的任何数据，也不会上传任何数据到外网，严格保护用户的隐私。
+本软件采用**最严安全原则**，所有分析操作采用只读模式，未经允许不会尝试改写和破坏用户电脑的任何数据，也不会上传任何数据到外网，严格保护用户的隐私。
 
 ## 功能特性
 
 - 🔍 **磁盘健康度检测** - 评估磁盘空间使用情况，提供健康状态建议
-- 📊 **目录大小分析** - 递归分析目录大小，找出占用空间最大的文件夹
-- 💻 **系统信息显示** - 显示Mac系统版本和基本信息
+- 📊 **交互式目录分析** - 递归分析目录大小，支持选择序号进行深度下探分析
+- 💻 **详细系统信息** - 显示CPU、内存、GPU、硬盘等完整硬件信息
 - 📄 **报告导出** - 将分析结果导出为JSON格式报告
-- ⚡ **高性能** - 优化的算法，快速分析大型文件系统
+- ⚡ **高性能优化** - 优先使用 `du -sk` 命令，失败时回退到 `os.scandir` 高效遍历
 - 🎯 **灵活配置** - 支持自定义分析路径和显示数量
-- 🗂️ **索引缓存** - 目录大小结果本地索引缓存（`~/.spacecli/index.json`），支持TTL与重建提示
+- 🗂️ **智能索引缓存** - 目录大小结果本地索引缓存（`~/.spacecli/index.json`），支持TTL与重建提示
 - 🧩 **应用分析** - 汇总 `Applications`、`Library`、`Caches`、`Logs` 等路径估算应用占用，给出卸载建议
- - 🏠 **用户目录深度分析** - 针对 `~/Library`、`~/Downloads`、`~/Documents` 分别下探并展示Top N目录
- - 🗄️ **大文件分析** - 扫描并列出指定路径下最大的文件，支持数量和最小体积阈值
- - ⏱️ **支持MCP调用** - 支持你自己的AI Agent无缝调用磁盘空间信息
+- 🗑️ **一键删除应用** - 在应用分析列表中输入序号即可一键删除所选应用及其缓存（含二次确认）
+- 🏠 **用户目录深度分析** - 针对 `~/Library`、`~/Downloads`、`~/Documents` 分别下探并展示Top N目录
+- 🗄️ **大文件分析** - 扫描并列出指定路径下最大的文件，支持数量和最小体积阈值
+- 🔄 **返回上一级** - 在下探分析中支持选择0返回上一级目录
+- ⏱️ **支持MCP调用** - 支持你自己的AI Agent无缝调用磁盘空间信息
 
 ## 安装
 
-### 方法1：直接使用（推荐）
+### 方法1：通过 pip 安装（推荐）
+
+```bash
+python3 -m pip install --upgrade myspace-cli
+
+# 支持Pip安装
+pip install myspace-cli
+
+# 安装完成后直接使用
+# 请注意命令行的启动文件名(space-cli)和pip包的名字(myspace-cli)不一样
+# 建议直接运行，可以看到使用菜单
+space-cli
+
+# 或以模块方式
+python3 -m space_cli
+
+# 如果要使用高级的功能，请使用更复杂的命令行参数，可以运行help
+space-cli --help
+
+```
+
+### 方法2：直接使用
 
 ```bash
 # 克隆或下载项目
@@ -55,7 +78,7 @@ chmod +x space_cli.py
 python3 space_cli.py
 ```
 
-### 方法2：创建全局命令
+### 方法3：创建全局命令
 
 ```bash
 # 复制到系统路径
@@ -66,24 +89,14 @@ sudo chmod +x /usr/local/bin/space-cli
 space-cli
 ```
 
-### 方法3：通过 pip 安装（发布到 PyPI 后）
-
-```bash
-python3 -m pip install --upgrade spacecli
-
-# 直接使用命令
-space-cli --help
-
-# 或者作为模块调用
-python3 -m space_cli --help
-```
+注：若你更倾向于使用 PyPI 包名 `spacecli`，也可执行 `python3 -m pip install --upgrade spacecli`，命令入口同为 `space-cli`。
 
 ## 使用方法
 
 ### 基本用法
 
 ```bash
-# 分析根目录（默认）
+# 分析根目录（默认）- 支持交互式下探分析
 python3 space_cli.py
 
 # 分析指定路径
@@ -94,6 +107,9 @@ python3 space_cli.py -n 10
 
 # 快捷分析当前用户目录（含用户目录深度分析）
 python3 space_cli.py --home
+
+# 交互式目录空间分析（支持选择序号下探，选择0返回上一级）
+python3 space_cli.py --directories-only
 ```
 
 ### 高级用法
@@ -126,6 +142,8 @@ python3 space_cli.py --no-prompt
 # 分析应用目录占用并给出卸载建议（按应用归并）
 python3 space_cli.py --apps -n 20
 
+# 在应用分析输出后，按提示输入序号一键删除应用（会二次确认）
+# 例如：输入 3 即删除列表中的第3个应用及其相关缓存
 # 大文件分析（显示前20个，阈值2G）
 python3 space_cli.py --big-files --big-files-top 20 --big-files-min 2G
 
@@ -174,21 +192,30 @@ python3 space_cli.py --big-files --export report.json
 建议: 磁盘空间不足，建议清理一些文件
 ```
 
-### 目录分析
+### 交互式目录分析
 ```
 ============================================================
 📊 占用空间最大的目录
 ============================================================
 显示前 20 个最大的目录:
 
- 1. /Applications
-    大小: 15.2 GB (3.04%)
+ 1. /Applications --    大小: 15.2 GB (3.04%)
+ 2. /Users/username/Library --    大小: 8.5 GB (1.70%)
+ 3. /System --    大小: 6.8 GB (1.36%)
 
- 2. /Users/username/Library
-    大小: 8.5 GB (1.70%)
+============================================================
+🔍 下探分析选项
+============================================================
+选择序号进行深度分析，选择0返回上一级，直接回车退出:
+请输入选择 [回车=退出]: 1
 
- 3. /System
-    大小: 6.8 GB (1.36%)
+🔍 正在分析: /Applications (15.2 GB)
+============================================================
+📊 占用空间最大的目录
+============================================================
+ 1. /Applications/Xcode.app --    大小: 8.2 GB (1.64%)
+ 2. /Applications/Docker.app --    大小: 3.1 GB (0.62%)
+ 3. /Applications/Visual Studio Code.app --    大小: 1.8 GB (0.36%)
 ```
 
 ### 大文件分析
@@ -200,6 +227,29 @@ python3 space_cli.py --big-files --export report.json
  2. /Users/username/Movies/clip.mov   --  大小: 3.1 GB (0.62%)
 ```
 
+### 应用分析与一键删除
+```
+============================================================
+🧩 应用目录空间分析与卸载建议
+============================================================
+ 1. Docker Desktop  --  占用: 9.1 GB (1.80%)  — 建议卸载或清理缓存
+ 2. Xcode           --  占用: 6.2 GB (1.23%)  — 建议卸载或清理缓存
+ 3. WeChat          --  占用: 2.4 GB (0.47%)  — 可保留，定期清理缓存
+
+是否要一键删除某个应用？输入序号或回车跳过: 1
+确认删除应用及相关缓存: Docker Desktop (约 9.1 GB)？[y/N]: y
+将尝试删除以下路径：
+ - /Applications/Docker.app
+ - ~/Library/Application Support/Docker
+ - ~/Library/Caches/com.docker.docker
+...（略）
+✅ 删除完成，预计释放空间: 8.7 GB
+```
+
+说明：
+- 删除动作包含二次确认，并会列出将删除的路径清单。
+- 系统级目录可能因权限/SIP 受保护而无法完全删除，此时工具会尽量清理可删部分并给出失败项与原因。
+
 
 ## MCP Server（可选）
 
@@ -226,11 +276,13 @@ python3 mcp_server.py
 
 ## 性能优化
 
-- 使用递归算法高效计算目录大小
-- 跳过无法访问的系统文件和隐藏文件
-- 支持中断操作（Ctrl+C）
-- 内存优化的文件遍历
- - 单行滚动进度避免输出刷屏
+- **优先使用 `du -sk` 命令**：在 macOS 上使用原生 `du` 命令快速获取目录大小
+- **智能回退机制**：当 `du` 命令失败时，自动回退到基于 `os.scandir` 的高效遍历
+- **跳过系统目录**：自动忽略 `/System`、`/Volumes`、`/private` 等系统目录
+- **跳过无法访问的文件**：自动处理权限错误和符号链接
+- **支持中断操作**：使用 Ctrl+C 随时中断分析
+- **内存优化遍历**：使用栈式迭代替代递归，避免深度目录的栈溢出
+- **单行滚动进度**：避免输出刷屏，使用 ANSI 清行（\r\033[K）避免长行残留
 
 ## 故障排除
 
@@ -244,6 +296,11 @@ sudo python3 space_cli.py
 python3 space_cli.py -p /Users/$(whoami)
 ```
 
+此外，针对“Operation not permitted”等提示：
+- 退出相关应用后再试（例如删除 Docker 前先退出 Docker Desktop）。
+- 在“系统设置 → 隐私与安全性”中为终端授予“完全磁盘访问权限”。
+- 遇到容器元数据或受 SIP 保护的系统级文件（如 `~/Library/Containers/com.docker.docker/... .plist`），可能无法删除，建议仅清理用户级缓存目录。
+
 ### 性能问题
 对于大型文件系统，分析可能需要较长时间：
 - 使用 `--directories-only` 跳过健康检查
@@ -282,3 +339,16 @@ MIT License
 - 新增大文件分析 `--big-files`/`--big-files-top`/`--big-files-min`
 - 导出报告在启用大文件分析时包含 `largest_files`
 - 单行滚动进度显示
+
+### v1.2.0
+- 应用分析支持"按序号一键删除应用"，并显示将删除的路径清单与预计释放空间
+- 删除过程增加权限修复与降级清理策略（chflags nouchg / chmod 0777 / 逐项清理）
+- 针对 "Operation not permitted" 增加友好提示（SIP、完全磁盘访问、退出相关应用）
+- 单行覆盖输出加入 ANSI 清行，避免长行残留
+
+### v1.3.0
+- **性能大幅优化**：优先使用 `du -sk` 命令获取目录大小，失败时回退到 `os.scandir` 高效遍历
+- **交互式下探分析**：支持选择序号进行深度目录分析，选择0返回上一级
+- **增强系统信息**：显示 CPU、内存、GPU、硬盘等完整硬件信息
+- **智能目录过滤**：自动忽略系统目录（`/System`、`/Volumes`、`/private`）
+- **优化用户体验**：改进菜单选项，支持交互式目录空间分析

myspace_cli-1.4.0.dist-info/RECORD

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

space_cli.py

@@ -154,20 +154,48 @@ class SpaceAnalyzer:
         return f"{bytes_value:.1f} PB"
     
     def get_directory_size(self, path: str) -> int:
-        """递归计算目录大小"""
-        total_size = 0
+        """高性能计算目录大小。
+
+        优先使用 macOS 的 du -sk（以 KiB 为单位，速度快，原生命令可处理边界情况），
+        若 du 调用失败则回退到基于 os.scandir 的非递归遍历实现（避免 os.walk 的函数调用开销）。
+        """
+        # 优先尝试 du -sk（BSD du 在 macOS 可用）。
         try:
-            for dirpath, dirnames, filenames in os.walk(path):
-                for filename in filenames:
-                    filepath = os.path.join(dirpath, filename)
-                    try:
-                        total_size += os.path.getsize(filepath)
-                    except (OSError, FileNotFoundError):
-                        # 跳过无法访问的文件
-                        continue
-        except (OSError, PermissionError):
-            # 跳过无法访问的目录
+            # 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,
@@ -182,7 +210,7 @@ class SpaceAnalyzer:
                 dirpath_display = dirpath[-80:] # 截取最后50个字符
                 if dirpath_display == "":
                     dirpath_display = dirpath
-                sys.stdout.write(f"\r-> 正在读取: \033[36m{dirpath_display}\033[0m")
+                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)
@@ -203,7 +231,7 @@ class SpaceAnalyzer:
                         if dirpath_display == "":
                             dirpath_display = dirpath
                         # 间隔性进度输出（单行覆盖）
-                        sys.stdout.write(f"\r-> 正在读取: \033[36m{dirpath_display}\033[0m    已扫描文件数: \033[32m{scanned}\033[0m")
+                        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用户中断扫描，返回当前结果...")
@@ -241,6 +269,14 @@ class SpaceAnalyzer:
                     return [(e["path"], int(e["size"])) for e in cached["entries"]][:top_n]
 
         print("正在分析目录大小，这可能需要一些时间...")
+
+        # 忽略的目录列表, 这些目录时系统目录，不需要分析
+        ignore_dir_list = [
+            "/System",  # 系统目录
+            "/Volumes", # 外部挂载卷
+            "/private", # 私有目录
+        ]
+
         
         directory_sizes = []
         
@@ -252,11 +288,14 @@ class SpaceAnalyzer:
                 # 跳过隐藏文件和系统文件
                 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[36m{item_path}\033[0m")
+                        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))
@@ -284,19 +323,58 @@ class SpaceAnalyzer:
             return []
     
     def get_system_info(self) -> Dict:
-        """获取系统信息"""
+        """获取系统信息（包括 CPU、内存、GPU、硬盘等硬件信息）"""
+        system_info = {}
+        
         try:
-            # 获取系统版本
+            # 获取系统版本信息
             result = subprocess.run(['sw_vers'], capture_output=True, text=True)
-            system_info = {}
             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()
             
-            return system_info
+            # 获取 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:
-            return {"ProductName": "macOS", "ProductVersion": "未知"}
+            system_info["运行时间"] = "未知"
+        
+        return system_info
 
 
 class SpaceCli:
@@ -311,6 +389,200 @@ class SpaceCli:
         os.makedirs(app_cache_dir, exist_ok=True)
         self.app_index = IndexStore(index_file=os.path.join(app_cache_dir, "apps.json"))
 
+    # —— 应用删除相关 ——
+    def _candidate_app_paths(self, app_name: str) -> List[str]:
+        """根据应用名推导可能占用空间的相关目录/文件路径列表。"""
+        home = str(Path.home())
+        candidates: List[str] = []
+        possible_bases = [
+            ("/Applications", f"{app_name}.app"),
+            (os.path.join(home, "Applications"), f"{app_name}.app"),
+            ("/Library/Application Support", app_name),
+            (os.path.join(home, "Library", "Application Support"), app_name),
+            ("/Library/Caches", app_name),
+            (os.path.join(home, "Library", "Caches"), app_name),
+            ("/Library/Logs", app_name),
+            (os.path.join(home, "Library", "Logs"), app_name),
+            (os.path.join(home, "Library", "Containers"), app_name),
+        ]
+        # 直接拼接命中
+        for base, tail in possible_bases:
+            path = os.path.join(base, tail)
+            if os.path.exists(path):
+                candidates.append(path)
+        # 模糊扫描：包含应用名的目录
+        scan_dirs = [
+            "/Applications",
+            os.path.join(home, "Applications"),
+            "/Library/Application Support",
+            os.path.join(home, "Library", "Application Support"),
+            "/Library/Caches",
+            os.path.join(home, "Library", "Caches"),
+            "/Library/Logs",
+            os.path.join(home, "Library", "Logs"),
+            os.path.join(home, "Library", "Containers"),
+        ]
+        app_lower = app_name.lower()
+        for base in scan_dirs:
+            if not os.path.exists(base):
+                continue
+            try:
+                for item in os.listdir(base):
+                    item_path = os.path.join(base, item)
+                    # 只收集目录或 .app 包
+                    if not os.path.isdir(item_path):
+                        continue
+                    name_lower = item.lower()
+                    if app_lower in name_lower:
+                        candidates.append(item_path)
+            except (PermissionError, OSError):
+                continue
+        # 去重并按路径长度降序（先删更深层，避免空目录残留）
+        uniq: List[str] = []
+        seen = set()
+        for p in sorted(set(candidates), key=lambda x: len(x), reverse=True):
+            if p not in seen:
+                uniq.append(p)
+                seen.add(p)
+        return uniq
+
+    def _delete_paths_and_sum(self, paths: List[str]) -> Tuple[int, List[Tuple[str, str]]]:
+        """删除给定路径列表，返回释放的总字节数与失败列表(路径, 原因)。"""
+        total_freed = 0
+        failures: List[Tuple[str, str]] = []
+        
+        def _try_fix_permissions(path: str) -> None:
+            """尝试修复权限与不可变标记以便删除。"""
+            try:
+                # 去除不可变标记（普通用户能去除的场景）
+                subprocess.run(["chflags", "-R", "nouchg", path], capture_output=True)
+            except Exception:
+                pass
+            try:
+                os.chmod(path, 0o777)
+            except Exception:
+                pass
+
+        def _onerror(func, path, exc_info):
+            # 当 rmtree 无法删除时，尝试修复权限并重试一次
+            _try_fix_permissions(path)
+            try:
+                func(path)
+            except Exception:
+                # 让上层捕获
+                raise
+        for p in paths:
+            try:
+                size_before = 0
+                try:
+                    if os.path.isdir(p):
+                        size_before = self.analyzer.get_directory_size(p)
+                    elif os.path.isfile(p):
+                        size_before = os.path.getsize(p)
+                except Exception:
+                    size_before = 0
+                if os.path.isdir(p) and not os.path.islink(p):
+                    try:
+                        shutil.rmtree(p, ignore_errors=False, onerror=_onerror)
+                    except Exception:
+                        # 目录删除失败，降级为逐项尝试删除（尽量清理可删部分）
+                        for dirpath, dirnames, filenames in os.walk(p, topdown=False):
+                            for name in filenames:
+                                fpath = os.path.join(dirpath, name)
+                                try:
+                                    _try_fix_permissions(fpath)
+                                    os.remove(fpath)
+                                except Exception:
+                                    continue
+                            for name in dirnames:
+                                dpath = os.path.join(dirpath, name)
+                                try:
+                                    _try_fix_permissions(dpath)
+                                    os.rmdir(dpath)
+                                except Exception:
+                                    continue
+                        # 最后尝试删除顶层目录
+                        _try_fix_permissions(p)
+                        os.rmdir(p)
+                else:
+                    os.remove(p)
+                total_freed += size_before
+            except Exception as e:
+                failures.append((p, str(e)))
+        return total_freed, failures
+
+    def _offer_app_delete(self, apps: List[Tuple[str, int]]) -> None:
+        """在已打印的应用列表后，提供按序号一键删除功能。"""
+        if not sys.stdin.isatty() or getattr(self.args, 'no_prompt', False):
+            return
+        try:
+            ans = input("是否要一键删除某个应用？输入序号或回车跳过: ").strip()
+        except EOFError:
+            ans = ""
+        if not ans:
+            return
+        try:
+            idx = int(ans)
+        except ValueError:
+            print("❌ 无效的输入（应为数字序号）")
+            return
+        if idx < 1 or idx > len(apps):
+            print("❌ 序号超出范围")
+            return
+        app_name, app_size = apps[idx - 1]
+        size_str = self.analyzer.format_bytes(app_size)
+        try:
+            confirm = input(f"确认删除应用及相关缓存: {app_name} (约 {size_str})？[y/N]: ").strip().lower()
+        except EOFError:
+            confirm = ""
+        if confirm not in ("y", "yes"):
+            print("已取消删除")
+            return
+        related_paths = self._candidate_app_paths(app_name)
+        if not related_paths:
+            print("未找到可删除的相关目录/文件")
+            return
+        print("将尝试删除以下路径：")
+        for p in related_paths:
+            print(f" - {p}")
+        try:
+            confirm2 = input("再次确认删除以上路径？[y/N]: ").strip().lower()
+        except EOFError:
+            confirm2 = ""
+        if confirm2 not in ("y", "yes"):
+            print("已取消删除")
+            return
+        freed, failures = self._delete_paths_and_sum(related_paths)
+        print(f"✅ 删除完成，预计释放空间: {self.analyzer.format_bytes(freed)}")
+        if failures:
+            print("以下路径删除失败，可能需要手动或管理员权限：")
+            for p, reason in failures:
+                print(f" - {p}  ->  {reason}")
+            # 常见提示：Operation not permitted（SIP/容器元数据等）
+            if any("Operation not permitted" in r for _, r in failures):
+                print("提示：部分系统受保护或容器元数据文件无法删除。可尝试：")
+                print(" - 先退出相关应用（如 Docker）再重试")
+                print(" - 给予当前终端“完全磁盘访问权限”（系统设置 → 隐私与安全性）")
+                print(" - 仅删除用户目录下缓存，保留系统级容器元数据")
+
+    # 通用渲染：目录与应用（减少重复）
+    def _render_dirs(self, entries: List[Tuple[str, int]], total_bytes: int) -> None:
+        for i, (dir_path, size) in enumerate(entries, 1):
+            size_str = self.analyzer.format_bytes(size)
+            percentage = (size / total_bytes) * 100 if total_bytes else 0
+            # 1G 以上红色，否则绿色
+            color = "\033[31m" if size >= 1024**3 else "\033[32m"
+            print(f"{i:2d}. \033[36m{dir_path}\033[0m --    大小: {color}{size_str}\033[0m (\033[33m{percentage:.2f}%\033[0m)")
+
+    def _render_apps(self, entries: List[Tuple[str, int]], disk_total: int) -> None:
+        for i, (app, size) in enumerate(entries, 1):
+            size_str = self.analyzer.format_bytes(size)
+            pct = (size / disk_total) * 100 if disk_total else 0
+            suggestion = "建议卸载或清理缓存" if size >= 5 * 1024**3 else "可保留，定期清理缓存"
+            # 3G 以上红色，否则绿色
+            color = "\033[31m" if size >= 3 * 1024**3 else "\033[32m"
+            print(f"{i:2d}. \033[36m{app}\033[0m  --  占用: {color}{size_str}\033[0m ({pct:.2f}%)  — {suggestion}")
+
     def analyze_app_directories(self, top_n: int = 20,
                                 index: IndexStore = None,
                                 use_index: bool = True,
@@ -369,7 +641,8 @@ class SpaceCli:
                         continue
                     key = app_key_from_path(item_path)
                     # 进度提示：当前应用相关目录（单行覆盖）
-                    sys.stdout.write(f"\r-> 正在读取: {item_path}")
+                    item_path = item_path[:100]
+                    sys.stdout.write(f"\r\033[K-> 正在读取: \033[36m{item_path}\033[0m")
                     sys.stdout.flush()
                     size = self.analyzer.get_directory_size(item_path)
                     scanned_dirs.append(item_path)
@@ -419,37 +692,99 @@ class SpaceCli:
         print(f"建议: \033[36m{message}\033[0m")
         print()
     
-    def print_largest_directories(self, path: str = "/", top_n: int = 20):
+    def print_largest_directories(self, path: str = "/Library", top_n: int = 20):
         """打印占用空间最大的目录"""
         print("=" * 60)
         print("📊 占用空间最大的目录")
         print("=" * 60)
         
+        # 若有缓存：直接显示缓存，然后再询问是否重新分析
+        if self.args.use_index:
+            cached = self.index.get(path)
+            if cached and cached.get("entries"):
+                cached_entries = [(e["path"], int(e["size"])) for e in cached["entries"]][:top_n]
+                total_info = self.analyzer.get_disk_usage(path)
+                total_bytes = total_info['total'] if total_info else 1
+                print(f"(来自索引) 显示前 {min(len(cached_entries), top_n)} 个最大的目录:\n")
+                self._render_dirs(cached_entries, total_bytes)
+                if sys.stdin.isatty() and not self.args.no_prompt:
+                    try:
+                        ans = input("是否重新分析以刷新索引？[y/N]: ").strip().lower()
+                    except EOFError:
+                        ans = ""
+                    if ans not in ("y", "yes"):
+                        # 提供下探分析选项
+                        self._offer_drill_down_analysis(cached_entries, path)
+                        return
+                else:
+                    return
+
         directories = self.analyzer.analyze_largest_directories(
             path,
             top_n=top_n,
             index=self.index,
             use_index=self.args.use_index,
-            reindex=self.args.reindex,
+            reindex=True,  # 走到这里表示要刷新
             index_ttl_hours=self.args.index_ttl,
-            prompt=not self.args.no_prompt,
+            prompt=False,
         )
-        
         if not directories:
             print("❌ 无法分析目录大小")
             return
+        total_info = self.analyzer.get_disk_usage(path)
+        total_bytes = total_info['total'] if total_info else 1
+        print("\n已重新分析，最新结果：\n")
+        self._render_dirs(directories, total_bytes)
+        
+        # 提供下探分析选项
+        self._offer_drill_down_analysis(directories, path)
+
+    def _offer_drill_down_analysis(self, directories: List[Tuple[str, int]], current_path: str) -> None:
+        """提供交互式下探分析选项"""
+        if not sys.stdin.isatty() or getattr(self.args, 'no_prompt', False):
+            return
         
-        print(f"显示前 {min(len(directories), top_n)} 个最大的目录:\n")
+        print("\n" + "=" * 60)
+        print("🔍 下探分析选项")
+        print("=" * 60)
+        print("选择序号进行深度分析，选择0返回上一级，直接回车退出:")
         
-        for i, (dir_path, size) in enumerate(directories, 1):
-            size_str = self.analyzer.format_bytes(size)
-            percentage = (size / self.analyzer.get_disk_usage(path)['total']) * 100 if self.analyzer.get_disk_usage(path) else 0
-            # 目录大小大于1G采用红色显示
-            color = "\033[31m" if size >= 1024**3 else "\033[32m"
-            print(f"{i:2d}. \033[36m{dir_path}\033[0m --    大小: {color}{size_str}\033[0m (\033[33m{percentage:.2f}%\033[0m)")
-            ##print(f"{i:2d}. {dir_path}")
-            ##print(f"    大小: {size_str} ({percentage:.2f}%)")
-            ##print()
+        try:
+            choice = input("请输入选择 [回车=退出]: ").strip()
+        except EOFError:
+            return
+        
+        if not choice:
+            return
+        
+        try:
+            idx = int(choice)
+        except ValueError:
+            print("❌ 无效的输入（应为数字序号）")
+            return
+        
+        if idx == 0:
+            # 返回上一级
+            parent_path = os.path.dirname(current_path.rstrip('/'))
+            if parent_path != current_path and parent_path != '/':
+                print(f"\n🔄 返回上一级: {parent_path}")
+                self.print_largest_directories(parent_path, self.args.top_n)
+            else:
+                print("❌ 已在根目录，无法返回上一级")
+            return
+        
+        if idx < 1 or idx > len(directories):
+            print("❌ 序号超出范围")
+            return
+        
+        selected_path, selected_size = directories[idx - 1]
+        size_str = self.analyzer.format_bytes(selected_size)
+        
+        print(f"\n🔍 正在分析: {selected_path} ({size_str})")
+        print("=" * 60)
+        
+        # 递归调用下探分析
+        self.print_largest_directories(selected_path, self.args.top_n)
 
     def print_app_analysis(self, top_n: int = 20):
         """打印应用目录占用分析，并给出卸载建议"""
@@ -457,29 +792,44 @@ class SpaceCli:
         print("🧩 应用目录空间分析与卸载建议")
         print("=" * 60)
 
+        # 先显示缓存，再决定是否刷新
+        if self.args.use_index:
+            cached = self.app_index.get_named("apps_aggregate")
+            if cached and cached.get("entries"):
+                cached_entries = [(e["name"], int(e["size"])) for e in cached["entries"]][:top_n]
+                total = self.analyzer.get_disk_usage("/")
+                disk_total = total['total'] if total else 1
+                print(f"(来自索引) 显示前 {min(len(cached_entries), top_n)} 个空间占用最高的应用:\n")
+                self._render_apps(cached_entries, disk_total)
+                # 提供一键删除
+                self._offer_app_delete(cached_entries)
+                if sys.stdin.isatty() and not self.args.no_prompt:
+                    try:
+                        ans = input("是否重新分析应用以刷新索引？[y/N]: ").strip().lower()
+                    except EOFError:
+                        ans = ""
+                    if ans not in ("y", "yes"):
+                        return
+                else:
+                    return
+
         apps = self.analyze_app_directories(
             top_n=top_n,
             index=self.app_index,
             use_index=self.args.use_index,
-            reindex=self.args.reindex,
+            reindex=True,
             index_ttl_hours=self.args.index_ttl,
-            prompt=not self.args.no_prompt,
+            prompt=False,
         )
         if not apps:
             print("❌ 未发现可分析的应用目录")
             return
-
         total = self.analyzer.get_disk_usage("/")
         disk_total = total['total'] if total else 1
-
-        print(f"显示前 {min(len(apps), top_n)} 个空间占用最高的应用:\n")
-        for i, (app, size) in enumerate(apps, 1):
-            size_str = self.analyzer.format_bytes(size)
-            pct = (size / disk_total) * 100
-            suggestion = "建议卸载或清理缓存" if size >= 5 * 1024**3 else "可保留，定期清理缓存"
-            print(f"{i:2d}. \033[36m{app}\033[0m  --  占用: {size_str} ({pct:.2f}%)  — {suggestion}")
-            ##print(f"    占用: {size_str} ({pct:.2f}%)  — {suggestion}")
-            #print()
+        print("\n已重新分析，最新应用占用结果：\n")
+        self._render_apps(apps, disk_total)
+        # 提供一键删除
+        self._offer_app_delete(apps)
 
     def print_home_deep_analysis(self, top_n: int = 20):
         """对用户目录的 Library / Downloads / Documents 分别下探分析"""
@@ -545,7 +895,7 @@ class SpaceCli:
         system_info = self.analyzer.get_system_info()
         
         for key, value in system_info.items():
-            print(f"{key}: {value}")
+            print(f"{key}: \033[36m{value}\033[0m")
         print()
     
     def export_report(self, output_file: str, path: str = "/"):
@@ -744,50 +1094,57 @@ def main():
         print("🧭 SpaceCli 菜单（直接回车 = 执行全部项目）")
         print("=" * 60)
         home_path = str(Path.home())
-        print("1) \033[36m执行全部项目（系统信息 + 健康 + 目录 + 应用）\033[0m")
+        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("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":
+        if choice == "0": # 退出
             sys.exit(0)
-        elif choice == "2":
+        elif choice == "2": # 仅显示当前用户目录分析
             args.path = home_path
             args.apps = False
             args.health_only = False
             args.directories_only = False
-        elif choice == "3":
+        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
-        elif choice == "4":
+            args.big_files = False
+        elif choice == "5": # 仅显示最大目录列表
             args.health_only = False
             args.directories_only = True
             args.apps = False
-        elif choice == "5":
+            args.big_files = False
+        elif choice == "6": # 仅显示应用目录分析与建议
             args.health_only = False
             args.directories_only = False
-            args.apps = False
-        elif choice == "6":
-            args.health_only = False
-            args.directories_only = True
             args.apps = True
-        elif choice == "7":
+            args.big_files = False
+        elif choice == "7": # 仅显示大文件分析
             args.health_only = False
-            args.directories_only = True
+            args.directories_only = False
             args.apps = False
             args.big_files = True
-        else:
-            # 默认执行全部（用户不选择，或者选择1）
-            args.apps = True
+        else: # 默认执行全部（用户不选择，或者选择1）            
+            args.health_only = True
+            args.directories_only = False
+            args.big_files = False
+            args.apps = True            
+
 
     # --home 优先设置路径
     if getattr(args, 'home', False):
@@ -805,15 +1162,14 @@ def main():
     
     try:
         # 显示系统信息
-        if not args.directories_only:
-            space_cli.print_system_info()
+        space_cli.print_system_info()
         
         # 显示磁盘健康状态
-        if not args.directories_only:
+        if args.health_only:
             space_cli.print_disk_health(args.path)
         
         # 显示目录分析
-        if not args.health_only:
+        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())):
@@ -824,7 +1180,8 @@ def main():
             space_cli.print_app_analysis(args.top_n)
 
         # 大文件分析
-        if getattr(args, 'big_files', False):
+        #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)
         
         # 导出报告

myspace_cli-1.2.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-space_cli.py,sha256=cQR64qsQyjGkkOskkm3EH59dx-T2idfv_YYuI6VPk9A,32260
-myspace_cli-1.2.0.dist-info/METADATA,sha256=AKVi6Os8zDw6h8z_St0DAgaYy3PpCT3HUOzhCe9cUHY,8284
-myspace_cli-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-myspace_cli-1.2.0.dist-info/entry_points.txt,sha256=sIVEmPf6W8aNa7KiqOwAI6JrsgHlQciO5xH2G29tKPQ,45
-myspace_cli-1.2.0.dist-info/top_level.txt,sha256=lnUfbQX9h-9ZjecMVCOWucS2kx69FwTndlrb48S20Sc,10
-myspace_cli-1.2.0.dist-info/RECORD,,