save-c 1.0.0__py3-none-any.whl

save_c-1.0.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: save-c
+Version: 1.0.0
+Summary: 将 C 盘目录迁移到 D 盘并创建软链接，安全释放 C 盘空间
+Project-URL: Homepage, https://github.com/user/save-c
+Project-URL: Source, https://github.com/user/save-c
+Author-email: icexmoon <icexmoon@qq.com>
+License: Apache-2.0
+Keywords: disk,space-saver,symlink,windows
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# save-c
+
+将 C 盘目录迁移到 D 盘并创建目录软链接（symlink），安全释放 C 盘空间。
+
+先完整拷贝到 D 盘，确认成功后删除 C 盘原目录，再创建软链接指回 D 盘。
+拷贝出错时自动清理残缺文件，不会留下脏数据。
+
+## 安装
+
+```bash
+pip install .
+```
+
+或开发模式安装（编辑后即时生效）：
+
+```bash
+pip install -e .
+```
+
+## 用法
+
+### 交互模式
+
+直接执行 `savec`，按提示输入路径：
+
+```bash
+savec
+```
+
+### 命令行模式
+
+```
+savec C:\Users\xxx\AppData\Roaming\SomeApp
+```
+
+### 模拟运行（不做任何实际修改）
+
+```
+savec C:\Users\xxx\SomeDir --dry-run
+```
+
+### 跳过确认
+
+```
+savec C:\Users\xxx\SomeDir --force
+```
+
+### 自定义 D 盘保存目录
+
+```
+savec C:\Users\xxx\SomeDir --dest-dir D:\my_moved
+```
+
+## 扫描模式（批量迁移）
+
+扫描用户目录下的所有子目录，统计占用的磁盘空间，交互式选择要迁移的目录。
+
+```bash
+savec scan
+```
+
+### 扫描指定目录
+
+```bash
+savec scan -d C:\Users\xxx\AppData
+```
+
+### 扫描并模拟运行
+
+```bash
+savec scan --dry-run
+```
+
+### Python API
+
+```python
+from savec import move_and_link
+
+move_and_link("C:\\Users\\xxx\\SomeDir", dry_run=True)
+
+from savec import scan_and_select_interactive
+
+scan_and_select_interactive("C:\\Users\\xxx", dry_run=True)
+```
+
+## 安全说明
+
+- 只允许操作 C 盘目录。
+- 禁止迁移 Windows 系统目录。
+- 拷贝失败自动回滚删除残缺文件。
+- 删除原目录前会二次确认（除非 `--force`）。
+- 创建和删除软链接、删除目录需要**管理员身份**运行。
+
+## 许可证
+
+Apache-2.0
+

save_c-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+savec/__init__.py,sha256=mTo9XpMw0Q3FBCE5jN4lmiQ4y5n2hich9Gu2hh02UPM,322
+savec/__main__.py,sha256=W73yLsFrjelHrDG8yQCzfxKthFZ4mojoFXwAP0DVR-M,97
+savec/cli.py,sha256=a_l6pthR9n35I0TL36uzyYzY0iImvRK7U3G5RX5yRoQ,4602
+savec/core.py,sha256=LmJrtSZ2AWyvo6tGyTIVDbMiNIWKeNLtXhMcV8BCZG8,5203
+savec/scan.py,sha256=crzqZYEOBYcpkZqPTi_jhsNt4Dl0FnwbjcLn-Zt-FNA,11207
+save_c-1.0.0.dist-info/METADATA,sha256=0i-UAjpQl8KU2vmK4EDAqGsX5dX0tp5TTUsK8AvkCdQ,2424
+save_c-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+save_c-1.0.0.dist-info/entry_points.txt,sha256=ihYSbNXD92-OoKsLPO88ih0_8vsUtWtlAXcHoF1NIGo,41
+save_c-1.0.0.dist-info/RECORD,,

save_c-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

save_c-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+savec = savec.cli:main

savec/__init__.py

@@ -0,0 +1,10 @@
+"""
+save-c — 将 C 盘目录迁移到 D 盘并创建软链接，安全释放 C 盘空间。
+"""
+
+__version__ = "1.0.0"
+
+from savec.core import move_and_link, DryRunError
+from savec.scan import ScanEntry, scan_and_select_interactive
+
+__all__ = ["move_and_link", "DryRunError", "ScanEntry", "scan_and_select_interactive"]

