lcch-cli 1.0.1

package/dist/index.js

@@ -0,0 +1,3015 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * LCCH - Claude Code Helper
+ * 管理 Claude Code 配置的 CLI 工具
+ *
+ * 使用方式: lcch <command> [options]
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const prompts_1 = require("@inquirer/prompts");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+const os = __importStar(require("os"));
+const scanner_1 = require("./scanner");
+const backup_1 = require("./backup");
+const export_1 = require("./export");
+/**
+ * 简单掩码函数 - 保留前4位，其余用 **** 替代
+ */
+function maskSecret(secret) {
+    if (secret.length <= 8) {
+        return secret.substring(0, Math.min(4, secret.length)) + '****';
+    }
+    return secret.substring(0, 4) + '****';
+}
+/**
+ * 打印项目会话历史（按有效/无效分类）
+ */
+async function printProjectSessions(config, result, filter = 'all') {
+    const sessions = await (0, scanner_1.readSessionHistory)();
+    const sessionsByProject = (0, scanner_1.groupSessionsByProject)(sessions);
+    // 扫描孤立会话（有session但没有project）
+    const allSessionProjects = new Set(sessionsByProject.keys());
+    const configProjects = new Set([...result.validProjects, ...result.invalidProjects]);
+    const orphanedProjects = [];
+    for (const projectPath of allSessionProjects) {
+        if (!configProjects.has(projectPath)) {
+            orphanedProjects.push(projectPath);
+        }
+    }
+    // 按有效/无效分类
+    const validSet = new Set(result.validProjects);
+    // 打印有效项目的会话
+    if ((filter === 'all' || filter === 'valid') && result.validProjects.length > 0) {
+        console.log(chalk_1.default.green.bold(`\n✓ 有效项目 (${result.validProjects.length} 个):\n`));
+        const sortedValid = [...result.validProjects].sort();
+        for (const projectPath of sortedValid) {
+            const projectSessions = sessionsByProject.get(projectPath) || [];
+            printProjectSessionDetail(projectPath, true, projectSessions);
+        }
+    }
+    // 打印无效项目的会话
+    if ((filter === 'all' || filter === 'invalid') && result.invalidProjects.length > 0) {
+        console.log(chalk_1.default.red.bold(`\n✗ 无效项目 (${result.invalidProjects.length} 个):\n`));
+        const sortedInvalid = [...result.invalidProjects].sort();
+        for (const projectPath of sortedInvalid) {
+            const projectSessions = sessionsByProject.get(projectPath) || [];
+            printProjectSessionDetail(projectPath, false, projectSessions);
+        }
+    }
+    // 打印孤立会话
+    if ((filter === 'all' || filter === 'orphaned') && orphanedProjects.length > 0) {
+        console.log(chalk_1.default.yellow.bold(`\n⚠ 孤立会话 (${orphanedProjects.length} 个 - 有记录但无配置):\n`));
+        const sortedOrphaned = orphanedProjects.sort();
+        for (const projectPath of sortedOrphaned) {
+            const projectSessions = sessionsByProject.get(projectPath) || [];
+            printProjectSessionDetail(projectPath, null, projectSessions);
+        }
+    }
+    // 汇总（只显示符合条件的）
+    console.log(chalk_1.default.bold('\n会话汇总:'));
+    if (filter === 'all' || filter === 'valid') {
+        console.log(`  ${chalk_1.default.green('有效项目')}: ${result.validProjects.length}`);
+    }
+    if (filter === 'all' || filter === 'invalid') {
+        console.log(`  ${chalk_1.default.red('无效项目')}: ${result.invalidProjects.length}`);
+    }
+    if (filter === 'all' || filter === 'orphaned') {
+        console.log(`  ${chalk_1.default.yellow('孤立会话')}: ${orphanedProjects.length}`);
+    }
+    if (filter === 'all') {
+        console.log(`  总计: ${result.totalCount + orphanedProjects.length}`);
+    }
+}
+/**
+ * 打印单个项目的会话详情
+ */
+function printProjectSessionDetail(projectPath, isValid, projectSessions) {
+    // 项目标题
+    let statusIcon;
+    let pathColor;
+    if (isValid === true) {
+        statusIcon = chalk_1.default.green('✓');
+        pathColor = chalk_1.default.white;
+    }
+    else if (isValid === false) {
+        statusIcon = chalk_1.default.red('✗');
+        pathColor = chalk_1.default.gray;
+    }
+    else {
+        statusIcon = chalk_1.default.yellow('⚠');
+        pathColor = chalk_1.default.yellow;
+    }
+    const sessionCount = projectSessions.length;
+    const countStr = sessionCount > 0 ? chalk_1.default.gray(`(${sessionCount} 条记录)`) : chalk_1.default.gray('(无记录)');
+    console.log(`${statusIcon} ${pathColor(chalk_1.default.bold(projectPath))} ${countStr}`);
+    // 显示会话记录（最多显示最近10条）
+    if (projectSessions.length > 0) {
+        const displaySessions = projectSessions.slice(0, 10);
+        for (let i = 0; i < displaySessions.length; i++) {
+            const session = displaySessions[i];
+            const isLast = i === displaySessions.length - 1;
+            const connector = isLast ? '└── ' : '├── ';
+            const timeStr = chalk_1.default.gray(`[${(0, scanner_1.formatRelativeTime)(session.timestamp)}]`);
+            const sessionIdStr = chalk_1.default.cyan(`[${session.sessionId}]`);
+            const content = (0, scanner_1.truncateText)(session.display || '(空)', 50);
+            console.log(`    ${connector}${timeStr} ${sessionIdStr} ${content}`);
+        }
+        // 如果还有更多，显示省略提示
+        if (projectSessions.length > 10) {
+            console.log(`    └── ${chalk_1.default.gray(`... 还有 ${projectSessions.length - 10} 条记录`)}`);
+        }
+    }
+    console.log();
+}
+/**
+ * 打印所有项目的 resume 历史（按有效/无效分类）
+ */
+async function printProjectResumes(config, result, allowDelete = false, filter = 'all') {
+    const validSet = new Set(result.validProjects);
+    const allConfigProjects = new Set([...result.validProjects, ...result.invalidProjects]);
+    // 收集所有 config 中项目的 resume 信息（包括有 resume 和没有 resume 的）
+    const allProjects = [];
+    for (const projectPath of allConfigProjects) {
+        const resumes = await (0, scanner_1.getProjectResumeInfo)(projectPath);
+        allProjects.push({
+            projectPath,
+            isValid: validSet.has(projectPath),
+            resumes,
+        });
+    }
+    // 扫描孤立的 resume（不在 config 中的项目目录）
+    const orphanedResumes = await (0, scanner_1.getOrphanedResumes)(allConfigProjects);
+    if (allProjects.length === 0 && orphanedResumes.length === 0) {
+        console.log(chalk_1.default.yellow('\n没有找到任何项目'));
+        return;
+    }
+    // 按有效/无效/孤立分类
+    const validProjects = allProjects.filter(p => p.isValid);
+    const invalidProjects = allProjects.filter(p => !p.isValid);
+    const validWithResume = validProjects.filter(p => p.resumes.length > 0);
+    const validNoResume = validProjects.filter(p => p.resumes.length === 0);
+    const invalidWithResume = invalidProjects.filter(p => p.resumes.length > 0);
+    const invalidNoResume = invalidProjects.filter(p => p.resumes.length === 0);
+    const allResumeChoices = [];
+    // 详细显示 resume（仅在非删除模式下显示）
+    if (!allowDelete) {
+        // 打印有效项目（有 resume）
+        if ((filter === 'all' || filter === 'valid') && validWithResume.length > 0) {
+            console.log(chalk_1.default.green.bold(`\n✓ 有效项目 - 有 resume (${validWithResume.length} 个):\n`));
+            for (const { projectPath, resumes } of validWithResume) {
+                console.log(`${chalk_1.default.green('✓')} ${chalk_1.default.bold(projectPath)} ${chalk_1.default.gray(`(${resumes.length} 个 resume)`)}`);
+                resumes.forEach((resume, index) => {
+                    const isLast = index === resumes.length - 1;
+                    const connector = isLast ? '└── ' : '├── ';
+                    // 一行格式: [session-id] 创建时间→最后活动时间 | 消息数 | 磁盘大小 | 压缩次数
+                    const createdTime = (0, scanner_1.formatRelativeTime)(resume.createdAt.getTime());
+                    const lastActivityTime = (0, scanner_1.formatRelativeTime)(resume.lastActivity.getTime());
+                    const timeRange = `${createdTime} → ${lastActivityTime}`;
+                    const messagesStr = `${resume.messageCount}条`;
+                    const sizeStr = (0, backup_1.formatFileSize)(resume.fileSize);
+                    const compactStr = resume.compactCount > 0 ? ` | ${resume.compactCount}次压缩` : '';
+                    console.log(`    ${connector}${chalk_1.default.cyan(`[${resume.sessionId}]`)} ${chalk_1.default.gray(timeRange)} | ${chalk_1.default.yellow(messagesStr)} | ${chalk_1.default.gray(sizeStr)}${chalk_1.default.magenta(compactStr)}`);
+                    // 添加到删除选项
+                    allResumeChoices.push({
+                        name: `${projectPath} - [${resume.sessionId}] (${(0, scanner_1.formatRelativeTime)(resume.lastActivity.getTime())})`,
+                        value: { projectPath, sessionId: resume.sessionId },
+                        checked: false,
+                    });
+                });
+                console.log();
+            }
+        }
+        // 打印有效项目（无 resume）
+        if ((filter === 'all' || filter === 'valid') && validNoResume.length > 0) {
+            console.log(chalk_1.default.green.bold(`\n✓ 有效项目 - 无 resume (${validNoResume.length} 个):\n`));
+            for (const { projectPath } of validNoResume) {
+                console.log(`${chalk_1.default.green('✓')} ${chalk_1.default.bold(projectPath)} ${chalk_1.default.gray('(无 resume)')}`);
+            }
+            console.log();
+        }
+        // 打印无效项目（有 resume）
+        if ((filter === 'all' || filter === 'invalid') && invalidWithResume.length > 0) {
+            console.log(chalk_1.default.red.bold(`\n✗ 无效项目 - 有 resume (${invalidWithResume.length} 个):\n`));
+            for (const { projectPath, resumes } of invalidWithResume) {
+                console.log(`${chalk_1.default.red('✗')} ${chalk_1.default.gray(chalk_1.default.bold(projectPath))} ${chalk_1.default.gray(`(${resumes.length} 个 resume)`)}`);
+                resumes.forEach((resume, index) => {
+                    const isLast = index === resumes.length - 1;
+                    const connector = isLast ? '└── ' : '├── ';
+                    // 一行格式: [session-id] 创建时间→最后活动时间 | 消息数 | 磁盘大小 | 压缩次数
+                    const createdTime = (0, scanner_1.formatRelativeTime)(resume.createdAt.getTime());
+                    const lastActivityTime = (0, scanner_1.formatRelativeTime)(resume.lastActivity.getTime());
+                    const timeRange = `${createdTime} → ${lastActivityTime}`;
+                    const messagesStr = `${resume.messageCount}条`;
+                    const sizeStr = (0, backup_1.formatFileSize)(resume.fileSize);
+                    const compactStr = resume.compactCount > 0 ? ` | ${resume.compactCount}次压缩` : '';
+                    console.log(`    ${connector}${chalk_1.default.cyan(`[${resume.sessionId}]`)} ${chalk_1.default.gray(timeRange)} | ${chalk_1.default.yellow(messagesStr)} | ${chalk_1.default.gray(sizeStr)}${chalk_1.default.magenta(compactStr)}`);
+                    // 添加到删除选项（默认选中无效项目的 resume）
+                    allResumeChoices.push({
+                        name: `${chalk_1.default.gray(projectPath)} - [${resume.sessionId}] (${(0, scanner_1.formatRelativeTime)(resume.lastActivity.getTime())})`,
+                        value: { projectPath, sessionId: resume.sessionId },
+                        checked: true,
+                    });
+                });
+                console.log();
+            }
+        }
+        // 打印无效项目（无 resume）
+        if ((filter === 'all' || filter === 'invalid') && invalidNoResume.length > 0) {
+            console.log(chalk_1.default.red.bold(`\n✗ 无效项目 - 无 resume (${invalidNoResume.length} 个):\n`));
+            for (const { projectPath } of invalidNoResume) {
+                console.log(`${chalk_1.default.red('✗')} ${chalk_1.default.gray(projectPath)} ${chalk_1.default.gray('(无 resume)')}`);
+            }
+            console.log();
+        }
+        // 打印孤立 resume（项目已删除但 resume 文件仍存在）
+        if ((filter === 'all' || filter === 'orphaned') && orphanedResumes.length > 0) {
+            console.log(chalk_1.default.yellow.bold(`\n⚠ 孤立 resume (${orphanedResumes.length} 个 - 项目已删除):\n`));
+            for (const { normalizedPath, resumes } of orphanedResumes) {
+                // 将 normalized path 转换回原始路径格式用于显示
+                const displayPath = normalizedPath.replace(/^-/, '/').replace(/-/g, '/');
+                console.log(`${chalk_1.default.yellow('⚠')} ${chalk_1.default.yellow.bold(displayPath)} ${chalk_1.default.gray(`(${resumes.length} 个 resume)`)}`);
+                resumes.forEach((resume, index) => {
+                    const isLast = index === resumes.length - 1;
+                    const connector = isLast ? '└── ' : '├── ';
+                    // 一行格式: [session-id] 创建时间→最后活动时间 | 消息数 | 磁盘大小 | 压缩次数
+                    const createdTime = (0, scanner_1.formatRelativeTime)(resume.createdAt.getTime());
+                    const lastActivityTime = (0, scanner_1.formatRelativeTime)(resume.lastActivity.getTime());
+                    const timeRange = `${createdTime} → ${lastActivityTime}`;
+                    const messagesStr = `${resume.messageCount}条`;
+                    const sizeStr = (0, backup_1.formatFileSize)(resume.fileSize);
+                    const compactStr = resume.compactCount > 0 ? ` | ${resume.compactCount}次压缩` : '';
+                    console.log(`    ${connector}${chalk_1.default.cyan(`[${resume.sessionId}]`)} ${chalk_1.default.gray(timeRange)} | ${chalk_1.default.yellow(messagesStr)} | ${chalk_1.default.gray(sizeStr)}${chalk_1.default.magenta(compactStr)}`);
+                    // 添加到删除选项（默认选中孤立 resume）
+                    allResumeChoices.push({
+                        name: `${chalk_1.default.yellow(displayPath)} - [${resume.sessionId}] (${(0, scanner_1.formatRelativeTime)(resume.lastActivity.getTime())})`,
+                        value: { projectPath: normalizedPath, sessionId: resume.sessionId, isOrphaned: true },
+                        checked: true,
+                    });
+                });
+                console.log();
+            }
+        }
+    }
+    // 汇总（只显示符合条件的）
+    const totalResumes = allProjects.reduce((sum, p) => sum + p.resumes.length, 0);
+    const totalOrphanedResumes = orphanedResumes.reduce((sum, r) => sum + r.resumes.length, 0);
+    const validResumeCount = validWithResume.reduce((sum, p) => sum + p.resumes.length, 0);
+    const invalidResumeCount = invalidWithResume.reduce((sum, p) => sum + p.resumes.length, 0);
+    console.log(chalk_1.default.bold('\nResume 汇总:'));
+    if (filter === 'all' || filter === 'valid') {
+        console.log(`  ${chalk_1.default.green('有效项目')}: ${validProjects.length} 个项目 (${validWithResume.length} 个有 resume, ${validNoResume.length} 个无 resume)`);
+    }
+    if (filter === 'all' || filter === 'invalid') {
+        console.log(`  ${chalk_1.default.red('无效项目')}: ${invalidProjects.length} 个项目 (${invalidWithResume.length} 个有 resume, ${invalidNoResume.length} 个无 resume)`);
+    }
+    if (filter === 'all' || filter === 'orphaned') {
+        console.log(`  ${chalk_1.default.yellow('孤立 resume')}: ${orphanedResumes.length} 个项目, ${totalOrphanedResumes} 个 resume`);
+    }
+    if (filter === 'all') {
+        console.log(`  总计: ${totalResumes + totalOrphanedResumes} 个 resume`);
+    }
+    // 如果允许删除，进入删除流程
+    // 注意：在删除模式下，allResumeChoices 可能为空（因为跳过了详细显示），需要单独检查
+    const hasResumesToDelete = validWithResume.length > 0 || invalidWithResume.length > 0 || orphanedResumes.length > 0;
+    if (allowDelete && hasResumesToDelete) {
+        // 按有效/无效/孤立分类显示项目列表（不含 resume 明细）
+        const projectChoices = [];
+        // 有效项目（默认不选中）
+        for (const { projectPath, resumes } of validWithResume) {
+            // 转换为标准化路径格式（与 .claude/projects 目录一致）
+            const normalizedPath = projectPath.replace(/\//g, '-');
+            projectChoices.push({
+                name: `${projectPath} (${resumes.length} 个 resume)`,
+                value: { projectPath: normalizedPath, isValid: true, isOrphaned: false, resumes },
+                checked: false,
+            });
+        }
+        // 无效项目（默认不选中，因为路径不存在但可能是误配置）
+        for (const { projectPath, resumes } of invalidWithResume) {
+            // 转换为标准化路径格式
+            const normalizedPath = projectPath.replace(/\//g, '-');
+            projectChoices.push({
+                name: `${projectPath} (${resumes.length} 个 resume)`,
+                value: { projectPath: normalizedPath, isValid: false, isOrphaned: false, resumes },
+                checked: false,
+            });
+        }
+        // 孤立项目（默认全选，因为项目已删除，resume 没有意义）
+        for (const { normalizedPath, resumes } of orphanedResumes) {
+            // 使用 .claude/projects 路径格式
+            const displayPath = `~/.claude/projects/${normalizedPath}`;
+            projectChoices.push({
+                name: `${displayPath} (${resumes.length} 个 resume)`,
+                value: { projectPath: normalizedPath, isValid: false, isOrphaned: true, resumes },
+                checked: true,
+            });
+        }
+        if (projectChoices.length === 0) {
+            console.log(chalk_1.default.yellow('\n没有包含 resume 的项目'));
+            return;
+        }
+        // 根据 filter 筛选可选项目
+        const filteredProjectChoices = projectChoices.filter(choice => {
+            if (filter === 'all')
+                return true;
+            if (filter === 'valid')
+                return choice.value.isValid && !choice.value.isOrphaned;
+            if (filter === 'invalid')
+                return !choice.value.isValid && !choice.value.isOrphaned;
+            if (filter === 'orphaned')
+                return choice.value.isOrphaned;
+            return true;
+        });
+        // 第一步：选择项目
+        console.log(chalk_1.default.bold('\n请选择要删除 resume 的项目：\n'));
+        // 根据项目类型生成带颜色的选项名称
+        const getProjectChoiceName = (c) => {
+            const statusIcon = c.value.isOrphaned ? '⚠' : c.value.isValid ? '✓' : '✗';
+            const statusColor = c.value.isOrphaned ? chalk_1.default.yellow : c.value.isValid ? chalk_1.default.green : chalk_1.default.red;
+            return `${statusColor(statusIcon)} ${c.name}`;
+        };
+        const selectedProjects = await (0, prompts_1.checkbox)({
+            message: '选择项目（空格选择，回车确认）:',
+            choices: filteredProjectChoices.map(c => ({
+                name: getProjectChoiceName(c),
+                value: c.value,
+                checked: c.checked,
+            })),
+            pageSize: 15,
+            theme: {
+                style: {
+                    keysHelpTip: () => undefined,
+                },
+            },
+        });
+        if (selectedProjects.length === 0) {
+            console.log(chalk_1.default.yellow('未选择任何项目，操作已取消'));
+            return;
+        }
+        // 收集所有选中项目的 resume
+        const allSelectedResumes = [];
+        for (const project of selectedProjects) {
+            for (const resume of project.resumes) {
+                allSelectedResumes.push({
+                    name: '', // 动态生成
+                    value: {
+                        projectPath: project.projectPath,
+                        sessionId: resume.sessionId,
+                        isOrphaned: project.isOrphaned,
+                        lastActivity: resume.lastActivity,
+                        messageCount: resume.messageCount,
+                        fileSize: resume.fileSize,
+                    },
+                    checked: true, // 默认全选
+                });
+            }
+        }
+        // 第二步：选择要删除的 resume
+        console.log(chalk_1.default.bold(`\n已选择 ${selectedProjects.length} 个项目，共 ${allSelectedResumes.length} 个 resume，请选择要删除的：\n`));
+        // 根据 resume 所属项目的类型生成带颜色的选项名称（完整路径 + 详细信息）
+        const getResumeChoiceName = (c) => {
+            const statusIcon = c.value.isOrphaned ? '⚠' : '✓';
+            const statusColor = c.value.isOrphaned ? chalk_1.default.yellow : chalk_1.default.green;
+            // 统一使用 .claude/projects 路径格式
+            const displayPath = `~/.claude/projects/${c.value.projectPath}`;
+            // 显示详细信息
+            const timeStr = c.value.lastActivity ? (0, scanner_1.formatRelativeTime)(c.value.lastActivity.getTime()) : 'N/A';
+            const msgStr = c.value.messageCount !== undefined ? `${c.value.messageCount}条` : 'N/A';
+            const sizeStr = c.value.fileSize ? (0, backup_1.formatFileSize)(c.value.fileSize) : 'N/A';
+            // 在一行内显示完整信息，不截断
+            return `${statusColor(statusIcon)} ${displayPath} | ${chalk_1.default.cyan(c.value.sessionId)} | ${timeStr} | ${msgStr} | ${sizeStr}`;
+        };
+        const selectedResumes = await (0, prompts_1.checkbox)({
+            message: '选择要删除的 resume（空格选择，回车确认，全选请按 a）:',
+            choices: allSelectedResumes.map(c => ({
+                name: getResumeChoiceName(c),
+                value: c.value,
+                checked: c.checked,
+            })),
+            pageSize: 15,
+            theme: {
+                style: {
+                    keysHelpTip: () => undefined,
+                },
+            },
+        });
+        if (selectedResumes.length === 0) {
+            console.log(chalk_1.default.yellow('未选择任何 resume，操作已取消'));
+            return;
+        }
+        // 第三步：确认删除
+        const confirmed = await (0, prompts_1.confirm)({
+            message: chalk_1.default.red(`确认删除选中的 ${selectedResumes.length} 个 resume？`),
+            default: false,
+        });
+        if (!confirmed) {
+            console.log(chalk_1.default.yellow('操作已取消'));
+            return;
+        }
+        // 执行删除
+        const deleteByProject = new Map();
+        for (const { projectPath, sessionId } of selectedResumes) {
+            const set = deleteByProject.get(projectPath) || new Set();
+            set.add(sessionId);
+            deleteByProject.set(projectPath, set);
+        }
+        let totalDeleted = 0;
+        for (const [projectPath, sessionIds] of deleteByProject) {
+            const deleted = await (0, scanner_1.deleteProjectResumes)(projectPath, sessionIds);
+            totalDeleted += deleted;
+        }
+        console.log(chalk_1.default.green(`\n✓ 成功删除 ${totalDeleted} 个 resume！`));
+    }
+}
+const version = '1.0.0';
+// ============================================================
+// 主程序配置
+// ============================================================
+commander_1.program
+    .name('lcch')
+    .description('Claude Code Helper - 管理 Claude Code 配置的 CLI 工具')
+    .version(version, '--version', '显示版本号')
+    .usage('<command> [options]')
+    .addHelpText('after', `
+${chalk_1.default.bold('常用命令:')}
+
+  ${chalk_1.default.bold('项目管理:')}
+    ${chalk_1.default.cyan('lcch projects list')}              列出所有项目
+    ${chalk_1.default.cyan('lcch projects list --tree')}      树形结构显示项目
+    ${chalk_1.default.cyan('lcch projects list --verbose')}   显示详细统计信息
+    ${chalk_1.default.cyan('lcch projects list --sessions')}  显示会话历史
+    ${chalk_1.default.cyan('lcch projects list --resume')}    显示 resume 历史
+    ${chalk_1.default.cyan('lcch projects clean')}            交互式清理无效项目
+    ${chalk_1.default.cyan('lcch projects clean --force')}    强制清理无效项目
+    ${chalk_1.default.cyan('lcch project <path>')}            查看单个项目信息
+    ${chalk_1.default.cyan('lcch project <path> --resume')}   查看项目 resume 历史
+
+  ${chalk_1.default.bold('备份管理:')}
+    ${chalk_1.default.cyan('lcch backup_config list')}        列出所有备份（按类型分组）
+    ${chalk_1.default.cyan('lcch backup_config create')}      交互式创建备份（默认备份全部）
+    ${chalk_1.default.cyan('lcch backup_config restore')}     恢复备份
+    ${chalk_1.default.cyan('lcch backup_config delete')}      删除备份
+
+  ${chalk_1.default.bold('缓存和安全:')}
+    ${chalk_1.default.cyan('lcch cache')}                     查看缓存信息
+    ${chalk_1.default.cyan('lcch cache --json')}             以 JSON 格式输出
+    ${chalk_1.default.cyan('lcch scan-secrets')}             扫描缓存中的密钥
+    ${chalk_1.default.cyan('lcch scan-secrets --show')}      显示完整密钥
+    ${chalk_1.default.cyan('lcch scan-secrets --mask')}      扫描并掩码项目中的敏感信息
+    ${chalk_1.default.cyan('lcch scan-secrets --mask --restore <项目目录>')} 恢复项目所有备份
+
+  ${chalk_1.default.bold('配置信息:')}
+    ${chalk_1.default.cyan('lcch config path')}               显示配置文件路径
+    ${chalk_1.default.cyan('lcch config stats')}              显示详细统计信息
+
+  ${chalk_1.default.bold('MCP 和 Hooks:')}
+    ${chalk_1.default.cyan('lcch mcp list')}                  列出 MCP 服务器
+    ${chalk_1.default.cyan('lcch mcp info')}                  查看 MCP 服务器详细配置（交互式）
+    ${chalk_1.default.cyan('lcch hooks list')}                列出 hooks
+
+${chalk_1.default.bold('查看子命令帮助:')}
+    ${chalk_1.default.cyan('lcch projects -h')}               查看 projects 命令帮助
+    ${chalk_1.default.cyan('lcch projects list -h')}          查看 list 子命令帮助
+    ${chalk_1.default.cyan('lcch project -h')}                查看 project 命令帮助
+    ${chalk_1.default.cyan('lcch backup_config -h')}          查看 backup_config 命令帮助
+    ${chalk_1.default.cyan('lcch cache -h')}                  查看 cache 命令帮助
+`);
+// ============================================================
+// projects 子命令 - 项目管理
+// ============================================================
+const projectsCmd = commander_1.program
+    .command('projects')
+    .description('管理 Claude Code 项目')
+    .addHelpText('after', `
+${chalk_1.default.bold('子命令:')}
+  ${chalk_1.default.cyan('list [options]')}    列出所有项目
+  ${chalk_1.default.cyan('clean [options]')}   清理无效项目
+  ${chalk_1.default.cyan('export [options]')}  导出项目会话
+
+${chalk_1.default.bold('常用示例:')}
+  ${chalk_1.default.cyan('lcch projects list')}                      列出所有项目
+  ${chalk_1.default.cyan('lcch projects list --tree')}              树形结构显示
+  ${chalk_1.default.cyan('lcch projects list --tree-verbose')}      树形显示详细统计
+  ${chalk_1.default.cyan('lcch projects list --verbose')}           列表显示详细统计
+  ${chalk_1.default.cyan('lcch projects list --sessions')}          显示会话历史
+  ${chalk_1.default.cyan('lcch projects list --sessions --filter orphaned')}  只显示孤立会话
+  ${chalk_1.default.cyan('lcch projects list --resume')}            显示 resume 历史
+  ${chalk_1.default.cyan('lcch projects list --resume --filter invalid')}    只显示无效项目的 resume
+  ${chalk_1.default.cyan('lcch projects list --resume --delete-resumes')}  删除 resume
+  ${chalk_1.default.cyan('lcch projects clean')}                    交互式清理
+  ${chalk_1.default.cyan('lcch projects clean --all')}              清理所有无效项目
+  ${chalk_1.default.cyan('lcch projects clean --force')}            强制清理（不确认）
+  ${chalk_1.default.cyan('lcch projects export')}                   交互式导出会话
+  ${chalk_1.default.cyan('lcch projects export --format json')}     导出为 JSON
+  ${chalk_1.default.cyan('lcch projects export --format markdown')} 导出为 Markdown
+  ${chalk_1.default.cyan('lcch projects export --format html')}     导出为 HTML 交互式
+  ${chalk_1.default.cyan('lcch projects export --output-dir ./exports')} 指定输出目录
+`);
+// lcch projects list - 列出所有项目
+projectsCmd
+    .command('list')
+    .description('列出所有项目')
+    .option('--tree', '以树形结构显示', false)
+    .option('--sessions', '显示每个项目的会话历史', false)
+    .option('--resume', '显示每个项目的 resume 历史', false)
+    .option('--delete-resumes', '删除选中的 resume（需配合 --resume 使用）', false)
+    .option('--tree-verbose', '以树形结构显示，并显示详细统计信息', false)
+    .option('--verbose', '以列表形式显示详细统计信息', false)
+    .option('--filter <type>', '过滤类型：valid(有效)|invalid(无效)|orphaned(孤立)|all(全部)', 'all')
+    .action(async (options) => {
+    try {
+        const config = await (0, scanner_1.readConfig)();
+        const result = await (0, scanner_1.scanProjects)(config);
+        // 验证 filter 参数
+        const validFilters = ['valid', 'invalid', 'orphaned', 'all'];
+        if (!validFilters.includes(options.filter)) {
+            console.error(chalk_1.default.red(`错误: --filter 参数必须是其中之一: ${validFilters.join(', ')}`));
+            process.exit(1);
+        }
+        if (options.sessions) {
+            // 显示会话历史
+            await printProjectSessions(config, result, options.filter);
+            return;
+        }
+        if (options.resume) {
+            // 显示 resume 历史
+            await printProjectResumes(config, result, options.deleteResumes, options.filter);
+            return;
+        }
+        if (options.tree) {
+            // 树形结构显示
+            console.log(chalk_1.default.bold(`\n共 ${result.totalCount} 个项目:\n`));
+            const allProjects = [...result.validProjects, ...result.invalidProjects];
+            const tree = (0, scanner_1.buildProjectTree)(allProjects);
+            const validSet = new Set(result.validProjects);
+            const invalidSet = new Set(result.invalidProjects);
+            (0, scanner_1.printProjectTree)(tree, '', true, validSet, invalidSet);
+            console.log();
+            printSummary(result);
+            return;
+        }
+        if (options.treeVerbose) {
+            // 树形结构显示（详细信息）
+            await printProjectTreeVerbose(config, result);
+            return;
+        }
+        if (options.verbose) {
+            // 列表显示（详细信息）
+            await printProjectListVerbose(config, result);
+            return;
+        }
+        console.log(chalk_1.default.bold(`\n共 ${result.totalCount} 个项目:\n`));
+        // 显示有效项目
+        if (result.validProjects.length > 0) {
+            console.log(chalk_1.default.green.bold('有效项目:'));
+            for (const projectPath of result.validProjects) {
+                const info = (0, scanner_1.getProjectInfo)(config, projectPath);
+                console.log(`  ${chalk_1.default.green('✓')} ${projectPath}`);
+            }
+            console.log();
+        }
+        // 显示无效项目
+        if (result.invalidProjects.length > 0) {
+            console.log(chalk_1.default.red.bold('无效项目（路径不存在）:'));
+            for (const projectPath of result.invalidProjects) {
+                const info = (0, scanner_1.getProjectInfo)(config, projectPath);
+                console.log(`  ${chalk_1.default.red('✗')} ${projectPath}`);
+            }
+            console.log();
+        }
+        printSummary(result);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// lcch projects clean - 清理无效项目
+projectsCmd
+    .command('clean')
+    .description('清理无效项目')
+    .option('--force', '强制清理，不提示确认', false)
+    .option('--all', '清理所有无效项目（默认行为）', false)
+    .action(async (options) => {
+    try {
+        const config = await (0, scanner_1.readConfig)();
+        const result = await (0, scanner_1.scanProjects)(config);
+        if (result.invalidProjects.length === 0) {
+            console.log(chalk_1.default.green('没有发现无效项目，无需清理！'));
+            return;
+        }
+        printScanResult(result);
+        let projectsToDelete;
+        if (options.force) {
+            // 强制模式：直接删除所有无效项目
+            projectsToDelete = result.invalidProjects;
+        }
+        else if (options.all) {
+            // 删除所有，但需要确认
+            projectsToDelete = result.invalidProjects;
+            const { confirm } = await inquirer_1.default.prompt([{
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: chalk_1.default.red(`确认删除所有 ${projectsToDelete.length} 个无效项目？`),
+                    default: false,
+                }]);
+            if (!confirm) {
+                console.log(chalk_1.default.yellow('操作已取消'));
+                return;
+            }
+        }
+        else {
+            // 交互式选择要删除的项目
+            const selectedProjects = await (0, prompts_1.checkbox)({
+                message: '选择要删除的无效项目（空格选择，回车确认，a 全选）:',
+                choices: result.invalidProjects.map(p => ({
+                    name: p,
+                    value: p,
+                    checked: false,
+                })),
+                pageSize: 20,
+                theme: {
+                    style: {
+                        keysHelpTip: () => undefined,
+                    },
+                },
+            });
+            if (selectedProjects.length === 0) {
+                console.log(chalk_1.default.yellow('未选择任何项目，操作已取消'));
+                return;
+            }
+            projectsToDelete = selectedProjects;
+            // 确认删除
+            const { confirm } = await inquirer_1.default.prompt([{
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: chalk_1.default.red(`确认删除选中的 ${projectsToDelete.length} 个项目？`),
+                    default: false,
+                }]);
+            if (!confirm) {
+                console.log(chalk_1.default.yellow('操作已取消'));
+                return;
+            }
+        }
+        // 创建备份
+        const backupPath = await (0, backup_1.createBackup)('config');
+        console.log(chalk_1.default.green(`\n✓ 已创建备份: ${path.basename(backupPath)}`));
+        console.log(chalk_1.default.gray(`  恢复命令: lcch backup_config restore ${path.basename(backupPath)}`));
+        // 执行删除
+        (0, scanner_1.removeProjects)(config, projectsToDelete);
+        await (0, scanner_1.writeConfig)(config);
+        console.log(chalk_1.default.green(`✓ 成功清理 ${projectsToDelete.length} 个项目！`));
+        console.log(chalk_1.default.gray(`  恢复命令: lcch backup_config restore ${path.basename(backupPath)}`));
+        console.log(chalk_1.default.gray(`  剩余 ${result.totalCount - projectsToDelete.length} 个项目`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// lcch projects export - 导出项目会话
+projectsCmd
+    .command('export')
+    .description('导出项目会话')
+    .option('--format <format>', '导出格式 (json|markdown|html)', '')
+    .option('--output-dir <dir>', '输出目录', '')
+    .action(async (options) => {
+    try {
+        const config = await (0, scanner_1.readConfig)();
+        const result = await (0, scanner_1.scanProjects)(config);
+        if (result.validProjects.length === 0) {
+            console.log(chalk_1.default.yellow('没有发现有效项目'));
+            return;
+        }
+        // 检查哪些项目有 resume 数据
+        const projectsWithSessions = [];
+        for (const projectPath of result.validProjects) {
+            const sessions = await (0, export_1.readProjectSessions)(projectPath);
+            if (sessions.length > 0) {
+                projectsWithSessions.push(projectPath);
+            }
+        }
+        if (projectsWithSessions.length === 0) {
+            console.log(chalk_1.default.yellow('没有找到任何项目的会话数据'));
+            return;
+        }
+        console.log(chalk_1.default.bold(`\n发现 ${projectsWithSessions.length} 个项目有会话数据:\n`));
+        // 选择要导出的项目
+        const selectedProjects = await (0, prompts_1.checkbox)({
+            message: '选择要导出会话的项目（空格选择，回车确认）:',
+            choices: projectsWithSessions.map(p => ({
+                name: `${path.basename(p)} ${chalk_1.default.gray(p)}`,
+                value: p,
+                checked: false,
+            })),
+            pageSize: 20,
+            theme: {
+                style: {
+                    keysHelpTip: () => undefined,
+                },
+            },
+        });
+        if (selectedProjects.length === 0) {
+            console.log(chalk_1.default.yellow('\n未选择任何项目，操作已取消'));
+            return;
+        }
+        // 保存项目到会话ID列表的映射
+        const projectSessionsMap = new Map();
+        const allSessions = [];
+        for (const projectPath of selectedProjects) {
+            const resumeInfos = await (0, scanner_1.getProjectResumeInfo)(projectPath);
+            const sessionIds = [];
+            for (const info of resumeInfos) {
+                sessionIds.push(info.sessionId);
+                allSessions.push({
+                    projectPath,
+                    sessionId: info.sessionId,
+                    label: `${path.basename(projectPath)} | ${info.sessionId.substring(0, 8)}... | ${info.messageCount} 条消息 | ${(0, scanner_1.formatRelativeTime)(info.lastActivity.getTime())}`,
+                    messageCount: info.messageCount,
+                });
+            }
+            projectSessionsMap.set(projectPath, sessionIds);
+        }
+        // 选择要导出的会话
+        let exportOptions = { sessions: [], roles: [], contentTypes: [] };
+        if (allSessions.length > 0) {
+            console.log(chalk_1.default.bold(`\n共发现 ${allSessions.length} 个会话\n`));
+            const selectedSessions = await (0, prompts_1.checkbox)({
+                message: '选择要导出的会话（空格选择，回车确认）:',
+                choices: allSessions.map(s => ({
+                    name: s.label,
+                    value: `${s.projectPath}|${s.sessionId}`, // 使用项目路径+会话ID作为唯一值
+                    checked: true, // 默认全选
+                })),
+                pageSize: 20,
+                theme: {
+                    style: {
+                        keysHelpTip: () => undefined,
+                    },
+                },
+            });
+            // 解析选中的会话，按项目分组
+            const selectedProjectSessions = new Map();
+            for (const value of selectedSessions) {
+                const [projectPath, sessionId] = value.split('|');
+                if (!selectedProjectSessions.has(projectPath)) {
+                    selectedProjectSessions.set(projectPath, []);
+                }
+                selectedProjectSessions.get(projectPath).push(sessionId);
+            }
+            // 保存到导出选项中（后续会根据项目路径取对应的会话ID）
+            // 这里我们直接存储到临时变量中，稍后在导出时使用
+            exportOptions.projectSessionsMap = selectedProjectSessions;
+        }
+        // 选择要导出的角色
+        const selectedRoles = await (0, prompts_1.checkbox)({
+            message: '选择要导出的角色:',
+            choices: [
+                { name: '用户 (user)', value: 'user', checked: true },
+                { name: '助手 (assistant)', value: 'assistant', checked: true },
+            ],
+            pageSize: 10,
+            theme: {
+                style: {
+                    keysHelpTip: () => undefined,
+                },
+            },
+        });
+        exportOptions.roles = selectedRoles;
+        // 选择要导出的内容类型
+        const contentTypeChoices = [
+            { name: '文本内容', value: 'text', checked: true },
+            { name: '工具调用请求 (tool_use)', value: 'tool_use', checked: true },
+            { name: '工具执行结果 (tool_result)', value: 'tool_result', checked: true },
+            { name: '思考过程 (thinking)', value: 'thinking', checked: true },
+        ];
+        const selectedContentTypes = await (0, prompts_1.checkbox)({
+            message: '选择要导出的内容类型:',
+            choices: contentTypeChoices,
+            pageSize: 10,
+            theme: {
+                style: {
+                    keysHelpTip: () => undefined,
+                },
+            },
+        });
+        exportOptions.contentTypes = selectedContentTypes;
+        // 选择导出格式
+        let exportFormat;
+        const validFormats = ['json', 'markdown', 'html', 'text'];
+        if (validFormats.includes(options.format)) {
+            exportFormat = options.format;
+        }
+        else {
+            const { format } = await inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'format',
+                    message: '选择导出格式:',
+                    choices: [
+                        { name: 'JSON', value: 'json' },
+                        { name: 'Markdown', value: 'markdown' },
+                        { name: 'HTML 交互式', value: 'html' },
+                        { name: '纯文本', value: 'text' },
+                    ],
+                }]);
+            exportFormat = format;
+        }
+        // 选择输出目录
+        let outputDir;
+        if (options.outputDir) {
+            outputDir = options.outputDir;
+        }
+        else {
+            const defaultDir = (0, export_1.getDefaultOutputDir)();
+            const { dir } = await inquirer_1.default.prompt([{
+                    type: 'input',
+                    name: 'dir',
+                    message: '输入输出目录:',
+                    default: defaultDir,
+                }]);
+            outputDir = dir;
+        }
+        // 确保输出目录存在
+        await fs.ensureDir(outputDir);
+        // 确认导出
+        const formatNameMap = {
+            json: 'JSON',
+            markdown: 'Markdown',
+            html: 'HTML 交互式',
+        };
+        const formatName = formatNameMap[exportFormat] || exportFormat;
+        console.log(chalk_1.default.bold(`\n导出信息:`));
+        console.log(`  选中项目: ${selectedProjects.length} 个`);
+        console.log(`  导出格式: ${formatName}`);
+        console.log(`  输出目录: ${outputDir}`);
+        const { confirm } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'confirm',
+                message: '\n确认导出?',
+                default: true,
+            }]);
+        if (!confirm) {
+            console.log(chalk_1.default.yellow('操作已取消'));
+            return;
+        }
+        // 执行导出
+        console.log(chalk_1.default.bold('\n正在导出...\n'));
+        const exportResults = [];
+        const usedNames = new Set();
+        for (const projectPath of selectedProjects) {
+            // 为当前项目获取对应的会话ID
+            let projectSessionIds = [];
+            // 检查是否选择了会话
+            const projectSessionsMap = exportOptions.projectSessionsMap;
+            if (projectSessionsMap && projectSessionsMap.has(projectPath)) {
+                // 用户选择了具体会话
+                projectSessionIds = projectSessionsMap.get(projectPath) || [];
+            }
+            // 如果 projectSessionIds 为空数组，则表示导出全部会话（由 filterSessions 函数处理）
+            const result = await (0, export_1.exportProjectSessions)(projectPath, exportFormat, outputDir, usedNames, { ...exportOptions, sessions: projectSessionIds });
+            if (result) {
+                exportResults.push(result);
+                console.log(`${chalk_1.default.green('✓')} ${path.basename(projectPath)} → ${chalk_1.default.cyan(result.fileName)}`);
+                console.log(`  ${chalk_1.default.gray(`${result.sessionCount} 个会话, ${result.messageCount} 条消息`)}`);
+            }
+            else {
+                console.log(`${chalk_1.default.yellow('⚠')} ${path.basename(projectPath)} ${chalk_1.default.gray('(无会话数据)')}`);
+            }
+        }
+        // 显示导出结果
+        if (exportResults.length > 0) {
+            console.log(chalk_1.default.green(`\n✓ 成功导出 ${exportResults.length} 个项目!\n`));
+            console.log(chalk_1.default.bold('导出文件:'));
+            for (const result of exportResults) {
+                console.log(`  ${chalk_1.default.cyan(result.fileName)}`);
+                console.log(`    ${chalk_1.default.gray(result.projectPath)}`);
+            }
+            console.log(chalk_1.default.gray(`\n输出目录: ${outputDir}`));
+        }
+        else {
+            console.log(chalk_1.default.yellow('\n没有成功导出任何项目'));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// ============================================================
+// backup 子命令 - 备份管理
+// ============================================================
+const backupCmd = commander_1.program
+    .command('backup_config')
+    .description('管理 Claude Code 配置备份')
+    .addHelpText('after', `
+${chalk_1.default.bold('子命令:')}
+  ${chalk_1.default.cyan('list')}              列出所有备份文件（按类型分组）
+  ${chalk_1.default.cyan('create')}            交互式创建配置备份（默认备份 .claude.json 和 settings.json）
+  ${chalk_1.default.cyan('restore [file]')}    恢复配置备份
+  ${chalk_1.default.cyan('delete [file]')}     删除备份文件
+
+${chalk_1.default.bold('常用示例:')}
+  ${chalk_1.default.cyan('lcch backup_config list')}              列出所有备份
+  ${chalk_1.default.cyan('lcch backup_config create')}            交互式选择创建备份
+  ${chalk_1.default.cyan('lcch backup_config create --target config')}  只备份 .claude.json
+  ${chalk_1.default.cyan('lcch backup_config restore')}           交互式选择恢复
+  ${chalk_1.default.cyan('lcch backup_config restore <file>')}    直接恢复指定备份
+  ${chalk_1.default.cyan('lcch backup_config delete')}            交互式选择删除
+  ${chalk_1.default.cyan('lcch backup_config delete <file>')}     直接删除指定备份
+`);
+// lcch backup_config list - 列出备份
+backupCmd
+    .command('list')
+    .description('列出所有备份文件')
+    .option('--target <target>', '只显示指定类型的备份 (config|settings)')
+    .action(async (options) => {
+    try {
+        let backups = await (0, backup_1.listBackups)();
+        if (options.target) {
+            if (options.target !== 'config' && options.target !== 'settings') {
+                console.error(chalk_1.default.red('错误: --target 必须是 config 或 settings'));
+                process.exit(1);
+            }
+            backups = backups.filter(b => b.target === options.target);
+        }
+        if (backups.length === 0) {
+            console.log(chalk_1.default.yellow('没有找到备份文件'));
+            return;
+        }
+        // 按类型分组
+        const configBackups = backups.filter(b => b.target === 'config');
+        const settingsBackups = backups.filter(b => b.target === 'settings');
+        if (configBackups.length > 0) {
+            console.log(chalk_1.default.bold(`\n.claude.json 备份 (${configBackups.length}个):`));
+            configBackups.forEach((backup, index) => {
+                const isAuto = backup.filename.includes('backup_auto_before_restore');
+                console.log(`  ${index + 1}. ${chalk_1.default.cyan(backup.filename)}${isAuto ? chalk_1.default.gray(' (自动备份)') : ''}`);
+                console.log(`     ${chalk_1.default.gray('时间:')} ${(0, scanner_1.formatDate)(backup.createdAt)}  ${chalk_1.default.gray('大小:')} ${(0, backup_1.formatFileSize)(backup.size)}`);
+            });
+        }
+        if (settingsBackups.length > 0) {
+            console.log(chalk_1.default.bold(`\nsettings.json 备份 (${settingsBackups.length}个):`));
+            settingsBackups.forEach((backup, index) => {
+                const isAuto = backup.filename.includes('backup_auto_before_restore');
+                console.log(`  ${index + 1}. ${chalk_1.default.cyan(backup.filename)}${isAuto ? chalk_1.default.gray(' (自动备份)') : ''}`);
+                console.log(`     ${chalk_1.default.gray('时间:')} ${(0, scanner_1.formatDate)(backup.createdAt)}  ${chalk_1.default.gray('大小:')} ${(0, backup_1.formatFileSize)(backup.size)}`);
+            });
+        }
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// lcch backup_config create - 创建备份
+backupCmd
+    .command('create')
+    .description('手动创建配置备份')
+    .option('--target <target>', '指定备份目标 (config|settings)')
+    .action(async (options) => {
+    try {
+        let targets = [];
+        if (options.target) {
+            if (options.target !== 'config' && options.target !== 'settings') {
+                console.error(chalk_1.default.red('错误: --target 必须是 config 或 settings'));
+                process.exit(1);
+            }
+            targets = [options.target];
+        }
+        else {
+            // 交互式多选
+            const { selectedTargets } = await inquirer_1.default.prompt([{
+                    type: 'checkbox',
+                    name: 'selectedTargets',
+                    message: '选择要备份的文件（空格选择，回车确认）:',
+                    choices: [
+                        { name: '~/.claude.json', value: 'config', checked: true },
+                        { name: '~/.claude/settings.json', value: 'settings', checked: true },
+                    ],
+                }]);
+            if (selectedTargets.length === 0) {
+                console.log(chalk_1.default.yellow('未选择任何文件，操作已取消'));
+                return;
+            }
+            targets = selectedTargets;
+        }
+        for (const target of targets) {
+            const label = target === 'config' ? '.claude.json' : 'settings.json';
+            const spinner = createSpinner(`正在备份 ${label}...`);
+            spinner.start();
+            const backupPath = await (0, backup_1.createBackup)(target);
+            spinner.stop();
+            console.log(chalk_1.default.green(`✓ 备份已创建: ${path.basename(backupPath)}`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// lcch backup_config restore - 恢复备份
+backupCmd
+    .command('restore [file]')
+    .description('恢复配置备份')
+    .option('--force', '强制恢复，不提示确认', false)
+    .action(async (file, options) => {
+    try {
+        let backupPath;
+        if (file) {
+            // 使用指定的文件
+            if (path.isAbsolute(file)) {
+                backupPath = file;
+            }
+            else {
+                // 通过文件名前缀推断目录
+                let backupDir;
+                if (file.startsWith('.claude.json.')) {
+                    backupDir = path.join(os.homedir(), '.lcch', 'backups', 'config');
+                }
+                else if (file.startsWith('settings.json.')) {
+                    backupDir = path.join(os.homedir(), '.lcch', 'backups', 'settings');
+                }
+                else {
+                    console.error(chalk_1.default.red('错误: 无法识别的备份文件名'));
+                    process.exit(1);
+                }
+                backupPath = path.join(backupDir, file);
+            }
+        }
+        else {
+            // 交互式选择
+            const backups = await (0, backup_1.listBackups)();
+            if (backups.length === 0) {
+                console.log(chalk_1.default.yellow('没有找到备份文件'));
+                return;
+            }
+            const { selectedBackup } = await inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'selectedBackup',
+                    message: '选择要恢复的备份:',
+                    choices: backups.map(b => ({
+                        name: `${b.filename} (${b.target === 'config' ? '主配置' : 'Settings'}, ${(0, scanner_1.formatDate)(b.createdAt)}, ${(0, backup_1.formatFileSize)(b.size)})`,
+                        value: b.path,
+                    })),
+                }]);
+            backupPath = selectedBackup;
+        }
+        if (!await fs.pathExists(backupPath)) {
+            console.error(chalk_1.default.red(`备份文件不存在: ${backupPath}`));
+            process.exit(1);
+        }
+        if (!options.force) {
+            const { confirmRestore } = await inquirer_1.default.prompt([{
+                    type: 'confirm',
+                    name: 'confirmRestore',
+                    message: chalk_1.default.yellow(`确认从 ${path.basename(backupPath)} 恢复配置？`),
+                    default: false,
+                }]);
+            if (!confirmRestore) {
+                console.log(chalk_1.default.yellow('操作已取消'));
+                return;
+            }
+        }
+        await (0, backup_1.restoreBackup)(backupPath);
+        const filename = path.basename(backupPath);
+        const targetLabel = filename.startsWith('.claude.json.') ? '.claude.json' : 'settings.json';
+        console.log(chalk_1.default.green(`✓ ${targetLabel} 配置已成功恢复！`));
+        console.log(chalk_1.default.gray(`  恢复前已创建自动备份（覆盖旧备份）`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// lcch backup_config delete - 删除备份
+backupCmd
+    .command('delete [file]')
+    .description('删除备份文件')
+    .action(async (file) => {
+    try {
+        if (file) {
+            let backupPath;
+            if (path.isAbsolute(file)) {
+                backupPath = file;
+            }
+            else {
+                // 通过文件名前缀推断目录
+                let backupDir;
+                if (file.startsWith('.claude.json.')) {
+                    backupDir = path.join(os.homedir(), '.lcch', 'backups', 'config');
+                }
+                else if (file.startsWith('settings.json.')) {
+                    backupDir = path.join(os.homedir(), '.lcch', 'backups', 'settings');
+                }
+                else {
+                    console.error(chalk_1.default.red('错误: 无法识别的备份文件名'));
+                    process.exit(1);
+                }
+                backupPath = path.join(backupDir, file);
+            }
+            const { confirmDelete } = await inquirer_1.default.prompt([{
+                    type: 'confirm',
+                    name: 'confirmDelete',
+                    message: `确认删除 ${path.basename(backupPath)}？`,
+                    default: false,
+                }]);
+            if (!confirmDelete) {
+                console.log(chalk_1.default.yellow('操作已取消'));
+                return;
+            }
+            await (0, backup_1.deleteBackup)(backupPath);
+            console.log(chalk_1.default.green('✓ 备份已删除'));
+        }
+        else {
+            // 交互式选择多个，按类型分组
+            const backups = await (0, backup_1.listBackups)();
+            if (backups.length === 0) {
+                console.log(chalk_1.default.yellow('没有找到备份文件'));
+                return;
+            }
+            const configBackups = backups.filter(b => b.target === 'config');
+            const settingsBackups = backups.filter(b => b.target === 'settings');
+            const choices = [];
+            if (configBackups.length > 0) {
+                choices.push(new prompts_1.Separator('.claude.json 备份:'));
+                choices.push(...configBackups.map(b => ({
+                    name: `${b.filename} (${(0, scanner_1.formatDate)(b.createdAt)})`,
+                    value: b.path,
+                })));
+            }
+            if (settingsBackups.length > 0) {
+                choices.push(new prompts_1.Separator('settings.json 备份:'));
+                choices.push(...settingsBackups.map(b => ({
+                    name: `${b.filename} (${(0, scanner_1.formatDate)(b.createdAt)})`,
+                    value: b.path,
+                })));
+            }
+            const selectedBackups = await (0, prompts_1.checkbox)({
+                message: '选择要删除的备份（空格选择，回车确认）:',
+                choices,
+                theme: {
+                    style: {
+                        keysHelpTip: () => undefined,
+                    },
+                },
+            });
+            if (selectedBackups.length === 0) {
+                console.log(chalk_1.default.yellow('未选择任何备份'));
+                return;
+            }
+            const confirmedDelete = await (0, prompts_1.confirm)({
+                message: chalk_1.default.red(`确认删除选中的 ${selectedBackups.length} 个备份？`),
+                default: false,
+            });
+            if (!confirmedDelete) {
+                console.log(chalk_1.default.yellow('操作已取消'));
+                return;
+            }
+            for (const bp of selectedBackups) {
+                await (0, backup_1.deleteBackup)(bp);
+            }
+            console.log(chalk_1.default.green(`✓ 已删除 ${selectedBackups.length} 个备份`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// ============================================================
+// hooks 子命令 - Hooks 管理
+// ============================================================
+const hooksCmd = commander_1.program
+    .command('hooks')
+    .description('管理 Claude Code Hooks')
+    .addHelpText('after', `
+${chalk_1.default.bold('子命令:')}
+  ${chalk_1.default.cyan('list')}    列出所有 hooks
+
+${chalk_1.default.bold('示例:')}
+  ${chalk_1.default.cyan('lcch hooks list')}    列出所有 hooks（按全局/项目级分类）
+`);
+// lcch hooks list - 列出所有 hooks
+hooksCmd
+    .command('list')
+    .description('列出所有 hooks')
+    .action(async () => {
+    try {
+        const config = await (0, scanner_1.readConfig)();
+        const hooks = await (0, scanner_1.getAllHooksWithScope)(config);
+        if (hooks.length === 0) {
+            console.log(chalk_1.default.yellow('\n没有找到任何 hooks'));
+            return;
+        }
+        const { global, project } = (0, scanner_1.groupHooksByScope)(hooks);
+        console.log(chalk_1.default.bold(`\n共 ${hooks.length} 个 hooks:\n`));
+        // 显示全局 hooks
+        if (global.length > 0) {
+            const globalByEvent = new Map();
+            for (const hook of global) {
+                const list = globalByEvent.get(hook.event) || [];
+                list.push(hook);
+                globalByEvent.set(hook.event, list);
+            }
+            console.log(chalk_1.default.blue.bold('🌍 全局 Hooks:\n'));
+            for (const [event, eventHooks] of globalByEvent) {
+                console.log(chalk_1.default.blue.bold(`  📌 ${event}`));
+                console.log(chalk_1.default.gray(`     (${eventHooks.length} 个 hook)\n`));
+                for (let i = 0; i < eventHooks.length; i++) {
+                    const hook = eventHooks[i];
+                    const isLast = i === eventHooks.length - 1;
+                    const connector = isLast ? '└── ' : '├── ';
+                    console.log(`     ${connector}${chalk_1.default.cyan(`[${hook.type}]`)}`);
+                    if (hook.matcher) {
+                        console.log(`         ${chalk_1.default.gray('匹配器:')} ${hook.matcher}`);
+                    }
+                    if (hook.command) {
+                        console.log(`         ${chalk_1.default.gray('命令:')} ${hook.command}`);
+                    }
+                }
+                console.log();
+            }
+        }
+        // 显示项目级 hooks
+        if (project.size > 0) {
+            console.log(chalk_1.default.green.bold('📁 项目级 Hooks:\n'));
+            for (const [projectPath, projectHooks] of project) {
+                const projectHooksByEvent = new Map();
+                for (const hook of projectHooks) {
+                    const list = projectHooksByEvent.get(hook.event) || [];
+                    list.push(hook);
+                    projectHooksByEvent.set(hook.event, list);
+                }
+                console.log(chalk_1.default.green(`  ✓ ${chalk_1.default.bold(projectPath)}`));
+                console.log(chalk_1.default.gray(`    (${projectHooks.length} 个 hook)\n`));
+                for (const [event, eventHooks] of projectHooksByEvent) {
+                    console.log(chalk_1.default.blue.bold(`    📌 ${event}`));
+                    console.log(chalk_1.default.gray(`       (${eventHooks.length} 个 hook)\n`));
+                    for (let i = 0; i < eventHooks.length; i++) {
+                        const hook = eventHooks[i];
+                        const isLast = i === eventHooks.length - 1;
+                        const connector = isLast ? '└── ' : '├── ';
+                        console.log(`       ${connector}${chalk_1.default.cyan(`[${hook.type}]`)}`);
+                        if (hook.matcher) {
+                            console.log(`           ${chalk_1.default.gray('匹配器:')} ${hook.matcher}`);
+                        }
+                        if (hook.command) {
+                            console.log(`           ${chalk_1.default.gray('命令:')} ${hook.command}`);
+                        }
+                    }
+                    console.log();
+                }
+            }
+        }
+        // 汇总
+        console.log(chalk_1.default.bold('汇总:'));
+        console.log(`  ${chalk_1.default.blue('全局:')} ${global.length} 个`);
+        console.log(`  ${chalk_1.default.green('项目级:')} ${project.size} 个项目，${hooks.length - global.length} 个 hooks`);
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// ============================================================
+// config 子命令 - 配置管理
+// ============================================================
+const configCmd = commander_1.program
+    .command('config')
+    .description('查看 Claude Code 配置信息')
+    .addHelpText('after', `
+${chalk_1.default.bold('子命令:')}
+  ${chalk_1.default.cyan('path')}    显示配置文件路径
+  ${chalk_1.default.cyan('stats')}   显示配置统计信息
+
+${chalk_1.default.bold('示例:')}
+  ${chalk_1.default.cyan('lcch config path')}     显示配置文件路径
+  ${chalk_1.default.cyan('lcch config stats')}    显示详细统计（项目、会话、费用、Token等）
+`);
+// lcch config path - 显示配置文件路径
+configCmd
+    .command('path')
+    .description('显示配置文件路径')
+    .action(() => {
+    const configPath = (0, scanner_1.getConfigPath)();
+    console.log(chalk_1.default.bold('配置文件路径:'));
+    console.log(`  ${configPath}`);
+    if (fs.existsSync(configPath)) {
+        const stats = fs.statSync(configPath);
+        console.log(chalk_1.default.gray(`\n文件大小: ${(0, backup_1.formatFileSize)(stats.size)}`));
+        console.log(chalk_1.default.gray(`修改时间: ${(0, scanner_1.formatDate)(stats.mtime)}`));
+    }
+    else {
+        console.log(chalk_1.default.yellow('\n配置文件不存在'));
+    }
+});
+// lcch config stats - 显示配置统计
+configCmd
+    .command('stats')
+    .description('显示配置统计信息')
+    .action(async () => {
+    try {
+        const config = await (0, scanner_1.readConfig)();
+        const result = await (0, scanner_1.scanProjects)(config);
+        const stats = await (0, scanner_1.calculateGlobalStats)(config);
+        console.log(chalk_1.default.bold('\n📊 配置统计\n'));
+        // 项目统计
+        console.log(chalk_1.default.bold('📁 项目:'));
+        console.log(`  总项目数:     ${result.totalCount}`);
+        console.log(chalk_1.default.green(`  有效项目:     ${result.validCount}`));
+        console.log(chalk_1.default.red(`  无效项目:     ${result.invalidCount}`));
+        console.log(`  MCP 服务器:   ${Object.keys(config.mcpServers || {}).length}`);
+        console.log();
+        // 会话统计
+        console.log(chalk_1.default.bold('💬 会话:'));
+        console.log(`  历史会话总计: ${chalk_1.default.cyan(stats.totalSessionHistory.toString())} 条`);
+        console.log(`    ${chalk_1.default.green('✓ 有效项目:')}   ${formatNumber(stats.sessionHistoryByCategory.valid)} 条`);
+        console.log(`    ${chalk_1.default.red('✗ 无效项目:')}   ${formatNumber(stats.sessionHistoryByCategory.invalid)} 条`);
+        console.log(`    ${chalk_1.default.yellow('⚠ 无头项目:')}   ${formatNumber(stats.sessionHistoryByCategory.orphaned)} 条`);
+        console.log();
+        console.log(`  Resume 总计:  ${chalk_1.default.cyan(stats.totalResumeSessions.toString())} 个`);
+        console.log(`    ${chalk_1.default.green('✓ 有效项目:')}   ${formatNumber(stats.resumeSessionsByCategory.valid)} 个`);
+        console.log(`    ${chalk_1.default.red('✗ 无效项目:')}   ${formatNumber(stats.resumeSessionsByCategory.invalid)} 个`);
+        console.log(`    ${chalk_1.default.yellow('⚠ 无头项目:')}   ${formatNumber(stats.resumeSessionsByCategory.orphaned)} 个`);
+        console.log(`  启动次数:     ${config.numStartups || 0}`);
+        console.log();
+        // 费用统计
+        console.log(chalk_1.default.bold('💰 费用:'));
+        console.log(`  总花费:       ${chalk_1.default.yellow('$' + stats.totalCost.toFixed(4))}`);
+        if (result.totalCount > 0) {
+            console.log(`  平均/项目:    ${chalk_1.default.gray('$' + stats.avgCostPerProject.toFixed(4))}`);
+        }
+        console.log(chalk_1.default.gray('  按项目分类:'));
+        console.log(`    ${chalk_1.default.green('✓ 有效项目:')}   $${stats.costByCategory.valid.toFixed(4)}`);
+        console.log(`    ${chalk_1.default.red('✗ 无效项目:')}   $${stats.costByCategory.invalid.toFixed(4)}`);
+        console.log();
+        console.log();
+        // Token 统计
+        console.log(chalk_1.default.bold('🔢 Token 使用:'));
+        console.log(`  输入 Tokens:        ${chalk_1.default.cyan(formatNumber(stats.totalInputTokens))}`);
+        console.log(`  输出 Tokens:        ${chalk_1.default.cyan(formatNumber(stats.totalOutputTokens))}`);
+        console.log(`  缓存创建 Tokens:    ${chalk_1.default.cyan(formatNumber(stats.totalCacheCreationTokens))}`);
+        console.log(`  缓存读取 Tokens:    ${chalk_1.default.cyan(formatNumber(stats.totalCacheReadTokens))}`);
+        console.log();
+        // 工具使用统计
+        console.log(chalk_1.default.bold('🛠️ 工具使用:'));
+        console.log(`  工具调用总计: ${chalk_1.default.cyan(formatNumber(stats.totalToolUsage))} 次`);
+        if (stats.toolDetails.length > 0) {
+            console.log(chalk_1.default.gray('  详细列表:'));
+            stats.toolDetails.slice(0, 10).forEach((tool, index) => {
+                const isLast = index === Math.min(stats.toolDetails.length - 1, 9);
+                const connector = isLast ? '└── ' : '├── ';
+                const name = tool.name;
+                const count = chalk_1.default.cyan(`${formatNumber(tool.count)} 次`);
+                const lastUsed = chalk_1.default.gray(`[${(0, scanner_1.formatRelativeTime)(tool.lastUsedAt)}]`);
+                console.log(`      ${connector}${name} ${count} ${lastUsed}`);
+            });
+            if (stats.toolDetails.length > 10) {
+                console.log(`      └── ${chalk_1.default.gray(`... 还有 ${stats.toolDetails.length - 10} 个工具`)}`);
+            }
+        }
+        console.log();
+        // Skill 使用统计
+        console.log(chalk_1.default.bold('✨ Skill 使用:'));
+        console.log(`  Skill 调用总计: ${chalk_1.default.cyan(formatNumber(stats.totalSkillUsage))} 次`);
+        if (stats.skillDetails.length > 0) {
+            console.log(chalk_1.default.gray('  详细列表:'));
+            stats.skillDetails.slice(0, 10).forEach((skill, index) => {
+                const isLast = index === Math.min(stats.skillDetails.length - 1, 9);
+                const connector = isLast ? '└── ' : '├── ';
+                const name = skill.name;
+                const count = chalk_1.default.cyan(`${formatNumber(skill.count)} 次`);
+                const lastUsed = chalk_1.default.gray(`[${(0, scanner_1.formatRelativeTime)(skill.lastUsedAt)}]`);
+                console.log(`      ${connector}${name} ${count} ${lastUsed}`);
+            });
+            if (stats.skillDetails.length > 10) {
+                console.log(`      └── ${chalk_1.default.gray(`... 还有 ${stats.skillDetails.length - 10} 个 Skill`)}`);
+            }
+        }
+        console.log();
+        // GitHub 统计
+        console.log(chalk_1.default.bold('🔗 GitHub:'));
+        console.log(`  关联仓库:     ${chalk_1.default.cyan(stats.totalGithubRepos.toString())} 个`);
+        console.log();
+        // 时间统计
+        console.log(chalk_1.default.bold('⏱️ 时间:'));
+        console.log(`  使用天数:     ${chalk_1.default.cyan(stats.usageDays.toString())} 天`);
+        if (config.firstStartTime) {
+            console.log(`  首次启动:     ${(0, scanner_1.formatDate)(new Date(config.firstStartTime))}`);
+        }
+        if (stats.lastActivity) {
+            console.log(`  最后活动:     ${(0, scanner_1.formatRelativeTime)(stats.lastActivity.getTime())}`);
+        }
+        console.log();
+        // 用户信息
+        console.log(chalk_1.default.bold('👤 用户:'));
+        console.log(`  用户 ID:      ${config.userID || 'N/A'}`);
+        console.log(`  安装方式:     ${config.installMethod || 'N/A'}`);
+        // AI 伴侣信息
+        if (stats.companionInfo) {
+            console.log();
+            console.log(chalk_1.default.bold('🥚 AI 伴侣:'));
+            console.log(`  名字:         ${chalk_1.default.magenta(stats.companionInfo.name)}`);
+            console.log(`  性格:         ${stats.companionInfo.personality}`);
+            console.log(`  孵化时间:     ${(0, scanner_1.formatRelativeTime)(stats.companionInfo.hatchedAt.getTime())}`);
+        }
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// ============================================================
+// mcp 子命令 - MCP 服务器管理
+// ============================================================
+const mcpCmd = commander_1.program
+    .command('mcp')
+    .description('管理 MCP 服务器')
+    .addHelpText('after', `
+${chalk_1.default.bold('子命令:')}
+  ${chalk_1.default.cyan('list')}    列出所有 MCP 服务器
+  ${chalk_1.default.cyan('info')}    查看 MCP 服务器详细配置（交互式选择）
+
+${chalk_1.default.bold('示例:')}
+  ${chalk_1.default.cyan('lcch mcp list')}           列出所有 MCP 服务器（按全局/项目级分类）
+  ${chalk_1.default.cyan('lcch mcp info')}           交互式选择并查看 MCP 服务器详情
+  ${chalk_1.default.cyan('lcch mcp info --show')}    交互式选择并显示敏感信息（环境变量等）
+`);
+// lcch mcp list - 列出所有 MCP 服务器
+mcpCmd
+    .command('list')
+    .description('列出所有 MCP 服务器')
+    .action(async () => {
+    try {
+        const config = await (0, scanner_1.readConfig)();
+        const mcpServers = (0, scanner_1.getAllMcpServers)(config);
+        const { global, project } = (0, scanner_1.groupMcpServersByScope)(mcpServers);
+        if (mcpServers.length === 0) {
+            console.log(chalk_1.default.yellow('\n没有找到 MCP 服务器'));
+            return;
+        }
+        console.log(chalk_1.default.bold(`\n共 ${mcpServers.length} 个 MCP 服务器:\n`));
+        // 显示全局 MCP 服务器
+        if (global.length > 0) {
+            console.log(chalk_1.default.magenta.bold('全局 MCP 服务器:'));
+            for (const server of global) {
+                console.log(`  ${chalk_1.default.cyan('•')} ${chalk_1.default.bold(server.name)}`);
+                if (server.config.type) {
+                    console.log(`    ${chalk_1.default.gray('类型:')} ${server.config.type}`);
+                }
+                if (server.config.command) {
+                    console.log(`    ${chalk_1.default.gray('命令:')} ${server.config.command}`);
+                }
+            }
+            console.log();
+        }
+        // 显示项目级 MCP 服务器
+        if (project.size > 0) {
+            console.log(chalk_1.default.green.bold('项目级 MCP 服务器:'));
+            for (const [projectPath, servers] of project) {
+                console.log(`  ${chalk_1.default.green('✓')} ${chalk_1.default.bold(projectPath)} ${chalk_1.default.gray(`(${servers.length} 个)`)}`);
+                for (const server of servers) {
+                    console.log(`    ${chalk_1.default.cyan('•')} ${server.name}`);
+                    if (server.config.type) {
+                        console.log(`      ${chalk_1.default.gray('类型:')} ${server.config.type}`);
+                    }
+                    if (server.config.command) {
+                        console.log(`      ${chalk_1.default.gray('命令:')} ${server.config.command}`);
+                    }
+                }
+            }
+            console.log();
+        }
+        // 汇总
+        console.log(chalk_1.default.bold('汇总:'));
+        console.log(`  ${chalk_1.default.magenta('全局:')} ${global.length} 个`);
+        console.log(`  ${chalk_1.default.green('项目级:')} ${project.size} 个项目，${mcpServers.length - global.length} 个服务器`);
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// lcch mcp info - 查看 MCP 服务器详细信息
+mcpCmd
+    .command('info')
+    .description('查看 MCP 服务器详细配置（交互式选择）')
+    .option('--show', '显示敏感信息（环境变量中的密钥等）', false)
+    .action(async (options) => {
+    try {
+        const config = await (0, scanner_1.readConfig)();
+        const mcpServers = (0, scanner_1.getAllMcpServers)(config);
+        if (mcpServers.length === 0) {
+            console.log(chalk_1.default.yellow('\n没有找到 MCP 服务器'));
+            return;
+        }
+        // 交互式选择
+        const choices = mcpServers.map(s => {
+            const scopeLabel = s.scope === 'global' ? chalk_1.default.magenta('[全局]') : chalk_1.default.green(`[项目: ${s.projectPath}]`);
+            return {
+                name: `${s.name} ${scopeLabel}`,
+                value: s,
+            };
+        });
+        const { server } = await inquirer_1.default.prompt([{
+                type: 'list',
+                name: 'server',
+                message: '选择要查看的 MCP 服务器:',
+                choices,
+                pageSize: 20,
+            }]);
+        const selectedServer = server;
+        if (!selectedServer) {
+            console.log(chalk_1.default.yellow('未选择任何服务器'));
+            return;
+        }
+        // 显示详细信息
+        console.log(chalk_1.default.bold(`\n🔌 MCP 服务器详情\n`));
+        console.log(`${chalk_1.default.bold('名称:')} ${chalk_1.default.cyan(selectedServer.name)}`);
+        console.log(`${chalk_1.default.bold('作用范围:')} ${selectedServer.scope === 'global' ? chalk_1.default.magenta('全局') : chalk_1.default.green('项目级')}`);
+        if (selectedServer.projectPath) {
+            console.log(`${chalk_1.default.bold('项目路径:')} ${selectedServer.projectPath}`);
+        }
+        console.log();
+        // 显示配置详情
+        console.log(chalk_1.default.bold('配置详情:'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        const serverConfig = selectedServer.config;
+        // 类型
+        if (serverConfig.type) {
+            console.log(`${chalk_1.default.bold('类型:')} ${chalk_1.default.yellow(serverConfig.type)}`);
+        }
+        // 命令
+        if (serverConfig.command) {
+            console.log(`${chalk_1.default.bold('命令:')} ${chalk_1.default.cyan(serverConfig.command)}`);
+        }
+        // 参数
+        if (serverConfig.args && Array.isArray(serverConfig.args) && serverConfig.args.length > 0) {
+            console.log(`${chalk_1.default.bold('参数:')}`);
+            serverConfig.args.forEach((arg, index) => {
+                console.log(`  [${index}] ${chalk_1.default.cyan(arg)}`);
+            });
+        }
+        // 环境变量
+        if (serverConfig.env && typeof serverConfig.env === 'object' && Object.keys(serverConfig.env).length > 0) {
+            console.log(`${chalk_1.default.bold('环境变量:')}`);
+            for (const [key, value] of Object.entries(serverConfig.env)) {
+                // 检测敏感信息：包含 key、token、secret、password、auth、authorization、apikey、api-key、access_key、secret_key 或以 _pass 结尾的键
+                const isSecretKey = /key|token|secret|password|auth|authorization|apikey|api-key|access_key|secret_key|_pass$/i.test(key);
+                // 检测值是否包含敏感模式（如 Bearer token、Basic auth 等）
+                const strValue = String(value);
+                const isSecretValue = /^(Bearer\s+|Basic\s+|ApiKey\s+|Token\s+)/i.test(strValue);
+                let displayValue;
+                if ((isSecretKey || isSecretValue) && value && !options.show) {
+                    // 模糊化显示：保留前4个字符，其余用 * 替代
+                    displayValue = strValue.length > 4 ? `${strValue.substring(0, 4)}****` : '****';
+                }
+                else {
+                    displayValue = strValue;
+                }
+                console.log(`  ${chalk_1.default.gray(key)}=${chalk_1.default.cyan(displayValue)}`);
+            }
+        }
+        // URL（对于 HTTP SSE 类型）
+        if (serverConfig.url) {
+            console.log(`${chalk_1.default.bold('URL:')} ${chalk_1.default.cyan(serverConfig.url)}`);
+        }
+        // 超时设置
+        if (serverConfig.timeout !== undefined) {
+            console.log(`${chalk_1.default.bold('超时:')} ${serverConfig.timeout}ms`);
+        }
+        // 自动批准
+        if (serverConfig.autoApprove !== undefined) {
+            console.log(`${chalk_1.default.bold('自动批准:')} ${serverConfig.autoApprove ? chalk_1.default.green('是') : chalk_1.default.red('否')}`);
+        }
+        // 禁用状态
+        if (serverConfig.disabled !== undefined) {
+            console.log(`${chalk_1.default.bold('状态:')} ${serverConfig.disabled ? chalk_1.default.red('已禁用') : chalk_1.default.green('已启用')}`);
+        }
+        // 其他配置项
+        const knownKeys = ['type', 'command', 'args', 'env', 'url', 'timeout', 'autoApprove', 'disabled'];
+        const otherKeys = Object.keys(serverConfig).filter(k => !knownKeys.includes(k));
+        if (otherKeys.length > 0) {
+            console.log();
+            console.log(`${chalk_1.default.bold('其他配置:')}`);
+            for (const key of otherKeys) {
+                const value = serverConfig[key];
+                if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                    console.log(`  ${chalk_1.default.gray(key)}: ${chalk_1.default.cyan(String(value))}`);
+                }
+                else if (value !== null && value !== undefined) {
+                    console.log(`  ${chalk_1.default.gray(key)}: ${chalk_1.default.cyan(JSON.stringify(value))}`);
+                }
+            }
+        }
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// ============================================================
+// cache 子命令 - 缓存管理
+// ============================================================
+const cacheCmd = commander_1.program
+    .command('cache')
+    .description('查看 Claude Code 缓存信息')
+    .option('--json', '以 JSON 格式输出', false)
+    .addHelpText('after', `
+${chalk_1.default.bold('子命令:')}
+  ${chalk_1.default.cyan('scan-secrets')} 扫描缓存中的敏感信息
+
+${chalk_1.default.bold('示例:')}
+  ${chalk_1.default.cyan('lcch cache')}              查看所有缓存信息
+  ${chalk_1.default.cyan('lcch cache --json')}        以 JSON 格式输出
+  ${chalk_1.default.cyan('lcch scan-secrets')}        扫描缓存中的密钥（独立命令）
+`);
+// lcch cache - 查看缓存信息
+cacheCmd
+    .action(async (options) => {
+    try {
+        const caches = await (0, scanner_1.getCacheInfo)();
+        const promptCacheStats = await (0, scanner_1.getPromptCacheStats)();
+        if (options.json) {
+            // JSON 格式输出
+            console.log(JSON.stringify({
+                caches: caches.map(c => ({
+                    name: c.name,
+                    description: c.description,
+                    path: c.path,
+                    fileCount: c.fileCount,
+                    totalSize: c.totalSize,
+                    lastModified: c.lastModified?.toISOString(),
+                })),
+                promptCacheStats: promptCacheStats || undefined,
+            }, null, 2));
+            return;
+        }
+        // 表格形式输出
+        console.log(chalk_1.default.bold('\n📦 Claude Code 缓存信息\n'));
+        // 计算总缓存大小
+        const totalCacheSize = caches.reduce((sum, c) => sum + c.totalSize, 0);
+        // 显示各类缓存
+        if (caches.length === 0) {
+            console.log(chalk_1.default.yellow('没有发现缓存文件'));
+        }
+        else {
+            for (const cache of caches) {
+                const sizeStr = (0, backup_1.formatFileSize)(cache.totalSize);
+                const countStr = cache.fileCount === 1
+                    ? '1 个文件'
+                    : `${cache.fileCount} 个文件`;
+                const dateStr = cache.lastModified
+                    ? chalk_1.default.gray(`最后更新: ${(0, scanner_1.formatRelativeTime)(cache.lastModified.getTime())}`)
+                    : '';
+                console.log(`${chalk_1.default.cyan('•')} ${chalk_1.default.bold(cache.name)}`);
+                console.log(`    ${chalk_1.default.gray(cache.description)}`);
+                console.log(`    ${chalk_1.default.gray('路径:')} ${cache.path}`);
+                console.log(`    ${chalk_1.default.gray(`大小: ${sizeStr} | ${countStr}`)} ${dateStr}`);
+                console.log();
+            }
+            // 汇总
+            console.log(chalk_1.default.bold('─────────────────────────────────────'));
+            console.log(chalk_1.default.bold('  缓存汇总'));
+            console.log(chalk_1.default.bold('─────────────────────────────────────'));
+            console.log(`  缓存类型:  ${caches.length} 种`);
+            console.log(`  总大小:    ${chalk_1.default.yellow((0, backup_1.formatFileSize)(totalCacheSize))}`);
+            console.log(chalk_1.default.bold('─────────────────────────────────────'));
+        }
+        // 显示 API Prompt 缓存统计
+        if (promptCacheStats) {
+            console.log(chalk_1.default.bold('\n\n🔄 API Prompt 缓存统计\n'));
+            for (const [model, stats] of Object.entries(promptCacheStats.modelUsage)) {
+                console.log(chalk_1.default.blue.bold(`  模型: ${model}`));
+                console.log(`    输入 Tokens:       ${chalk_1.default.cyan(formatNumber(stats.inputTokens))}`);
+                console.log(`    输出 Tokens:       ${chalk_1.default.cyan(formatNumber(stats.outputTokens))}`);
+                console.log(`    ${chalk_1.default.green('缓存读取 Tokens:')} ${chalk_1.default.green(formatNumber(stats.cacheReadInputTokens))}`);
+                console.log(`    ${chalk_1.default.yellow('缓存创建 Tokens:')} ${chalk_1.default.yellow(formatNumber(stats.cacheCreationInputTokens))}`);
+                console.log(`    费用:              ${chalk_1.default.yellow('$' + stats.costUSD.toFixed(4))}`);
+                // 计算缓存命中率
+                const totalInput = stats.inputTokens + stats.cacheReadInputTokens;
+                if (totalInput > 0) {
+                    const cacheHitRate = (stats.cacheReadInputTokens / totalInput * 100).toFixed(1);
+                    console.log(`    缓存命中率:        ${chalk_1.default.cyan(cacheHitRate + '%')}`);
+                }
+                console.log();
+            }
+        }
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// ============================================================
+// 恢复备份相关函数
+// ============================================================
+/**
+ * 恢复单个备份文件
+ */
+async function restoreSingleBackup(backupPath) {
+    if (!await fs.pathExists(backupPath)) {
+        console.error(chalk_1.default.red(`错误: 备份不存在: ${backupPath}`));
+        process.exit(1);
+    }
+    // 从备份文件名推断原文件路径
+    // 备份格式: /path/to/file.json.backup.1234567890
+    const backupMatch = backupPath.match(/^(.+)\.backup\.\d+$/);
+    if (!backupMatch) {
+        console.error(chalk_1.default.red(`错误: 无效的备份文件路径格式: ${backupPath}`));
+        console.error(chalk_1.default.gray('  备份文件格式应为: <原文件路径>.backup.<时间戳>'));
+        process.exit(1);
+    }
+    const originalPath = backupMatch[1];
+    const { confirm } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: chalk_1.default.yellow(`确认从 ${path.basename(backupPath)} 恢复文件？原文件将被覆盖。`),
+            default: false,
+        }]);
+    if (!confirm) {
+        console.log(chalk_1.default.yellow('操作已取消'));
+        return;
+    }
+    // 恢复单个文件
+    await fs.copy(backupPath, originalPath);
+    console.log(chalk_1.default.green(`✓ 文件已成功恢复: ${originalPath}`));
+    // 删除备份文件
+    await fs.remove(backupPath);
+    console.log(chalk_1.default.gray(`  备份文件已删除: ${path.basename(backupPath)}`));
+}
+/**
+ * 恢复项目下的所有备份文件
+ */
+async function restoreProjectBackups(projectDir) {
+    if (!await fs.pathExists(projectDir)) {
+        console.error(chalk_1.default.red(`错误: 项目目录不存在: ${projectDir}`));
+        process.exit(1);
+    }
+    // 查找项目目录下的所有备份文件
+    const allFiles = await fs.readdir(projectDir, { recursive: true });
+    const backupFiles = [];
+    for (const file of allFiles) {
+        const fullPath = path.join(projectDir, file);
+        const stat = await fs.stat(fullPath);
+        if (stat.isFile() && file.match(/\.backup\.\d+$/)) {
+            backupFiles.push(fullPath);
+        }
+    }
+    if (backupFiles.length === 0) {
+        console.log(chalk_1.default.yellow(`项目目录下没有找到备份文件: ${projectDir}`));
+        return;
+    }
+    // 按原文件路径分组备份
+    const backupGroups = new Map();
+    for (const backupPath of backupFiles) {
+        const match = backupPath.match(/^(.+)\.backup\.\d+$/);
+        if (match) {
+            const originalPath = match[1];
+            const list = backupGroups.get(originalPath) || [];
+            list.push(backupPath);
+            backupGroups.set(originalPath, list);
+        }
+    }
+    // 显示找到的备份
+    console.log(chalk_1.default.bold(`\n📁 找到 ${backupFiles.length} 个备份文件（涉及 ${backupGroups.size} 个原文件）\n`));
+    for (const [originalPath, backups] of backupGroups) {
+        const relativeOriginal = originalPath.replace(projectDir, '.');
+        console.log(`  ${chalk_1.default.cyan(relativeOriginal)}:`);
+        for (const backup of backups.sort()) {
+            console.log(`    ${chalk_1.default.gray('→')} ${path.basename(backup)}`);
+        }
+    }
+    console.log();
+    // 确认恢复
+    const { confirm } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: chalk_1.default.yellow(`确认恢复所有 ${backupFiles.length} 个备份文件？原文件将被覆盖。`),
+            default: false,
+        }]);
+    if (!confirm) {
+        console.log(chalk_1.default.yellow('操作已取消'));
+        return;
+    }
+    // 执行恢复
+    console.log(chalk_1.default.bold('\n📝 正在恢复备份文件...\n'));
+    let restoredCount = 0;
+    let deletedCount = 0;
+    const failedRestores = [];
+    for (const [originalPath, backups] of backupGroups) {
+        // 使用最新的备份（按时间戳排序）
+        const latestBackup = backups.sort().pop();
+        const relativeOriginal = originalPath.replace(projectDir, '.');
+        try {
+            // 恢复文件
+            await fs.copy(latestBackup, originalPath);
+            console.log(`  ${chalk_1.default.green('✓')} ${relativeOriginal} ${chalk_1.default.gray(`← ${path.basename(latestBackup)}`)}`);
+            restoredCount++;
+            // 删除该原文件的所有备份
+            for (const backup of backups) {
+                await fs.remove(backup);
+                deletedCount++;
+            }
+            // 删除最新备份
+            await fs.remove(latestBackup);
+            deletedCount++;
+        }
+        catch (error) {
+            console.error(`  ${chalk_1.default.red('✗')} ${relativeOriginal} - ${error.message}`);
+            failedRestores.push(relativeOriginal);
+        }
+    }
+    console.log();
+    console.log(chalk_1.default.green('✓ 恢复完成'));
+    console.log(`  ${chalk_1.default.gray('成功恢复:')} ${restoredCount} 个文件`);
+    console.log(`  ${chalk_1.default.gray('删除备份:')} ${deletedCount} 个`);
+    if (failedRestores.length > 0) {
+        console.log(`  ${chalk_1.default.red('失败:')} ${failedRestores.length} 个文件`);
+        for (const failed of failedRestores) {
+            console.log(`    ${chalk_1.default.red('•')} ${failed}`);
+        }
+    }
+}
+/**
+ * 列出所有掩码备份
+ */
+async function listMaskBackups() {
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    if (!await fs.pathExists(projectsDir)) {
+        console.log(chalk_1.default.yellow('没有找到项目缓存目录'));
+        return;
+    }
+    // 读取所有项目目录
+    const projectDirs = await fs.readdir(projectsDir, { withFileTypes: true });
+    const projectsWithBackups = [];
+    for (const dir of projectDirs) {
+        if (!dir.isDirectory())
+            continue;
+        const projectPath = path.join(projectsDir, dir.name);
+        const allFiles = await fs.readdir(projectPath, { recursive: true });
+        const backupInfos = [];
+        for (const file of allFiles) {
+            const fullPath = path.join(projectPath, file);
+            const stat = await fs.stat(fullPath).catch(() => null);
+            if (!stat || !stat.isFile())
+                continue;
+            // 匹配备份文件格式: filename.backup.timestamp
+            const backupMatch = file.match(/^(.*)\.backup\.(\d+)$/);
+            if (backupMatch) {
+                const originalName = backupMatch[1];
+                const timestamp = parseInt(backupMatch[2], 10);
+                const originalPath = path.join(projectPath, file.replace(/\.backup\.\d+$/, ''));
+                backupInfos.push({
+                    projectName: dir.name,
+                    projectPath,
+                    originalPath: originalPath.replace(projectPath, '.'),
+                    backupPath: fullPath,
+                    backupTime: new Date(timestamp),
+                    size: stat.size,
+                });
+            }
+        }
+        if (backupInfos.length > 0) {
+            // 尝试获取真实项目路径
+            const realPath = dir.name.replace(/-/g, '/');
+            const fullRealPath = path.resolve('/', realPath);
+            projectsWithBackups.push({
+                normalizedPath: dir.name,
+                realPath: await fs.pathExists(fullRealPath) ? fullRealPath : undefined,
+                backups: backupInfos,
+            });
+        }
+    }
+    if (projectsWithBackups.length === 0) {
+        console.log(chalk_1.default.green('✓ 没有发现任何备份文件'));
+        return;
+    }
+    // 计算统计信息
+    let totalBackups = 0;
+    let totalSize = 0;
+    for (const project of projectsWithBackups) {
+        totalBackups += project.backups.length;
+        for (const backup of project.backups) {
+            totalSize += backup.size;
+        }
+    }
+    // 显示总览
+    console.log(chalk_1.default.bold('\n📦 掩码备份统计\n'));
+    console.log(`  ${chalk_1.default.gray('涉及项目:')} ${projectsWithBackups.length} 个`);
+    console.log(`  ${chalk_1.default.gray('备份文件:')} ${totalBackups} 个`);
+    console.log(`  ${chalk_1.default.gray('总大小:')} ${(0, backup_1.formatFileSize)(totalSize)}`);
+    console.log();
+    // 按项目显示详细信息
+    for (const project of projectsWithBackups.sort((a, b) => a.normalizedPath.localeCompare(b.normalizedPath))) {
+        // 判断项目状态
+        const isValid = project.realPath && await fs.pathExists(project.realPath);
+        const statusIcon = isValid ? chalk_1.default.green('✓') : chalk_1.default.yellow('⚠');
+        const statusColor = isValid ? chalk_1.default.green : chalk_1.default.yellow;
+        console.log(statusColor(`  ${statusIcon} ${project.normalizedPath}`));
+        console.log(`    ${chalk_1.default.gray('备份数:')} ${project.backups.length}`);
+        if (project.realPath) {
+            console.log(`    ${chalk_1.default.gray('路径:')} ${project.realPath.replace(os.homedir(), '~')}`);
+        }
+        // 按原文件分组显示备份
+        const byOriginalFile = new Map();
+        for (const backup of project.backups) {
+            const list = byOriginalFile.get(backup.originalPath) || [];
+            list.push(backup);
+            byOriginalFile.set(backup.originalPath, list);
+        }
+        for (const [originalPath, backups] of byOriginalFile) {
+            console.log(`    ${chalk_1.default.cyan('•')} ${originalPath}`);
+            for (const backup of backups.sort((a, b) => b.backupTime.getTime() - a.backupTime.getTime())) {
+                const timeStr = backup.backupTime.toLocaleString('zh-CN');
+                const sizeStr = (0, backup_1.formatFileSize)(backup.size);
+                console.log(`      ${chalk_1.default.gray('→')} ${chalk_1.default.yellow(path.basename(backup.backupPath))} ${chalk_1.default.gray(`(${timeStr}, ${sizeStr})`)}`);
+            }
+        }
+        console.log();
+    }
+    // 显示恢复提示
+    console.log(chalk_1.default.bold('─────────────────────────────────────'));
+    console.log(chalk_1.default.gray('恢复命令:'));
+    console.log(`  lcch scan-secrets --mask --restore ${chalk_1.default.cyan('<项目目录>')}`);
+    console.log(chalk_1.default.bold('─────────────────────────────────────'));
+    console.log();
+}
+// ============================================================
+// scan-secrets 子命令 - 扫描缓存中的密钥
+// ============================================================
+const scanSecretsCmd = commander_1.program
+    .command('scan-secrets')
+    .description('扫描 Claude Code 缓存或项目中的敏感信息')
+    .option('--show', '显示完整密钥（不安全，仅供调试）', false)
+    .option('--mask', '扫描项目并交互式掩码敏感信息', false)
+    .option('--restore <path>', '恢复指定的备份文件或项目目录（需配合 --mask）', '')
+    .option('--backup', '列出所有掩码备份信息', false)
+    .addHelpText('after', `
+${chalk_1.default.bold('说明:')}
+  扫描 Claude Code 缓存目录或项目中的敏感信息，包括：
+  - API 密钥（Anthropic、OpenAI、GitHub 等）
+  - 数据库连接字符串
+  - JWT 令牌
+  - 私钥文件
+  - MCP 服务器认证信息
+
+  扫描位置：
+  - ~/.claude/settings.json
+  - ~/.claude/projects/
+  - ~/.claude/history.jsonl
+  - ~/.claude/session-env/
+
+${chalk_1.default.bold('示例:')}
+  ${chalk_1.default.cyan('lcch scan-secrets')}              扫描缓存中的密钥
+  ${chalk_1.default.cyan('lcch scan-secrets --show')}      显示完整密钥
+  ${chalk_1.default.cyan('lcch scan-secrets --mask')}      扫描项目并交互式掩码敏感信息
+  ${chalk_1.default.cyan('lcch scan-secrets --mask --restore <项目目录>')} 恢复项目所有备份
+  ${chalk_1.default.cyan('lcch scan-secrets --backup')}    列出所有掩码备份
+`);
+// lcch cache scan-secrets - 扫描密钥
+scanSecretsCmd
+    .action(async (options) => {
+    try {
+        // 处理 --backup 模式：列出所有备份
+        if (options.backup) {
+            await listMaskBackups();
+            return;
+        }
+        // 处理 --mask 模式下的恢复备份
+        if (options.mask && options.restore) {
+            const restorePath = options.restore;
+            // 检查是否是项目目录（包含备份文件）
+            const isProjectDir = await fs.pathExists(path.join(restorePath, '..', '..', '.claude')) ||
+                restorePath.includes('.claude/projects');
+            if (isProjectDir || (await fs.stat(restorePath)).isDirectory()) {
+                // 按项目恢复所有备份
+                await restoreProjectBackups(restorePath);
+            }
+            else {
+                // 恢复单个备份文件（旧方式，保持兼容）
+                await restoreSingleBackup(restorePath);
+            }
+            return;
+        }
+        // 处理 --mask 模式
+        if (options.mask) {
+            // 获取配置和项目状态
+            const config = await (0, scanner_1.readConfig)();
+            const result = await (0, scanner_1.scanProjects)(config);
+            // 构建项目状态映射
+            const validProjectsSet = new Set(result.validProjects);
+            const invalidProjectsSet = new Set(result.invalidProjects);
+            const allConfigProjects = new Set([...result.validProjects, ...result.invalidProjects]);
+            // 构建 normalizedPath -> projectPath 的映射
+            const normalizedToProjectMap = new Map();
+            for (const configPath of allConfigProjects) {
+                const configNormalizedPath = configPath.replace(/\//g, '-');
+                normalizedToProjectMap.set(configNormalizedPath, configPath);
+            }
+            // 获取所有项目缓存目录
+            const allCacheDirs = await (0, scanner_1.getAllProjectCacheDirs)();
+            if (allCacheDirs.length === 0) {
+                console.log(chalk_1.default.yellow('没有发现项目缓存目录'));
+                return;
+            }
+            // 扫描所有项目缓存，收集包含敏感信息的项目
+            console.log(chalk_1.default.bold('\n🔍 正在扫描所有项目缓存中的敏感信息...\n'));
+            const projectsWithSecrets = [];
+            for (const normalizedPath of allCacheDirs) {
+                const findings = await (0, scanner_1.scanProjectCacheSecrets)(normalizedPath);
+                if (findings.length > 0) {
+                    const realPath = normalizedToProjectMap.get(normalizedPath);
+                    let status;
+                    if (realPath) {
+                        if (validProjectsSet.has(realPath)) {
+                            status = 'valid';
+                        }
+                        else {
+                            status = 'invalid';
+                        }
+                    }
+                    else {
+                        status = 'orphaned';
+                    }
+                    projectsWithSecrets.push({
+                        normalizedPath,
+                        realPath,
+                        status,
+                        findings,
+                    });
+                }
+            }
+            if (projectsWithSecrets.length === 0) {
+                console.log(chalk_1.default.green('✓ 所有项目均未发现敏感信息'));
+                return;
+            }
+            // 按状态分组
+            const validProjects = projectsWithSecrets.filter(p => p.status === 'valid');
+            const invalidProjects = projectsWithSecrets.filter(p => p.status === 'invalid');
+            const orphanedProjects = projectsWithSecrets.filter(p => p.status === 'orphaned');
+            console.log(chalk_1.default.yellow(`\n发现 ${projectsWithSecrets.length} 个项目包含敏感信息\n`));
+            // 构建交互选择列表（按状态分组）
+            const choices = [];
+            // 有效项目组
+            if (validProjects.length > 0) {
+                choices.push({
+                    name: chalk_1.default.green('━━ 有效项目 ━━'),
+                    value: '---valid---',
+                    short: '有效项目',
+                });
+                for (const project of validProjects.sort((a, b) => (a.realPath || '').localeCompare(b.realPath || ''))) {
+                    const shortPath = (project.realPath || '').replace(os.homedir(), '~');
+                    choices.push({
+                        name: `${chalk_1.default.green(shortPath)} ${chalk_1.default.gray(`(${project.findings.length} 处敏感信息)`)}`,
+                        value: project.normalizedPath,
+                        short: shortPath,
+                    });
+                }
+            }
+            // 无效项目组
+            if (invalidProjects.length > 0) {
+                choices.push({
+                    name: chalk_1.default.red('━━ 无效项目 ━━'),
+                    value: '---invalid---',
+                    short: '无效项目',
+                });
+                for (const project of invalidProjects.sort((a, b) => (a.realPath || '').localeCompare(b.realPath || ''))) {
+                    const shortPath = (project.realPath || '').replace(os.homedir(), '~');
+                    choices.push({
+                        name: `${chalk_1.default.magenta(shortPath)} ${chalk_1.default.gray(`(${project.findings.length} 处敏感信息)`)}`,
+                        value: project.normalizedPath,
+                        short: shortPath,
+                    });
+                }
+            }
+            // 孤立项目组
+            if (orphanedProjects.length > 0) {
+                choices.push({
+                    name: chalk_1.default.yellow('━━ 孤立项目 ━━'),
+                    value: '---orphaned---',
+                    short: '孤立项目',
+                });
+                for (const project of orphanedProjects.sort((a, b) => a.normalizedPath.localeCompare(b.normalizedPath))) {
+                    choices.push({
+                        name: `${chalk_1.default.yellow(project.normalizedPath)} ${chalk_1.default.gray(`(${project.findings.length} 处敏感信息)`)}`,
+                        value: project.normalizedPath,
+                        short: project.normalizedPath,
+                    });
+                }
+            }
+            // 交互选择项目（支持重新选择分隔项）
+            let selectedNormalizedPath;
+            while (true) {
+                const result = await inquirer_1.default.prompt([{
+                        type: 'list',
+                        name: 'selectedNormalizedPath',
+                        message: '选择要处理的项目:',
+                        choices,
+                        pageSize: 20,
+                    }]);
+                selectedNormalizedPath = result.selectedNormalizedPath;
+                // 检查是否选择了分隔项
+                if (!selectedNormalizedPath.startsWith('---')) {
+                    break;
+                }
+                // 如果选择了分隔项，显示提示并重新选择
+                console.log(chalk_1.default.gray('请选择一个项目，而不是分组标题'));
+            }
+            // 获取选中项目的扫描结果
+            const selectedProjectData = projectsWithSecrets.find(p => p.normalizedPath === selectedNormalizedPath);
+            if (!selectedProjectData) {
+                console.log(chalk_1.default.red('错误: 无法找到选中的项目数据'));
+                return;
+            }
+            const findings = selectedProjectData.findings;
+            const projectDir = path.join(os.homedir(), '.claude', 'projects', selectedNormalizedPath);
+            // 显示项目标题
+            console.log();
+            if (selectedProjectData.status === 'valid' && selectedProjectData.realPath) {
+                const shortPath = selectedProjectData.realPath.replace(os.homedir(), '~');
+                console.log(chalk_1.default.bold(`\n🔍 项目: ${chalk_1.default.green(shortPath)}`));
+                console.log(chalk_1.default.gray(`   ~/.claude/projects/${selectedNormalizedPath}`));
+            }
+            else if (selectedProjectData.status === 'invalid' && selectedProjectData.realPath) {
+                const shortPath = selectedProjectData.realPath.replace(os.homedir(), '~');
+                console.log(chalk_1.default.bold(`\n🔍 项目: ${chalk_1.default.magenta(shortPath)}`));
+                console.log(chalk_1.default.gray(`   ~/.claude/projects/${selectedNormalizedPath}`));
+            }
+            else {
+                console.log(chalk_1.default.bold(`\n🔍 项目: ${chalk_1.default.yellow(selectedNormalizedPath)}`));
+                console.log(chalk_1.default.gray(`   ~/.claude/projects/${selectedNormalizedPath}`));
+            }
+            console.log();
+            // 按类型统计敏感信息
+            const byType = new Map();
+            for (const finding of findings) {
+                const list = byType.get(finding.type) || [];
+                list.push(finding);
+                byType.set(finding.type, list);
+            }
+            // 按文件统计，并收集每文件的敏感信息类型
+            const byFile = new Map();
+            for (const finding of findings) {
+                const relativePath = finding.path.replace(projectDir, '.');
+                if (!byFile.has(relativePath)) {
+                    byFile.set(relativePath, new Map());
+                }
+                const typeMap = byFile.get(relativePath);
+                const list = typeMap.get(finding.type) || [];
+                list.push(finding);
+                typeMap.set(finding.type, list);
+            }
+            // 显示统计概览
+            console.log(chalk_1.default.red.bold(`⚠️ 发现 ${findings.length} 处敏感信息:\n`));
+            console.log(chalk_1.default.bold('  🔑 按类型分布:'));
+            for (const [type, typeFindings] of byType) {
+                console.log(`    ${chalk_1.default.cyan('•')} ${type}: ${chalk_1.default.yellow(String(typeFindings.length))} 处`);
+            }
+            console.log();
+            const fileGroups = [];
+            for (const [relativePath, typeMap] of byFile) {
+                let totalCount = 0;
+                for (const list of typeMap.values()) {
+                    totalCount += list.length;
+                }
+                fileGroups.push({ relativePath, typeMap, totalCount });
+            }
+            // 按文件路径排序
+            fileGroups.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+            console.log(chalk_1.default.bold('  📁 涉及文件列表:'));
+            for (const group of fileGroups) {
+                const typeNames = Array.from(group.typeMap.keys()).join(', ');
+                console.log(`    ${chalk_1.default.cyan('•')} ${group.relativePath}: ${chalk_1.default.yellow(String(group.totalCount))} 处 ${chalk_1.default.gray(`(${typeNames})`)}`);
+            }
+            console.log();
+            // 收集所有敏感信息（所有文件）
+            const allFindings = [];
+            for (const group of fileGroups) {
+                for (const [type, findingsList] of group.typeMap) {
+                    for (const f of findingsList) {
+                        allFindings.push({
+                            type: f.type,
+                            description: f.description,
+                            path: f.path,
+                            line: f.line,
+                            context: f.context,
+                            masked: f.masked,
+                            originalSecret: f.originalSecret,
+                            fullMatch: f.fullMatch,
+                            replacement: maskSecret(f.originalSecret),
+                        });
+                    }
+                }
+            }
+            // 二次确认
+            const confirmedMask = await (0, prompts_1.confirm)({
+                message: chalk_1.default.red(`确认创建备份并替换所有 ${allFindings.length} 处敏感信息？`),
+                default: false,
+            });
+            if (!confirmedMask) {
+                console.log(chalk_1.default.yellow('操作已取消'));
+                return;
+            }
+            // 执行掩码
+            console.log(chalk_1.default.bold('\n📝 正在创建备份并替换敏感信息...\n'));
+            const maskResult = await (0, scanner_1.maskProjectSecrets)(projectDir, allFindings);
+            // 显示结果
+            console.log(chalk_1.default.green('✓ 备份已创建'));
+            console.log(`  ${chalk_1.default.gray('备份文件数:')} ${maskResult.backups.length}`);
+            for (const backup of maskResult.backups) {
+                const relativeOriginal = backup.originalPath.replace(projectDir, '.');
+                const backupFilename = path.basename(backup.backupPath);
+                console.log(`    ${chalk_1.default.cyan(relativeOriginal)} ${chalk_1.default.gray('→')} ${chalk_1.default.yellow(backupFilename)}`);
+            }
+            console.log();
+            console.log(chalk_1.default.green(`✓ 掩码替换完成`));
+            console.log(`  ${chalk_1.default.gray('修改文件数:')} ${maskResult.filesModified.length}`);
+            console.log();
+            if (maskResult.filesModified.length > 0) {
+                console.log(chalk_1.default.bold('修改的文件:'));
+                for (const file of maskResult.filesModified) {
+                    const relativePath = file.replace(projectDir, '.');
+                    console.log(`  ${chalk_1.default.cyan(relativePath)}`);
+                }
+            }
+            console.log();
+            console.log(chalk_1.default.bold('─────────────────────────────────────'));
+            console.log(chalk_1.default.yellow('如需恢复原始文件，请运行以下命令：'));
+            console.log(chalk_1.default.gray('  # 恢复项目所有文件'));
+            console.log(`  lcch scan-secrets --mask --restore ${projectDir}`);
+            console.log(chalk_1.default.bold('─────────────────────────────────────'));
+            console.log();
+            return;
+        }
+        // 普通模式：扫描缓存
+        console.log(chalk_1.default.bold('\n🔍 正在扫描缓存中的敏感信息...\n'));
+        const findings = await (0, scanner_1.scanCacheSecrets)();
+        // 表格形式输出
+        if (findings.length === 0) {
+            console.log(chalk_1.default.green('✓ 未发现敏感信息'));
+            console.log(chalk_1.default.gray('  扫描了以下位置:'));
+            console.log(chalk_1.default.gray('    - ~/.claude/settings.json'));
+            console.log(chalk_1.default.gray('    - ~/.claude/projects/'));
+            console.log(chalk_1.default.gray('    - ~/.claude/history.jsonl'));
+            console.log(chalk_1.default.gray('    - ~/.claude/session-env/'));
+        }
+        else {
+            // 读取配置并扫描项目状态
+            const config = await (0, scanner_1.readConfig)();
+            const scanResult = await (0, scanner_1.scanProjects)(config);
+            // 构建项目状态映射
+            const validProjectsSet = new Set(scanResult.validProjects);
+            const invalidProjectsSet = new Set(scanResult.invalidProjects);
+            const allConfigProjects = new Set([...scanResult.validProjects, ...scanResult.invalidProjects]);
+            // 构建 normalizedPath -> projectPath 的映射
+            const normalizedToProjectMap = new Map();
+            for (const configPath of allConfigProjects) {
+                const configNormalizedPath = configPath.replace(/\//g, '-');
+                normalizedToProjectMap.set(configNormalizedPath, configPath);
+            }
+            // 按状态分类收集涉及的项目
+            const validWithSecrets = [];
+            const invalidWithSecrets = [];
+            const orphanedWithSecrets = [];
+            // 收集所有涉及的 normalizedPath
+            const involvedNormalizedPaths = new Set();
+            for (const finding of findings) {
+                const projectsMatch = finding.path.match(/\.claude\/projects\/([^/]+)/);
+                if (projectsMatch) {
+                    involvedNormalizedPaths.add(projectsMatch[1]);
+                }
+            }
+            // 分类项目
+            for (const normalizedPath of involvedNormalizedPaths) {
+                const projectPath = normalizedToProjectMap.get(normalizedPath);
+                if (projectPath) {
+                    // 在配置中
+                    if (validProjectsSet.has(projectPath)) {
+                        validWithSecrets.push(projectPath);
+                    }
+                    else {
+                        invalidWithSecrets.push(projectPath);
+                    }
+                }
+                else {
+                    // 不在配置中（孤立项目）
+                    orphanedWithSecrets.push(normalizedPath);
+                }
+            }
+            const totalProjects = validWithSecrets.length + invalidWithSecrets.length + orphanedWithSecrets.length;
+            console.log(chalk_1.default.red.bold(`\n⚠️ 发现 ${findings.length} 处敏感信息（涉及 ${totalProjects} 个项目）\n`));
+            // 显示涉及的项目列表（按状态分组）
+            if (totalProjects > 0) {
+                console.log(chalk_1.default.bold('📁 涉及项目列表:'));
+                // 有效项目
+                if (validWithSecrets.length > 0) {
+                    console.log(chalk_1.default.green(`\n  ✓ 有效项目 (${validWithSecrets.length} 个):`));
+                    for (const projectPath of validWithSecrets.sort()) {
+                        const shortPath = projectPath.replace(os.homedir(), '~');
+                        const normalizedPath = projectPath.replace(/\//g, '-');
+                        console.log(`    ${chalk_1.default.green('•')} ${chalk_1.default.cyan(shortPath)}`);
+                        console.log(`      ${chalk_1.default.gray('~/.claude/projects/' + normalizedPath)}`);
+                    }
+                }
+                // 无效项目
+                if (invalidWithSecrets.length > 0) {
+                    console.log(chalk_1.default.red(`\n  ✗ 无效项目 (${invalidWithSecrets.length} 个):`));
+                    for (const projectPath of invalidWithSecrets.sort()) {
+                        const shortPath = projectPath.replace(os.homedir(), '~');
+                        const normalizedPath = projectPath.replace(/\//g, '-');
+                        console.log(`    ${chalk_1.default.red('•')} ${chalk_1.default.magenta(shortPath)}`);
+                        console.log(`      ${chalk_1.default.gray('~/.claude/projects/' + normalizedPath)}`);
+                    }
+                }
+                // 孤立项目
+                if (orphanedWithSecrets.length > 0) {
+                    console.log(chalk_1.default.yellow(`\n  ⚠ 孤立项目 (${orphanedWithSecrets.length} 个 - 已删除但数据仍存在):`));
+                    for (const normalizedPath of orphanedWithSecrets.sort()) {
+                        console.log(`    ${chalk_1.default.yellow('•')} ${chalk_1.default.yellow(normalizedPath)}`);
+                    }
+                }
+                console.log();
+            }
+            // 按类型分组显示敏感信息明细
+            const byType = new Map();
+            for (const finding of findings) {
+                const list = byType.get(finding.type) || [];
+                list.push(finding);
+                byType.set(finding.type, list);
+            }
+            for (const [type, typeFindings] of byType) {
+                console.log(chalk_1.default.red.bold(`  🔑 ${type} (${typeFindings.length} 处)`));
+                // 按项目分组（有效/无效/孤立）
+                const validFindings = typeFindings.filter(f => {
+                    const match = f.path.match(/\.claude\/projects\/([^/]+)/);
+                    if (!match)
+                        return false;
+                    const projectPath = normalizedToProjectMap.get(match[1]);
+                    return projectPath && validProjectsSet.has(projectPath);
+                });
+                const invalidFindings = typeFindings.filter(f => {
+                    const match = f.path.match(/\.claude\/projects\/([^/]+)/);
+                    if (!match)
+                        return false;
+                    const projectPath = normalizedToProjectMap.get(match[1]);
+                    return projectPath && invalidProjectsSet.has(projectPath);
+                });
+                const orphanedFindings = typeFindings.filter(f => {
+                    const match = f.path.match(/\.claude\/projects\/([^/]+)/);
+                    if (!match)
+                        return false;
+                    return !normalizedToProjectMap.has(match[1]);
+                });
+                // 按文件路径分组，合并相同的敏感信息
+                const byFile = new Map();
+                for (const finding of typeFindings) {
+                    const relativePath = finding.path.replace(os.homedir(), '~');
+                    if (!byFile.has(relativePath)) {
+                        byFile.set(relativePath, new Map());
+                    }
+                    const fileFindings = byFile.get(relativePath);
+                    // 使用 masked 值作为唯一标识来合并相同的敏感信息
+                    const key = finding.masked;
+                    if (!fileFindings.has(key)) {
+                        fileFindings.set(key, {
+                            lines: [],
+                            masked: finding.masked,
+                            fullMatch: finding.fullMatch,
+                        });
+                    }
+                    const entry = fileFindings.get(key);
+                    if (finding.line && !entry.lines.includes(finding.line)) {
+                        entry.lines.push(finding.line);
+                    }
+                }
+                // 输出合并后的结果
+                for (const [relativePath, fileFindings] of byFile) {
+                    // 确定文件所属的项目状态
+                    const projectsMatch = relativePath.match(/\.claude\/projects\/([^/]+)/);
+                    let statusIndicator = chalk_1.default.gray('📄');
+                    let pathColor;
+                    let statusLabel;
+                    if (projectsMatch) {
+                        const normalizedPath = projectsMatch[1];
+                        const projectPath = normalizedToProjectMap.get(normalizedPath);
+                        if (projectPath) {
+                            if (validProjectsSet.has(projectPath)) {
+                                statusIndicator = chalk_1.default.green('✓');
+                                pathColor = chalk_1.default.green; // 有效项目用绿色
+                                statusLabel = 'valid';
+                            }
+                            else {
+                                statusIndicator = chalk_1.default.red('✗');
+                                pathColor = chalk_1.default.magenta; // 无效项目用洋红色
+                                statusLabel = 'invalid';
+                            }
+                        }
+                        else {
+                            statusIndicator = chalk_1.default.yellow('⚠');
+                            pathColor = chalk_1.default.yellow; // 孤立项目用黄色
+                            statusLabel = 'orphaned';
+                        }
+                    }
+                    else {
+                        // 非项目文件（如 settings.json）
+                        pathColor = chalk_1.default.cyan;
+                        statusLabel = 'other';
+                    }
+                    // 每个文件显示一次路径，根据项目状态使用不同颜色
+                    const pathParts = relativePath.split('/');
+                    const coloredPath = pathParts.map((part, index) => {
+                        if (index === pathParts.length - 1) {
+                            // 文件名用白色加粗
+                            return chalk_1.default.white.bold(part);
+                        }
+                        else if (part.startsWith('.')) {
+                            // 隐藏目录用灰色
+                            return chalk_1.default.gray(part);
+                        }
+                        else {
+                            // 根据项目状态使用不同颜色
+                            return pathColor(part);
+                        }
+                    }).join(chalk_1.default.gray('/'));
+                    console.log(`     ${statusIndicator} ${coloredPath}`);
+                    if (options.show) {
+                        // --show 模式：去掉序号，每项信息换行，纵向对齐
+                        const entries = Array.from(fileFindings.entries());
+                        entries.forEach(([key, entry], index) => {
+                            const lineCount = entry.lines.length;
+                            const sortedLines = entry.lines.sort((a, b) => a - b);
+                            const isLast = index === entries.length - 1;
+                            const connector = isLast ? '└─' : '├─';
+                            console.log(`       ${chalk_1.default.gray(`${connector} 匹配:`)} ${chalk_1.default.yellow(entry.fullMatch)}`);
+                            console.log(`       ${chalk_1.default.gray(isLast ? '   ' : '│  ')} ${chalk_1.default.gray('条数:')} ${chalk_1.default.cyan(lineCount.toString())}`);
+                            if (sortedLines.length > 0) {
+                                console.log(`       ${chalk_1.default.gray(isLast ? '   ' : '│  ')} ${chalk_1.default.gray('行号:')} ${chalk_1.default.cyan(sortedLines.join(', '))}`);
+                            }
+                        });
+                    }
+                    else {
+                        // 普通模式：每项信息换行，纵向对齐
+                        const entries = Array.from(fileFindings.entries());
+                        entries.forEach(([key, entry], index) => {
+                            const lineCount = entry.lines.length;
+                            const sortedLines = entry.lines.sort((a, b) => a - b);
+                            const isLast = index === entries.length - 1;
+                            const connector = isLast ? '└─' : '├─';
+                            console.log(`       ${chalk_1.default.gray(`${connector} 匹配:`)} ${chalk_1.default.yellow(entry.masked)}`);
+                            console.log(`       ${chalk_1.default.gray(isLast ? '   ' : '│  ')} ${chalk_1.default.gray('条数:')} ${chalk_1.default.cyan(lineCount.toString())}`);
+                            if (sortedLines.length > 0) {
+                                console.log(`       ${chalk_1.default.gray(isLast ? '   ' : '│  ')} ${chalk_1.default.gray('行号:')} ${chalk_1.default.cyan(sortedLines.join(', '))}`);
+                            }
+                        });
+                    }
+                    console.log(); // 每个文件后空一行
+                }
+            }
+            console.log(chalk_1.default.bold('\n─────────────────────────────────────'));
+            console.log(chalk_1.default.bold('  安全建议'));
+            console.log(chalk_1.default.bold('─────────────────────────────────────'));
+            console.log(chalk_1.default.yellow('  1. 定期清理会话历史和 resume 数据'));
+            console.log(chalk_1.default.yellow('  2. 定期轮换 API 密钥'));
+            console.log(chalk_1.default.bold('─────────────────────────────────────'));
+        }
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+// ============================================================
+// project 子命令 - 单个项目管理
+// ============================================================
+const projectCmd = commander_1.program
+    .command('project <path>')
+    .description('管理单个 Claude Code 项目')
+    .option('--sessions', '显示该项目的所有会话', false)
+    .option('--delete-sessions', '删除选中的会话（需配合 --sessions 使用）', false)
+    .option('--resume', '显示该项目的 resume 历史记录', false)
+    .addHelpText('after', `
+${chalk_1.default.bold('参数:')}
+  ${chalk_1.default.cyan('<path>')}    项目路径（支持相对路径和 ~ 符号）
+
+${chalk_1.default.bold('选项:')}
+  ${chalk_1.default.cyan('--sessions')}          显示该项目的所有会话
+  ${chalk_1.default.cyan('--delete-sessions')}   删除选中的会话（需配合 --sessions 使用）
+  ${chalk_1.default.cyan('--resume')}            显示该项目的 resume 历史记录
+
+${chalk_1.default.bold('常用示例:')}
+  ${chalk_1.default.cyan('lcch project /path/to/project')}                    查看项目基本信息
+  ${chalk_1.default.cyan('lcch project ~/workspace/my-project')}              使用 ~ 符号
+  ${chalk_1.default.cyan('lcch project ./my-project')}                        使用相对路径
+  ${chalk_1.default.cyan('lcch project /path/to/project --sessions')}         查看会话历史
+  ${chalk_1.default.cyan('lcch project /path/to/project --sessions --delete-sessions')}  删除会话
+  ${chalk_1.default.cyan('lcch project /path/to/project --resume')}           查看 resume 历史
+  ${chalk_1.default.cyan('lcch project /path/to/project --resume --sessions')} 同时查看 resume 和会话
+`)
+    .action(async (projectPath, options) => {
+    try {
+        const config = await (0, scanner_1.readConfig)();
+        // 标准化路径（处理 ~ 符号）
+        const expandedPath = projectPath.startsWith('~')
+            ? path.join(os.homedir(), projectPath.slice(1))
+            : projectPath;
+        const absolutePath = path.resolve(expandedPath);
+        // 检查路径是否存在
+        const isValid = await fs.pathExists(absolutePath);
+        // 获取项目的配置信息（如果存在）
+        const projectConfig = config.projects[absolutePath];
+        // 显示项目基本信息
+        console.log(chalk_1.default.bold('\n项目信息:'));
+        console.log(`  路径: ${absolutePath}`);
+        console.log(`  状态: ${isValid ? chalk_1.default.green('有效') : chalk_1.default.red('无效')}`);
+        if (projectConfig) {
+            console.log(`  最后会话: ${projectConfig.lastSessionId || 'N/A'}`);
+            console.log(`  花费: $${projectConfig.lastCost?.toFixed(4) || 0}`);
+        }
+        else {
+            console.log(`  配置状态: ${chalk_1.default.yellow('未在 claude.json 中注册')}`);
+        }
+        // 如果指定了 --resume，显示 resume 历史
+        if (options.resume) {
+            const resumeInfos = await (0, scanner_1.getProjectResumeInfo)(absolutePath);
+            console.log(chalk_1.default.bold(`\nResume 历史 (${resumeInfos.length} 个会话):\n`));
+            if (resumeInfos.length === 0) {
+                console.log(chalk_1.default.gray('  无 resume 记录'));
+            }
+            else {
+                resumeInfos.forEach((info, index) => {
+                    const isLast = index === resumeInfos.length - 1;
+                    const connector = isLast ? '└── ' : '├── ';
+                    const sessionIdStr = chalk_1.default.cyan(`[${info.sessionId}]`);
+                    const createdStr = chalk_1.default.gray(`创建: ${(0, scanner_1.formatRelativeTime)(info.createdAt.getTime())}`);
+                    const lastActivityStr = chalk_1.default.gray(`最后活动: ${(0, scanner_1.formatRelativeTime)(info.lastActivity.getTime())}`);
+                    const messagesStr = chalk_1.default.yellow(`${info.messageCount} 条消息`);
+                    const compactStr = info.compactCount > 0 ? chalk_1.default.magenta(` (${info.compactCount} 次压缩)`) : '';
+                    const sizeStr = chalk_1.default.gray((0, backup_1.formatFileSize)(info.fileSize));
+                    console.log(`  ${connector}${sessionIdStr}`);
+                    console.log(`      ${createdStr}`);
+                    console.log(`      ${lastActivityStr}`);
+                    console.log(`      ${messagesStr}${compactStr} | ${sizeStr}`);
+                });
+            }
+            console.log();
+        }
+        // 如果指定了 --sessions，显示会话历史
+        if (options.sessions) {
+            const sessions = await (0, scanner_1.readSessionHistory)();
+            const sessionsByProject = (0, scanner_1.groupSessionsByProject)(sessions);
+            const projectSessions = sessionsByProject.get(absolutePath) || [];
+            console.log(chalk_1.default.bold(`\n会话历史 (${projectSessions.length} 条):\n`));
+            if (projectSessions.length === 0) {
+                console.log(chalk_1.default.gray('  无会话记录'));
+                return;
+            }
+            // 显示所有会话
+            projectSessions.forEach((session, index) => {
+                const isLast = index === projectSessions.length - 1;
+                const connector = isLast ? '└── ' : '├── ';
+                const timeStr = chalk_1.default.gray(`[${(0, scanner_1.formatRelativeTime)(session.timestamp)}]`);
+                const sessionIdStr = chalk_1.default.cyan(`[${session.sessionId}]`);
+                const content = (0, scanner_1.truncateText)(session.display || '(空)', 50);
+                console.log(`  ${connector}${timeStr} ${sessionIdStr} ${content}`);
+            });
+            // 如果指定了 --delete-sessions，删除选中的会话
+            if (options.deleteSessions) {
+                console.log();
+                const selectedSessions = await (0, prompts_1.checkbox)({
+                    message: '选择要删除的会话（空格选择，回车确认）:',
+                    choices: projectSessions.map(s => ({
+                        name: `[${(0, scanner_1.formatRelativeTime)(s.timestamp)}] ${(0, scanner_1.truncateText)(s.display || '(空)', 40)}`,
+                        value: s.sessionId,
+                    })),
+                    pageSize: 20,
+                    theme: {
+                        style: {
+                            keysHelpTip: () => undefined,
+                        },
+                    },
+                });
+                if (selectedSessions.length === 0) {
+                    console.log(chalk_1.default.yellow('未选择任何会话，操作已取消'));
+                    return;
+                }
+                const confirmedDeleteSessions = await (0, prompts_1.confirm)({
+                    message: chalk_1.default.red(`确认删除选中的 ${selectedSessions.length} 条会话记录？`),
+                    default: false,
+                });
+                if (!confirmedDeleteSessions) {
+                    console.log(chalk_1.default.yellow('操作已取消'));
+                    return;
+                }
+                const deletedCount = await (0, scanner_1.deleteSessions)(new Set(selectedSessions));
+                console.log(chalk_1.default.green(`✓ 成功删除 ${deletedCount} 条会话记录！`));
+            }
+        }
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`错误: ${error.message}`));
+        process.exit(1);
+    }
+});
+function createSpinner(text) {
+    let spinner = null;
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let index = 0;
+    return {
+        start: () => {
+            process.stdout.write(`${frames[0]} ${text}`);
+            spinner = setInterval(() => {
+                index = (index + 1) % frames.length;
+                process.stdout.write(`\r${frames[index]} ${text}`);
+            }, 80);
+        },
+        stop: () => {
+            if (spinner) {
+                clearInterval(spinner);
+                process.stdout.write(`\r✓ ${text}\n`);
+            }
+        },
+    };
+}
+function printScanResult(result) {
+    console.log(chalk_1.default.bold('\n扫描结果:'));
+    console.log(`  总项目数: ${result.totalCount}`);
+    console.log(chalk_1.default.green(`  有效项目: ${result.validCount}`));
+    console.log(chalk_1.default.red(`  无效项目: ${result.invalidCount}`));
+    if (result.invalidProjects.length > 0) {
+        console.log(chalk_1.default.red.bold('\n无效项目列表:'));
+        result.invalidProjects.forEach((project, index) => {
+            console.log(`  ${index + 1}. ${chalk_1.default.red(project)}`);
+        });
+    }
+}
+function printSummary(result) {
+    console.log(chalk_1.default.bold('\n汇总:'));
+    console.log(`  ${chalk_1.default.green('✓')} 有效: ${result.validCount}`);
+    console.log(`  ${chalk_1.default.red('✗')} 无效: ${result.invalidCount}`);
+    console.log(`  总计: ${result.totalCount}`);
+    if (result.invalidCount > 0) {
+        console.log(chalk_1.default.yellow(`\n提示: 使用 ${chalk_1.default.cyan('lcch projects clean')} 清理无效项目`));
+    }
+}
+/**
+ * 获取单个项目的详细统计信息
+ */
+async function getProjectStats(config, projectPath, isValid) {
+    const projectConfig = config.projects[projectPath];
+    // 基础信息
+    const stats = {
+        projectPath,
+        isValid,
+        cost: projectConfig?.lastCost || 0,
+        resumes: 0,
+        sessions: 0,
+        mcpServers: projectConfig?.mcpServers ? Object.keys(projectConfig.mcpServers).length : 0,
+        skills: 0,
+        hooks: 0,
+        diskUsage: 0,
+        inputTokens: projectConfig?.lastTotalInputTokens || 0,
+        outputTokens: projectConfig?.lastTotalOutputTokens || 0,
+    };
+    // 获取 resume 数量和磁盘占用
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    const normalizedPath = projectPath.replace(/\//g, '-');
+    const projectDir = path.join(projectsDir, normalizedPath);
+    if (await fs.pathExists(projectDir)) {
+        const entries = await fs.readdir(projectDir, { withFileTypes: true });
+        stats.resumes = entries.filter(e => e.isFile() && e.name.endsWith('.jsonl')).length;
+        // 计算磁盘占用
+        let totalSize = 0;
+        for (const entry of entries) {
+            if (entry.isFile()) {
+                const filePath = path.join(projectDir, entry.name);
+                const fileStat = await fs.stat(filePath);
+                totalSize += fileStat.size;
+            }
+        }
+        stats.diskUsage = totalSize;
+    }
+    // 获取会话数量
+    const historyPath = path.join(os.homedir(), '.claude', 'history.jsonl');
+    if (await fs.pathExists(historyPath)) {
+        const content = await fs.readFile(historyPath, 'utf-8');
+        const lines = content.trim().split('\n').filter(line => line.trim());
+        for (const line of lines) {
+            try {
+                const record = JSON.parse(line);
+                if (record.project === projectPath) {
+                    stats.sessions++;
+                }
+            }
+            catch {
+                // 忽略
+            }
+        }
+    }
+    // 获取 skills 数量（从项目级 settings）
+    const projectSettingsPath = path.join(projectPath, '.claude', 'settings.json');
+    if (await fs.pathExists(projectSettingsPath)) {
+        try {
+            const settingsContent = await fs.readFile(projectSettingsPath, 'utf-8');
+            const settings = JSON.parse(settingsContent);
+            if (settings.skills) {
+                stats.skills = Object.keys(settings.skills).length;
+            }
+            // 获取 hooks 数量
+            if (settings.hooks) {
+                let hookCount = 0;
+                for (const eventHooks of Object.values(settings.hooks)) {
+                    if (Array.isArray(eventHooks)) {
+                        for (const hookGroup of eventHooks) {
+                            if (hookGroup.hooks && Array.isArray(hookGroup.hooks)) {
+                                hookCount += hookGroup.hooks.length;
+                            }
+                        }
+                    }
+                }
+                stats.hooks = hookCount;
+            }
+        }
+        catch {
+            // 忽略
+        }
+    }
+    return stats;
+}
+/**
+ * 打印项目树（详细信息）
+ */
+async function printProjectTreeVerbose(config, result) {
+    const allProjects = [...result.validProjects, ...result.invalidProjects];
+    if (allProjects.length === 0) {
+        console.log(chalk_1.default.yellow('没有项目'));
+        return;
+    }
+    console.log(chalk_1.default.bold(`\n共 ${result.totalCount} 个项目（详细信息）:\n`));
+    // 收集所有项目的统计信息
+    const projectStatsMap = new Map();
+    const validSet = new Set(result.validProjects);
+    const invalidSet = new Set(result.invalidProjects);
+    // 批量收集统计信息
+    for (const projectPath of allProjects) {
+        const isValid = validSet.has(projectPath);
+        const stats = await getProjectStats(config, projectPath, isValid);
+        projectStatsMap.set(projectPath, stats);
+    }
+    // 构建树结构
+    const tree = (0, scanner_1.buildProjectTree)(allProjects);
+    // 打印树形结构
+    printProjectTreeVerboseRecursive(tree, '', true, projectStatsMap, validSet, invalidSet);
+    // 打印汇总
+    printTreeVerboseSummary(projectStatsMap, result);
+}
+/**
+ * 递归打印项目树（详细信息）
+ */
+function printProjectTreeVerboseRecursive(tree, prefix = '', isLast = true, projectStatsMap, validProjects, invalidProjects) {
+    const entries = Array.from(tree.entries());
+    for (let i = 0; i < entries.length; i++) {
+        const [name, value] = entries[i];
+        const isLastItem = i === entries.length - 1;
+        const connector = isLastItem ? '└── ' : '├── ';
+        const childPrefix = isLastItem ? '    ' : '│   ';
+        if (value && typeof value === 'object' && value._isLeaf) {
+            // 叶子节点（项目）
+            const fullPath = value._fullPath;
+            const stats = projectStatsMap.get(fullPath);
+            if (stats) {
+                const statusIcon = stats.isValid ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+                // 构建统计信息字符串（使用管道分隔）
+                const statParts = [];
+                // 花费
+                const costStr = stats.cost > 0
+                    ? chalk_1.default.yellow(`花费: $${stats.cost.toFixed(2)}`)
+                    : chalk_1.default.gray('花费: $0.00');
+                statParts.push(costStr);
+                // Resume
+                const resumeStr = stats.resumes > 0
+                    ? chalk_1.default.cyan(`Resume: ${stats.resumes}`)
+                    : chalk_1.default.gray('Resume: 0');
+                statParts.push(resumeStr);
+                // 会话
+                const sessionStr = stats.sessions > 0
+                    ? chalk_1.default.cyan(`会话: ${stats.sessions}`)
+                    : chalk_1.default.gray('会话: 0');
+                statParts.push(sessionStr);
+                // MCP
+                const mcpStr = stats.mcpServers > 0
+                    ? chalk_1.default.magenta(`MCP: ${stats.mcpServers}`)
+                    : chalk_1.default.gray('MCP: 0');
+                statParts.push(mcpStr);
+                // Skills
+                const skillStr = stats.skills > 0
+                    ? chalk_1.default.green(`Skills: ${stats.skills}`)
+                    : chalk_1.default.gray('Skills: 0');
+                statParts.push(skillStr);
+                // Hooks
+                const hooksStr = stats.hooks > 0
+                    ? chalk_1.default.magenta(`Hooks: ${stats.hooks}`)
+                    : chalk_1.default.gray('Hooks: 0');
+                statParts.push(hooksStr);
+                // 磁盘
+                const diskStr = stats.diskUsage > 0
+                    ? chalk_1.default.yellow(`磁盘: ${(0, backup_1.formatFileSize)(stats.diskUsage)}`)
+                    : chalk_1.default.gray('磁盘: 0 B');
+                statParts.push(diskStr);
+                console.log(`${prefix}${connector}${name} ${statusIcon}`);
+                console.log(`${prefix}${childPrefix}  ${statParts.join(' | ')}`);
+            }
+        }
+        else if (value instanceof Map) {
+            // 目录节点
+            console.log(`${prefix}${connector}${chalk_1.default.white(name)}`);
+            printProjectTreeVerboseRecursive(value, prefix + childPrefix, isLastItem, projectStatsMap, validProjects, invalidProjects);
+        }
+    }
+}
+/**
+ * 打印树形详细信息的汇总
+ */
+function printTreeVerboseSummary(projectStatsMap, result) {
+    let totalCost = 0;
+    let totalResumes = 0;
+    let totalSessions = 0;
+    let totalMcp = 0;
+    let totalSkills = 0;
+    let totalHooks = 0;
+    let totalDisk = 0;
+    for (const stats of projectStatsMap.values()) {
+        totalCost += stats.cost;
+        totalResumes += stats.resumes;
+        totalSessions += stats.sessions;
+        totalMcp += stats.mcpServers;
+        totalSkills += stats.skills;
+        totalHooks += stats.hooks;
+        totalDisk += stats.diskUsage;
+    }
+    console.log();
+    console.log(chalk_1.default.bold('─────────────────────────────────────'));
+    console.log(chalk_1.default.bold('  汇总'));
+    console.log(chalk_1.default.bold('─────────────────────────────────────'));
+    console.log(`  ${chalk_1.default.green('✓')} 有效项目: ${result.validCount}`);
+    console.log(`  ${chalk_1.default.red('✗')} 无效项目: ${result.invalidCount}`);
+    console.log(`  ${chalk_1.default.yellow('花费:')} $${totalCost.toFixed(4)}`);
+    console.log(`  ${chalk_1.default.cyan('Resume:')} ${totalResumes}`);
+    console.log(`  ${chalk_1.default.cyan('会话:')} ${totalSessions}`);
+    console.log(`  ${chalk_1.default.magenta('MCP:')} ${totalMcp}`);
+    console.log(`  ${chalk_1.default.green('Skills:')} ${totalSkills}`);
+    console.log(`  ${chalk_1.default.magenta('Hooks:')} ${totalHooks}`);
+    console.log(`  ${chalk_1.default.yellow('磁盘:')} ${(0, backup_1.formatFileSize)(totalDisk)}`);
+    console.log(chalk_1.default.bold('─────────────────────────────────────'));
+    console.log();
+}
+/**
+ * 打印项目列表（详细信息）
+ */
+async function printProjectListVerbose(config, result) {
+    const allProjects = [...result.validProjects, ...result.invalidProjects];
+    if (allProjects.length === 0) {
+        console.log(chalk_1.default.yellow('没有项目'));
+        return;
+    }
+    console.log(chalk_1.default.bold(`\n共 ${result.totalCount} 个项目（详细信息）:\n`));
+    // 收集所有项目的统计信息
+    const projectStatsMap = new Map();
+    const validSet = new Set(result.validProjects);
+    const invalidSet = new Set(result.invalidProjects);
+    // 批量收集统计信息
+    for (const projectPath of allProjects) {
+        const isValid = validSet.has(projectPath);
+        const stats = await getProjectStats(config, projectPath, isValid);
+        projectStatsMap.set(projectPath, stats);
+    }
+    // 按花费排序
+    const sortedProjects = [...projectStatsMap.values()].sort((a, b) => b.cost - a.cost);
+    // 按状态分组
+    const validProjects = sortedProjects.filter(p => p.isValid);
+    const invalidProjects = sortedProjects.filter(p => !p.isValid);
+    // 打印有效项目
+    if (validProjects.length > 0) {
+        console.log(chalk_1.default.green.bold(`✓ 有效项目 (${validProjects.length}):`));
+        for (const stats of validProjects) {
+            const costStr = stats.cost > 0
+                ? chalk_1.default.yellow(`花费: $${stats.cost.toFixed(2)}`)
+                : chalk_1.default.gray('花费: $0.00');
+            const resumeStr = stats.resumes > 0
+                ? chalk_1.default.cyan(`Resume: ${stats.resumes}`)
+                : chalk_1.default.gray('Resume: 0');
+            const sessionStr = stats.sessions > 0
+                ? chalk_1.default.cyan(`会话: ${stats.sessions}`)
+                : chalk_1.default.gray('会话: 0');
+            const mcpStr = stats.mcpServers > 0
+                ? chalk_1.default.magenta(`MCP: ${stats.mcpServers}`)
+                : chalk_1.default.gray('MCP: 0');
+            const skillStr = stats.skills > 0
+                ? chalk_1.default.green(`Skills: ${stats.skills}`)
+                : chalk_1.default.gray('Skills: 0');
+            const hooksStr = stats.hooks > 0
+                ? chalk_1.default.magenta(`Hooks: ${stats.hooks}`)
+                : chalk_1.default.gray('Hooks: 0');
+            const diskStr = stats.diskUsage > 0
+                ? chalk_1.default.yellow(`磁盘: ${(0, backup_1.formatFileSize)(stats.diskUsage)}`)
+                : chalk_1.default.gray('磁盘: 0 B');
+            console.log(`  ${chalk_1.default.green('✓')} ${chalk_1.default.white(stats.projectPath)}`);
+            console.log(`      ${[costStr, resumeStr, sessionStr, mcpStr, skillStr, hooksStr, diskStr].join(' | ')}`);
+        }
+        console.log();
+    }
+    // 打印无效项目
+    if (invalidProjects.length > 0) {
+        console.log(chalk_1.default.red.bold(`✗ 无效项目 (${invalidProjects.length}):`));
+        for (const stats of invalidProjects) {
+            const costStr = stats.cost > 0
+                ? chalk_1.default.yellow(`花费: $${stats.cost.toFixed(2)}`)
+                : chalk_1.default.gray('花费: $0.00');
+            const resumeStr = stats.resumes > 0
+                ? chalk_1.default.cyan(`Resume: ${stats.resumes}`)
+                : chalk_1.default.gray('Resume: 0');
+            const sessionStr = stats.sessions > 0
+                ? chalk_1.default.cyan(`会话: ${stats.sessions}`)
+                : chalk_1.default.gray('会话: 0');
+            const mcpStr = stats.mcpServers > 0
+                ? chalk_1.default.magenta(`MCP: ${stats.mcpServers}`)
+                : chalk_1.default.gray('MCP: 0');
+            const skillStr = stats.skills > 0
+                ? chalk_1.default.green(`Skills: ${stats.skills}`)
+                : chalk_1.default.gray('Skills: 0');
+            const hooksStr = stats.hooks > 0
+                ? chalk_1.default.magenta(`Hooks: ${stats.hooks}`)
+                : chalk_1.default.gray('Hooks: 0');
+            const diskStr = stats.diskUsage > 0
+                ? chalk_1.default.yellow(`磁盘: ${(0, backup_1.formatFileSize)(stats.diskUsage)}`)
+                : chalk_1.default.gray('磁盘: 0 B');
+            console.log(`  ${chalk_1.default.red('✗')} ${chalk_1.default.gray(stats.projectPath)}`);
+            console.log(`      ${[costStr, resumeStr, sessionStr, mcpStr, skillStr, hooksStr, diskStr].join(' | ')}`);
+        }
+        console.log();
+    }
+    // 打印汇总
+    printTreeVerboseSummary(projectStatsMap, result);
+}
+/**
+ * 格式化数字（添加千分位分隔符）
+ */
+function formatNumber(num) {
+    if (num === 0)
+        return '0';
+    if (num < 1000)
+        return num.toString();
+    return num.toLocaleString('zh-CN');
+}
+// 运行程序
+commander_1.program.parse();