savec/__main__.py

@@ -0,0 +1,7 @@
+"""
+python -m savec 支持
+"""
+from savec.cli import main
+
+if __name__ == "__main__":
+    main()

savec/cli.py

@@ -0,0 +1,153 @@
+"""
+命令行入口：``savec`` | ``savec scan`` | ``python -m savec``。
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+from savec import __version__
+from savec.core import DryRunError, move_and_link
+from savec.scan import scan_and_select_interactive
+
+
+def _build_move_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="savec",
+        description="将 C 盘目录迁移到 D 盘并创建软链接，安全释放 C 盘空间。",
+        epilog=(
+            "不传参时进入交互模式，由程序提示输入路径。\n"
+            "注意：创建和删除软链接、删除目录需要管理员权限。\n"
+            "子命令: savec scan  — 扫描用户目录并交互式迁移"
+        ),
+    )
+    parser.add_argument(
+        "path",
+        nargs="?",
+        default=None,
+        help="C 盘待迁移的目录完整路径（如 C:\\Users\\xxx\\AppData\\Roaming\\SomeApp）。",
+    )
+    parser.add_argument(
+        "--dest-dir",
+        default="D:\\moved_from_c",
+        help="D 盘目标根目录（默认: D:\\moved_from_c）。",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="模拟运行，打印动作日志但不做任何实际修改。",
+    )
+    parser.add_argument(
+        "-f", "--force",
+        action="store_true",
+        help="跳过二次确认提示。",
+    )
+    parser.add_argument(
+        "-V", "--version",
+        action="version",
+        version=f"save-c {__version__}",
+        help="显示版本信息并退出。",
+    )
+    return parser
+
+
+def _build_scan_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="savec scan",
+        description="扫描目录，统计可迁移的空间并交互式选择迁移。",
+    )
+    parser.add_argument(
+        "-d", "--dir",
+        default=os.path.expanduser("~"),
+        help="要扫描的目录（默认: 当前用户主目录）。",
+    )
+    parser.add_argument(
+        "--dest-dir",
+        default="D:\\moved_from_c",
+        help="D 盘目标根目录（默认: D:\\moved_from_c）。",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="模拟运行，不做实际修改。",
+    )
+    parser.add_argument(
+        "--min-size",
+        type=int,
+        default=500,
+        metavar="MB",
+        help="只显示大于指定大小（MB）的目录（默认: 500MB）。",
+    )
+    parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        help="忽略缓存，强制重新扫描。",
+    )
+    return parser
+
+
+def _run_move(argv: list[str]) -> int:
+    """迁移模式：处理单个目录迁移。"""
+    parser = _build_move_parser()
+    args = parser.parse_args(argv)
+
+    if args.path is None:
+        print("===== save-c: C盘目录迁移 + 软链接（安全增强版）=====")
+        print("说明：先完整复制，成功后再删原目录，异常自动清理残缺文件\n")
+        raw = input("请输入要迁移的 C 盘完整目录路径: ").strip().strip('"')
+        if not raw:
+            print("[CANCEL] 未输入路径，退出。")
+            return 0
+        args.path = raw
+
+    try:
+        move_and_link(
+            args.path,
+            dst_dir=args.dest_dir,
+            dry_run=args.dry_run,
+            skip_confirm=args.force,
+        )
+        return 0
+    except DryRunError:
+        return 0
+    except PermissionError:
+        return 1
+    except (ValueError, OSError) as exc:
+        print(f"错误: {exc}")
+        return 1
+
+
+def _run_scan(argv: list[str]) -> int:
+    """扫描模式：交互式扫描、选择并迁移。"""
+    parser = _build_scan_parser()
+    args = parser.parse_args(argv)
+    return scan_and_select_interactive(
+        args.dir,
+        dest_dir=args.dest_dir,
+        dry_run=args.dry_run,
+        min_size=args.min_size * 1024 * 1024,
+        no_cache=args.no_cache,
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    if argv is None:
+        argv = sys.argv[1:]
+
+    if argv and argv[0] == "scan":
+        return _run_scan(argv[1:])
+    elif argv and argv[0] == "--help":
+        _build_move_parser().print_help()
+        return 0
+    elif argv and argv[0] in ("-V", "--version"):
+        _build_move_parser().parse_args(argv)
+        return 0
+    else:
+        return _run_move(argv)
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+

savec/core.py

@@ -0,0 +1,166 @@
+"""
+核心逻辑：目录安全拷贝、删除、软链接创建。
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import traceback
+
+
+class DryRunError(RuntimeError):
+    """Dry-run 模式下触发的中止信号，不会真正写入磁盘。"""
+
+
+# 禁止移动的系统核心目录前缀
+FORBIDDEN_PREFIXES = [
+    "C:\\Windows",
+    "C:\\Program Files",
+    "C:\\Program Files (x86)",
+    "C:\\System",
+    "C:\\Boot",
+    "C:\\PerfLogs",
+]
+
+
+def safe_copy_dir(src: str, dst: str, *, dry_run: bool = False) -> bool:
+    """安全完整拷贝目录，出错则回滚删除目标。
+
+    Args:
+        src: 源目录路径。
+        dst: 目标目录路径。
+        dry_run: 仅打印模拟信息，不实际拷贝。
+
+    Returns:
+        True 拷贝成功；False 目标已存在或拷贝失败。
+
+    Raises:
+        DryRunError: dry_run 模式下触发，调用方据此跳过后续实际写入。
+    """
+    if os.path.exists(dst):
+        print(f"  [X] 目标目录已存在: {dst}")
+        return False
+
+    if dry_run:
+        print(f"  [DRY] 模拟拷贝: {src}  ->  {dst}")
+        return True
+
+    try:
+        shutil.copytree(src, dst, dirs_exist_ok=False)
+        print(f"  [OK] 目录拷贝完成: {dst}")
+        return True
+    except Exception as e:
+        print(f"  [X] 拷贝过程出错: {e}")
+        if os.path.exists(dst):
+            try:
+                shutil.rmtree(dst)
+                print(f"  [CLEAN] 已清理残缺拷贝目录: {dst}")
+            except Exception:
+                print(f"  [WARN] 清理残缺目录失败，请手动删除: {dst}")
+        return False
+
+
+def move_and_link(
+    src: str,
+    *,
+    dst_dir: str = "D:\\moved_from_c",
+    dry_run: bool = False,
+    skip_confirm: bool = False,
+) -> None:
+    """流程：校验 -> 拷贝 -> 删原目录 -> 创建软链接。
+
+    异常自动回滚，提升安全性。
+
+    Args:
+        src: C 盘源目录完整路径。
+        dst_dir: D 盘目标根目录，默认 ``D:\\moved_from_c``。
+        dry_run: 仅打印模拟动作，不实际写入磁盘。
+        skip_confirm: 跳过二次确认提示。
+
+    Raises:
+        ValueError: 路径校验失败（非 C 盘、系统目录等）。
+        DryRunError: dry_run 模式完成全部模拟后抛出，表示流程正常中止。
+        PermissionError: 权限不足（需要管理员身份）。
+    """
+    src = src.rstrip("\\/")
+
+    # ── 源路径检查 ──
+    if not os.path.exists(src):
+        raise ValueError(f"源目录不存在: {src}")
+    if not os.path.isdir(src):
+        raise ValueError(f"不是有效目录: {src}")
+    if not src.startswith("C:\\"):
+        raise ValueError("仅支持转移 C 盘目录！")
+
+    src_lower = src.lower()
+    for fp in FORBIDDEN_PREFIXES:
+        if src_lower.startswith(fp.lower()):
+            raise ValueError(f"禁止转移系统关键目录: {src}")
+
+    # ── 构造目标路径 ──
+    rel_path = os.path.relpath(src, "C:\\")
+    dst_full = os.path.join(dst_dir, rel_path)
+
+    print("=" * 60)
+    print(f"  源目录: {src}")
+    print(f"  目标目录: {dst_full}")
+    print("=" * 60)
+
+    # ── 二次确认 ──
+    if not skip_confirm:
+        try:
+            answer = input("确认执行拷贝+迁移？(y/n): ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            print("[CANCEL] 操作已取消")
+            return
+        if answer != "y":
+            print("[CANCEL] 操作已取消")
+            return
+
+    # ── 执行流程 ──
+    try:
+        # 1. 创建 D 盘总目录
+        if not dry_run:
+            os.makedirs(dst_dir, exist_ok=True)
+        else:
+            print(f"  [DRY] 创建目录: {dst_dir}")
+
+        # 2. 完整拷贝，失败自动回滚
+        print("\n[PACK] 开始完整拷贝文件...")
+        copy_ok = safe_copy_dir(src, dst_full, dry_run=dry_run)
+        if not copy_ok:
+            print("[X] 拷贝失败，终止流程")
+            return
+
+        # 3. 拷贝成功后，删除原 C 盘目录
+        if dry_run:
+            print(f"  [DRY] 删除原目录: {src}")
+        else:
+            print("\n[DEL] 删除原 C 盘目录...")
+            shutil.rmtree(src)
+            print(f"  [OK] 原目录已删除: {src}")
+
+        # 4. 创建目录软链接
+        if dry_run:
+            print(f"  [DRY] 创建软链接: {src}  ->  {dst_full}")
+            raise DryRunError("Dry-run 完成，未做任何实际修改")
+        else:
+            print("\n[LINK] 创建软链接...")
+            os.symlink(dst_full, src, target_is_directory=True)
+            print(f"  [OK] 软链接创建成功: {src}  ->  {dst_full}")
+
+        print("\n[DONE] 全部操作完成，C 盘空间已释放！")
+
+    except PermissionError:
+        print("\n[X] 权限不足！请以管理员身份运行。")
+        raise
+    except DryRunError:
+        raise
+    except Exception as e:
+        print(f"\n[X] 执行异常: {e}")
+        traceback.print_exc()
+        if os.path.exists(dst_full) and not os.path.exists(src):
+            print(f"[WARN] 异常中断，请手动检查:\n   源目录: {src}\n   备份目录: {dst_full}")
+        raise

savec/scan.py

@@ -0,0 +1,338 @@
+"""
+扫描 C 盘用户目录，统计可迁移的目录及空间占用。
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+import time
+from dataclasses import dataclass
+
+from savec.core import DryRunError, move_and_link
+
+# 扫描时忽略的特殊目录（用户主目录下的系统级目录）
+SKIP_DIRS = frozenset({"appdata", "onedrive", "documents"})
+
+CACHE_DIR = os.path.join(os.environ.get("TEMP", os.environ.get("TMPDIR", "/tmp")), "savec-scan-cache")
+CACHE_TTL = 600
+
+
+def _cache_path(base_dir):
+    h = hashlib.sha256(base_dir.encode("utf-8")).hexdigest()[:16]
+    os.makedirs(CACHE_DIR, exist_ok=True)
+    return os.path.join(CACHE_DIR, f"{h}.json")
+
+
+def _load_cache(base_dir):
+    cpath = _cache_path(base_dir)
+    if not os.path.isfile(cpath):
+        return None
+    try:
+        with open(cpath, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if time.time() - data["created_at"] > CACHE_TTL:
+            return None
+        entries = [ScanEntry(**e) for e in data["entries"]]
+        return entries, data["symlink_count"]
+    except (json.JSONDecodeError, KeyError, OSError):
+        return None
+
+
+def _save_cache(base_dir, entries, symlink_count):
+    cpath = _cache_path(base_dir)
+    data = {
+        "base_dir": base_dir,
+        "created_at": time.time(),
+        "symlink_count": symlink_count,
+        "entries": [
+            {"name": e.name, "path": e.path, "size_bytes": e.size_bytes, "is_symlink": e.is_symlink}
+            for e in entries
+        ],
+    }
+    try:
+        with open(cpath, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False)
+    except OSError:
+        pass
+
+
+@dataclass
+class ScanEntry:
+    """单个扫描结果。"""
+    name: str
+    path: str
+    size_bytes: int
+    is_symlink: bool
+
+
+def format_size(size_bytes: int) -> str:
+    """将字节格式化为可读尺寸。"""
+    if size_bytes == 0:
+        return "    0 B"
+    b = float(abs(size_bytes))
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if b < 1024.0:
+            return f"{b:>6.1f} {unit}"
+        b /= 1024.0
+    return f"{b:>6.1f} PB"
+
+
+def _list_dirs(base_dir: str) -> tuple[list[ScanEntry], int]:
+    """列出 base_dir 下的所有子目录，分辨软链接。
+
+    Returns:
+        (entries, symlink_count)
+    """
+    entries: list[ScanEntry] = []
+    symlink_count = 0
+
+    try:
+        with os.scandir(base_dir) as it:
+            for entry in it:
+                if not entry.is_dir(follow_symlinks=False):
+                    continue
+                is_link = os.path.islink(entry.path)
+                entries.append(ScanEntry(
+                    name=entry.name,
+                    path=entry.path,
+                    size_bytes=0,
+                    is_symlink=is_link,
+                ))
+                if is_link:
+                    symlink_count += 1
+    except PermissionError:
+        print(f"  [WARN] 无权限访问: {base_dir}")
+    except FileNotFoundError:
+        print(f"  [X] 目录不存在: {base_dir}")
+
+    return entries, symlink_count
+
+
+def _calc_dir_size(dirpath: str, *, report_name: str = "") -> int:
+    """递归计算目录大小。
+
+    跳过内部软链接子目录，避免重复计算和无限递归。
+    """
+    total = 0
+    try:
+        for root, dirs, files in os.walk(dirpath, followlinks=False):
+            dirs[:] = [d for d in dirs
+                       if not os.path.islink(os.path.join(root, d))]
+            for f in files:
+                fpath = os.path.join(root, f)
+                try:
+                    if not os.path.islink(fpath):
+                        total += os.path.getsize(fpath)
+                except (OSError, PermissionError):
+                    pass
+    except (OSError, PermissionError):
+        pass
+    return total
+
+
+def scan_and_select_interactive(
+    base_dir: str,
+    *,
+    dest_dir: str = "D:\\moved_from_c",
+    dry_run: bool = False,
+    min_size: int = 500 * 1024 * 1024,
+    no_cache: bool = False,
+) -> int:
+    """扫描、展示、交互式选择并迁移目录。
+
+    Returns:
+        0 正常结束；1 出错。
+    """
+    base_dir = base_dir.rstrip("\\/")
+    if not os.path.isdir(base_dir):
+        print(f"[X] 目录不存在: {base_dir}")
+        return 1
+
+    # -- 0. 尝试读取缓存 --
+    loaded_from_cache = False
+    if not no_cache:
+        cached = _load_cache(base_dir)
+        if cached is not None:
+            all_entries, symlink_count = cached
+            loaded_from_cache = True
+            print(f"正在扫描 {base_dir} ...")
+            print("  使用缓存结果（10分钟内有效）")
+
+    if not loaded_from_cache:
+        # -- 1. 列出所有子目录 --
+        print(f"正在扫描 {base_dir} ...")
+        all_entries, symlink_count = _list_dirs(base_dir)
+
+        if not all_entries:
+            print("  未发现任何子目录。")
+            return 0
+
+        # -- 过滤掉不需要扫描的特殊目录 --
+        skip_count = 0
+        filtered = []
+        for e in all_entries:
+            if e.name.lower() in SKIP_DIRS:
+                skip_count += 1
+                continue
+            filtered.append(e)
+        all_entries = filtered
+
+        # -- 额外扫描 AppData\Local 和 AppData\Roaming --
+        appdata_extra = 0
+        for rel in ("AppData\\Local", "AppData\\Roaming"):
+            sub_dir = os.path.join(base_dir, rel)
+            if os.path.isdir(sub_dir):
+                sub_entries, sub_links = _list_dirs(sub_dir)
+                for e in sub_entries:
+                    if not e.is_symlink:
+                        e.name = f"{rel}\\{e.name}"
+                all_entries.extend(sub_entries)
+                symlink_count += sub_links
+                appdata_extra += len(sub_entries)
+
+        if not all_entries:
+            if skip_count and not appdata_extra:
+                print(f"  扫描完成，仅剩余 {skip_count} 个已过滤的目录，无需处理。")
+                return 0
+            elif not skip_count and not appdata_extra:
+                print("  未发现任何子目录。")
+                return 0
+
+        if skip_count:
+            print(f"  已过滤 {skip_count} 个特殊目录")
+        if appdata_extra:
+            print(f"  额外从 AppData\\Local 和 AppData\\Roaming 扫描到 {appdata_extra} 个子目录")
+
+        # -- 2. 分离已迁移（软链接）和待扫描目录 --
+        to_scan = [e for e in all_entries if not e.is_symlink]
+        if not to_scan:
+            print(f"  所有子目录均已迁移（共 {symlink_count} 个软链接），无需处理。")
+            return 0
+
+        print(f"  共 {len(all_entries)} 个子目录，已跳过 {symlink_count} 个已迁移目录（软链接）")
+
+        # -- 3. 计算每个目录大小 --
+        total_dirs = len(to_scan)
+        print(f"  正在统计目录大小 ...   0/{total_dirs}", end="", flush=True)
+        for i, entry in enumerate(to_scan, 1):
+            entry.size_bytes = _calc_dir_size(entry.path)
+            sys.stdout.write(f"\r  正在统计目录大小 ...   {i}/{total_dirs}  {entry.name}  {format_size(entry.size_bytes)}  ")
+            sys.stdout.flush()
+        print()
+
+        _save_cache(base_dir, all_entries, symlink_count)
+
+    else:
+        to_scan = [e for e in all_entries if not e.is_symlink]
+        if not to_scan:
+            print("  所有子目录均已迁移，无需处理。")
+            return 0
+        print(f"  共 {len(all_entries)} 个子目录，已跳过 {symlink_count} 个已迁移目录（软链接）")
+
+    # -- 4. 按大小降序排列 --
+    # ── 4. 按大小降序排列 ──
+    to_scan.sort(key=lambda e: e.size_bytes, reverse=True)
+
+    # ── 过滤小于 min_size 的目录 ──
+    hidden_count = 0
+    hidden_total = 0
+    filtered: list[ScanEntry] = []
+    for e in to_scan:
+        if e.size_bytes < min_size:
+            hidden_count += 1
+            hidden_total += e.size_bytes
+        else:
+            filtered.append(e)
+    to_scan = filtered
+
+    if hidden_count:
+        print(f"  已忽略 {hidden_count} 个小于 {format_size(min_size)} 的目录(合计 {format_size(hidden_total)})")
+
+    if not to_scan:
+        print("  所有目录均小于阈值，无需处理。")
+        return 0
+
+    # ── 5. 展示结果 ──
+    print()
+    print(f"  {'':>4} {'大小':>10}  目录")
+    print(f"  {'':─>4} {'─'*10}  {'─'*50}")
+    for idx, entry in enumerate(to_scan, 1):
+        size_str = format_size(entry.size_bytes)
+        print(f"  {idx:>3}  {size_str}  {entry.name}")
+
+    total_size = sum(e.size_bytes for e in to_scan)
+    print(f"  {'':─>4} {'─'*10}  {'─'*50}")
+    print(f"       {format_size(total_size)}  合计")
+    print()
+
+    # ── 6. 用户选择 ──
+    chosen = _select_entries(to_scan)
+    if not chosen:
+        print("[CANCEL] 未选择任何目录，退出。")
+        return 0
+
+    # ── 7. 逐个迁移 ──
+    success = 0
+    fail = 0
+    chosen_size = sum(e.size_bytes for e in chosen)
+    print(f"\n开始迁移 {len(chosen)} 个目录（合计 {format_size(chosen_size)}）...\n")
+    for entry in chosen:
+        print(f"{'='*60}")
+        print(f"  处理: {entry.path}")
+        try:
+            move_and_link(entry.path, dst_dir=dest_dir, dry_run=dry_run, skip_confirm=True)
+            success += 1
+        except DryRunError:
+            success += 1
+        except (ValueError, PermissionError, OSError) as exc:
+            print(f"  [X] 跳过: {exc}")
+            fail += 1
+        print()
+
+    # ── 8. 汇总 ──
+    if dry_run:
+        print(f"\n[DONE] 模拟完成。成功: {success}, 失败: {fail}")
+    else:
+        print(f"\n[DONE] 迁移完成。成功: {success}, 失败: {fail}")
+    return 0
+
+
+def _select_entries(entries: list[ScanEntry]) -> list[ScanEntry]:
+    """交互式选择目录编号，返回选中的条目列表。"""
+    prompt = "输入编号（空格分隔，如 1 3 5），a=全部，q=取消: "
+    try:
+        raw = input(prompt).strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return []
+
+    if not raw or raw == "q":
+        return []
+    if raw == "a":
+        return list(entries)
+
+    indices: set[int] = set()
+    for part in raw.replace(",", " ").split():
+        if "-" in part:
+            try:
+                a, b = part.split("-", 1)
+                start = int(a.strip())
+                end = int(b.strip())
+                indices.update(range(start, end + 1))
+            except ValueError:
+                continue
+        else:
+            try:
+                indices.add(int(part))
+            except ValueError:
+                continue
+
+    result: list[ScanEntry] = []
+    for idx in sorted(indices):
+        if 1 <= idx <= len(entries):
+            result.append(entries[idx - 1])
+    return result
+