vscode-delfiles-by-search 0.0.2

package/src/cli/index.js

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const fs = require('fs');
+const path = require('path');
+const inquirer = require('inquirer');
+const clipboardy = require('clipboardy');
+const { parseFilePaths } = require('../core/parser');
+const { deleteFiles } = require('../core/file-manager');
+
+const program = new Command();
+
+program
+  .name('delfiles')
+  .description('从搜索结果字符串中提取文件路径并删除文件')
+  .version('0.0.1');
+
+program
+  .option('-s, --string <content>', '直接传入包含搜索结果的字符串')
+  .option('-f, --file <path>', '包含搜索结果的文件路径')
+  .option('-b, --base <path>', '基准目录路径', process.cwd())
+  .option('-i, --ignore <pattern>', '忽略的文件模式 (glob)，多个模式用逗号分隔')
+  .option('--no-interaction', '跳过交互式确认', false)
+  .option('-d, --dry-run', '模拟运行，不实际删除文件', false)
+  .option('--no-trash', '永久删除文件，不移动到回收站')
+  .option('-v, --verbose', '显示详细日志', false)
+  .action(async (options) => {
+    try {
+      let inputString = '';
+      let basePath = options.base ? path.resolve(options.base) : process.cwd();
+      let ignorePatterns = options.ignore ? options.ignore.split(',') : [];
+      let isDryRun = options.dryRun || false;
+      let moveToTrash = options.trash !== false;
+      let isInteractive = false;
+
+      // 1. 获取输入内容
+      if (options.string) {
+        // 优先使用命令行直接传入的字符串
+        inputString = options.string;
+      } else if (options.file) {
+        // 从文件读取
+        const filePath = path.resolve(process.cwd(), options.file);
+        if (!fs.existsSync(filePath)) {
+          console.error(`错误: 文件不存在: ${filePath}`);
+          process.exit(1);
+        }
+        inputString = fs.readFileSync(filePath, 'utf-8');
+      } else if (process.stdin.isTTY) {
+        // 如果是 TTY 且没有指定文件或字符串，进入交互模式
+        isInteractive = true;
+        console.log('--- 进入交互式模式 ---');
+        
+        // 尝试从剪贴板读取内容
+        let clipboardContent = '';
+        try {
+          clipboardContent = await clipboardy.read();
+        } catch (err) {
+          // 忽略剪贴板读取错误
+        }
+
+        const choices = [
+            { name: '从文件读取搜索结果 (-f)', value: 'file' },
+            { name: '直接粘贴/输入搜索结果文本', value: 'string' }
+        ];
+
+        if (clipboardContent && clipboardContent.trim().length > 0) {
+            choices.unshift({ 
+                name: `使用剪贴板内容 (${clipboardContent.trim().substring(0, 30).replace(/\n/g, ' ')}...)`, 
+                value: 'clipboard' 
+            });
+        }
+
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'inputType',
+                message: '请选择输入方式:',
+                choices: choices
+            },
+            {
+                type: 'editor',
+                name: 'searchString',
+                message: '请输入需要搜索的字符串（-s），保存并关闭以继续:',
+                when: (answers) => answers.inputType === 'string',
+                validate: (input) => {
+                    if (input && input.trim().length > 0) return true;
+                    return '内容不能为空';
+                }
+            },
+            {
+                type: 'input',
+                name: 'filePath',
+                message: '请输入文件路径:',
+                when: (answers) => answers.inputType === 'file',
+                validate: (input) => {
+                    if (fs.existsSync(input.trim())) return true;
+                    return '文件不存在，请重新输入';
+                }
+            },
+            {
+                type: 'input',
+                name: 'basePath',
+                message: '请输入基准目录路径:',
+                default: process.cwd(),
+                validate: (input) => {
+                     if (fs.existsSync(input.trim()) && fs.statSync(input.trim()).isDirectory()) return true;
+                     return '目录不存在，请重新输入';
+                }
+            },
+            {
+                type: 'input',
+                name: 'ignore',
+                message: '请输入忽略规则 (Glob模式，多个用逗号分隔，可选):',
+            },
+            {
+                type: 'confirm',
+                name: 'dryRun',
+                message: '是否仅模拟运行 (Dry Run)?',
+                default: true
+            },
+            {
+                type: 'confirm',
+                name: 'moveToTrash',
+                message: '是否移动到回收站 (否则永久删除)?',
+                default: true,
+                when: (answers) => !answers.dryRun
+            }
+         ]);
+
+         if (answers.inputType === 'file') {
+             inputString = fs.readFileSync(answers.filePath.trim(), 'utf-8');
+         } else if (answers.inputType === 'clipboard') {
+             inputString = clipboardContent;
+             console.log('已读取剪贴板内容。');
+         } else {
+             inputString = answers.searchString;
+         }
+         
+         basePath = path.resolve(answers.basePath.trim());
+         if (answers.ignore && answers.ignore.trim()) {
+             ignorePatterns = answers.ignore.split(',').map(p => p.trim());
+         }
+         isDryRun = answers.dryRun;
+         if (!isDryRun) {
+             moveToTrash = answers.moveToTrash;
+         }
+
+      } else {
+        // 尝试从标准输入读取（支持管道）
+        // 这里不需要提示，因为非 TTY 意味着正在通过管道传输
+        inputString = await readStdin();
+      }
+
+      if (!inputString || inputString.trim() === '') {
+        console.error('错误: 输入内容为空');
+        process.exit(1);
+      }
+
+      // 2. 解析文件路径
+      let filePaths = parseFilePaths(inputString);
+      console.log(`解析到 ${filePaths.length} 个文件路径`);
+
+      if (filePaths.length === 0) {
+        console.log('未找到任何文件路径，退出。');
+        process.exit(0);
+      }
+
+      if (options.verbose) {
+        console.log('解析到的文件:', filePaths);
+      }
+
+      // 3. 交互式文件过滤
+      if (isInteractive && options.interaction !== false) {
+          const { selectedFiles } = await inquirer.prompt([
+              {
+                  type: 'checkbox',
+                  name: 'selectedFiles',
+                  message: '请选择要删除的文件 (空格键选择/取消，Enter 确认):',
+                  choices: filePaths.map(file => ({ name: file, checked: true })),
+                  pageSize: 20
+              }
+          ]);
+          
+          if (selectedFiles.length !== filePaths.length) {
+              filePaths = selectedFiles;
+              console.log(`已过滤，将处理 ${filePaths.length} 个文件。`);
+          }
+      }
+
+      // 4. 确认删除（如果是交互式终端且不是 dry-run 且之前未经过交互式确认）
+      if (!isDryRun && process.stdout.isTTY && !isInteractive) {
+        const { confirm } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: `即将对 ${filePaths.length} 个文件执行删除操作 (基准路径: ${basePath})，确定吗?`,
+            default: false
+        }]);
+        
+        if (!confirm) {
+            console.log('操作已取消');
+            process.exit(0);
+        }
+      }
+
+      // 5. 执行删除
+      const result = await deleteFiles(filePaths, {
+        basePath,
+        dryRun: isDryRun,
+        moveToTrash, 
+        logger: console.log,
+        ignorePatterns
+      });
+
+      // 5. 输出结果摘要
+      if (result.errors.length > 0) {
+        console.error('\n错误列表:');
+        result.errors.forEach(err => console.error(`- ${err.file}: ${err.error}`));
+      }
+
+    } catch (error) {
+      console.error('发生未知错误:', error);
+      process.exit(1);
+    }
+  });
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    const stdin = process.stdin;
+
+    if (stdin.isTTY) {
+        // 如果是 TTY，且没有参数传入文件，则等待用户输入
+        // 这里只是简单的处理，对于交互式 CLI 应该有更好的提示
+    }
+
+    stdin.on('data', chunk => {
+      data += chunk;
+    });
+
+    stdin.on('end', () => {
+      resolve(data);
+    });
+
+    stdin.on('error', err => {
+      reject(err);
+    });
+  });
+}
+
+// 导出以便测试或模块调用
+module.exports = {
+    program
+};
+
+// 如果直接执行
+if (require.main === module) {
+  program.parse(process.argv);
+}

package/src/core/file-manager.js

@@ -0,0 +1,158 @@
+
+const fs = require('fs');
+const path = require('path');
+const { promisify } = require('util');
+const minimatch = require('minimatch');
+
+// 使用动态导入加载 trash，因为它是纯 ESM 包
+async function loadTrash() {
+    try {
+        const trashModule = await import('trash');
+        return trashModule.default;
+    } catch (error) {
+        console.error('无法加载 trash 模块:', error);
+        throw error;
+    }
+}
+
+/**
+ * 检查文件是否存在
+ * @param {string} filePath 
+ * @returns {Promise<boolean>}
+ */
+async function fileExists(filePath) {
+    try {
+        await fs.promises.access(filePath, fs.constants.F_OK);
+        return true;
+    } catch (error) {
+        return false;
+    }
+}
+
+/**
+ * 删除文件操作的结果
+ * @typedef {Object} DeleteResult
+ * @property {string[]} success - 成功删除的文件列表
+ * @property {string[]} failed - 删除失败的文件列表
+ * @property {string[]} skipped - 跳过的文件列表（例如不存在）
+ * @property {Object[]} errors - 错误详情列表 { file: string, error: string }
+ */
+
+/**
+ * 执行文件删除操作
+ * @param {string[]} relativePaths - 相对路径列表
+ * @param {Object} options - 配置选项
+ * @param {string} options.basePath - 基础路径
+ * @param {boolean} [options.dryRun=false] - 是否模拟运行
+ * @param {boolean} [options.moveToTrash=true] - 是否移动到回收站
+ * @param {Function} [options.logger=console.log] - 日志记录函数
+ * @param {string[]} [options.ignorePatterns=[]] - 忽略的文件模式列表
+ * @returns {Promise<DeleteResult>}
+ */
+async function deleteFiles(relativePaths, options) {
+    const {
+        basePath,
+        dryRun = false,
+        moveToTrash = true,
+        logger = console.log,
+        ignorePatterns = []
+    } = options;
+
+    if (!basePath) {
+        throw new Error('必须指定 basePath');
+    }
+
+    // 尝试加载 .gitignore
+    let gitignorePatterns = [];
+    try {
+        const gitignorePath = path.join(basePath, '.gitignore');
+        if (await fileExists(gitignorePath)) {
+            const content = await fs.promises.readFile(gitignorePath, 'utf-8');
+            gitignorePatterns = content
+                .split('\n')
+                .map(line => line.trim())
+                .filter(line => line && !line.startsWith('#'));
+        }
+    } catch (err) {
+        logger(`[WARN] 无法读取 .gitignore: ${err.message}`);
+    }
+
+    const allIgnorePatterns = [...ignorePatterns, ...gitignorePatterns];
+
+    const result = {
+        success: [],
+        failed: [],
+        skipped: [],
+        errors: []
+    };
+
+    const trash = moveToTrash ? await loadTrash() : null;
+
+    logger(`开始处理 ${relativePaths.length} 个文件...`);
+    logger(`基准路径: ${basePath}`);
+    logger(`模式: ${dryRun ? '模拟运行 (Dry Run)' : '实际执行'}`);
+    logger(`删除方式: ${moveToTrash ? '移动到回收站' : '永久删除'}`);
+    if (allIgnorePatterns.length > 0) {
+        logger(`忽略规则: ${allIgnorePatterns.join(', ')}`);
+    }
+
+    for (const relativePath of relativePaths) {
+        // 检查忽略规则
+        if (allIgnorePatterns.length > 0) {
+            const isIgnored = allIgnorePatterns.some(pattern => minimatch(relativePath, pattern, { dot: true }));
+            if (isIgnored) {
+                logger(`[IGNORE] 已忽略: ${relativePath}`);
+                result.skipped.push(relativePath);
+                continue;
+            }
+        }
+
+        const absolutePath = path.resolve(basePath, relativePath);
+        
+        // 安全检查：确保路径在 basePath 内，防止路径遍历攻击
+        if (!absolutePath.startsWith(path.resolve(basePath))) {
+            const errorMsg = `路径非法（超出基准路径范围）: ${relativePath}`;
+            logger(`[ERROR] ${errorMsg}`);
+            result.failed.push(relativePath);
+            result.errors.push({ file: relativePath, error: errorMsg });
+            continue;
+        }
+
+        try {
+            const exists = await fileExists(absolutePath);
+            if (!exists) {
+                logger(`[SKIP] 文件不存在: ${relativePath}`);
+                result.skipped.push(relativePath);
+                continue;
+            }
+
+            if (dryRun) {
+                logger(`[DRY-RUN] 将删除: ${relativePath}`);
+                result.success.push(relativePath);
+            } else {
+                if (moveToTrash && trash) {
+                    await trash(absolutePath);
+                    logger(`[TRASH] 已移至回收站: ${relativePath}`);
+                } else {
+                    await fs.promises.unlink(absolutePath);
+                    logger(`[DELETE] 已永久删除: ${relativePath}`);
+                }
+                result.success.push(relativePath);
+            }
+        } catch (error) {
+            const errorMsg = error.message;
+            logger(`[FAIL] 删除失败: ${relativePath} - ${errorMsg}`);
+            result.failed.push(relativePath);
+            result.errors.push({ file: relativePath, error: errorMsg });
+        }
+    }
+
+    logger('--- 处理完成 ---');
+    logger(`成功: ${result.success.length}, 失败: ${result.failed.length}, 跳过: ${result.skipped.length}`);
+    
+    return result;
+}
+
+module.exports = {
+    deleteFiles
+};

package/src/core/parser.js

@@ -0,0 +1,95 @@
+
+/**
+ * 解析包含文件路径的搜索结果字符串
+ * @param {string} inputString - 输入的长字符串
+ * @returns {string[]} - 提取出的文件路径列表（去重）
+ */
+function parseFilePaths(inputString) {
+    if (!inputString || typeof inputString !== 'string') {
+        return [];
+    }
+
+    const lines = inputString.split('\n');
+    const filePaths = new Set();
+
+    // 正则表达式匹配文件路径
+    // 特征：
+    // 1. 行首可能有空白字符
+    // 2. 路径部分不包含空白字符（或者是为了支持带空格的路径，可以放宽）
+    // 3. 必须以冒号结尾
+    // 4. 通常包含文件扩展名（可选，但有助于过滤误报）
+    // 5. 排除常见的代码行特征（如 function, var, const, if 等，虽然正则匹配结尾冒号已经过滤了大部分）
+    
+    // 针对用户提供的示例： __APP___uni/141.js:
+    // 我们可以放宽一点，允许路径中有除了冒号和换行符以外的字符
+    // 但是通常文件路径不会包含双引号、单引号、括号等代码符号
+    
+    // 改进的正则：
+    // ^\s*                 : 行首空白
+    // (                    : 捕获组开始
+    //   .+?                : 非贪婪匹配任意字符
+    // )                    : 捕获组结束
+    // (:)?                 : 可选的冒号
+    // \s*$                 : 行尾空白
+    
+    // 我们不仅匹配以冒号结尾的行，也尝试匹配看起来像路径的行
+    // 但这会增加误报风险，所以后续的过滤条件需要更严格
+    // 注意：这里的正则比较宽泛，主要靠后续的逻辑过滤
+    const pathRegex = /^\s*(.+?)(:)?\s*$/;
+
+    for (const line of lines) {
+        // 忽略空行
+        if (!line || line.trim() === '') continue;
+
+        // 忽略明显是统计信息的行，如 "274 个结果 - 137 文件"
+        if (line.includes('个结果') && line.includes('文件')) {
+            continue;
+        }
+
+        const match = line.match(pathRegex);
+        if (match) {
+            let pathCandidate = match[1].trim();
+            
+            // 去除可能的行尾冒号
+            if (pathCandidate.endsWith(':')) {
+                pathCandidate = pathCandidate.slice(0, -1);
+            }
+            
+            // 过滤掉明显不是路径的行
+            // 1. 必须包含路径分隔符 (/ 或 \) 或者包含点 (.) 且看起来像文件扩展名
+            // 2. 排除包含代码特征字符的行
+            const hasPathChars = pathCandidate.includes('/') || pathCandidate.includes('\\');
+            const hasExtension = pathCandidate.includes('.') && pathCandidate.lastIndexOf('.') > pathCandidate.lastIndexOf('/');
+            
+            if (!hasPathChars && !hasExtension) continue;
+
+            // 排除常见的代码结构字符
+            const invalidChars = ['(', ')', '=', '{', '}', ';', '<', '>', '[', ']'];
+            if (invalidChars.some(char => pathCandidate.includes(char))) continue;
+            
+            // 排除注释
+            if (pathCandidate.startsWith('//') || pathCandidate.startsWith('*') || pathCandidate.startsWith('/*')) continue;
+
+            // 排除纯数字（行号）
+            if (/^\d+$/.test(pathCandidate)) continue;
+            
+            // 排除纯文本描述
+            // 1. 如果没有扩展名，且包含空格，视为无效
+            if (!hasExtension && pathCandidate.includes(' ')) continue;
+            // 2. 如果以大写字母开头且不包含斜杠（通常是句子），视为无效
+            if (/^[A-Z]/.test(pathCandidate) && !hasPathChars) continue;
+
+            // 排除常见的保留字开头的行（虽然上面符号过滤已经能过滤大部分，但双重保险）
+            const reservedWords = ['import ', 'export ', 'const ', 'let ', 'var ', 'function ', 'class ', 'if ', 'for ', 'while ', 'return '];
+            if (reservedWords.some(word => pathCandidate.startsWith(word))) continue;
+
+            filePaths.add(pathCandidate);
+        }
+    }
+
+    return Array.from(filePaths);
+}
+
+module.exports = {
+    parseFilePaths
+};

package/src/core/searcher.js

@@ -0,0 +1,172 @@
+
+const fs = require('fs');
+const path = require('path');
+const ignore = require('ignore');
+const { promisify } = require('util');
+
+const readdirPromise = promisify(fs.readdir);
+const statPromise = promisify(fs.stat);
+const readFilePromise = promisify(fs.readFile);
+
+class Searcher {
+    constructor(basePath, regex, options = {}) {
+        this.basePath = basePath;
+        this.regex = regex;
+        this.options = options;
+        this.ignoreManager = ignore();
+        this.debug = false;
+        this.followNestedGitignore = options.followNestedGitignore || false;
+
+        // Initialize with default ignores if provided
+        if (options.ignorePatterns && Array.isArray(options.ignorePatterns)) {
+            this.ignoreManager.add(options.ignorePatterns);
+        }
+    }
+
+    setDebug(enable) {
+        this.debug = enable;
+    }
+
+    log(msg) {
+        if (this.debug) {
+            console.log(`[Searcher] ${msg}`);
+        }
+    }
+
+    warn(msg) {
+        console.warn(`[Searcher Warn] ${msg}`);
+    }
+
+    /**
+     * 初始化：同步读取 .gitignore
+     * 按照要求，尝试读取两个位置：
+     * 1. 源码目录下的 .gitignore (Literal requirement from prompt)
+     * 2. basePath 下的 .gitignore (Logical requirement for functionality)
+     */
+    init() {
+        // 1. 读取 basePath 下的 .gitignore (最常用场景)
+        this._loadGitignore(this.basePath);
+
+        // 2. 读取当前文件同目录下的 .gitignore (满足特定 Prompt 要求)
+        // 注意：这通常用于开发调试或特定规则注入
+        try {
+            const localGitignore = path.join(__dirname, '.gitignore');
+            if (fs.existsSync(localGitignore)) {
+                this._loadGitignore(__dirname, localGitignore);
+            }
+        } catch (e) {
+            // Ignore error for this specific path
+        }
+
+        if (this.debug) {
+            this.log('Ignore rules loaded.');
+        }
+    }
+
+    _loadGitignore(targetDir, filePath = null) {
+        const gitignorePath = filePath || path.join(targetDir, '.gitignore');
+        
+        if (fs.existsSync(gitignorePath)) {
+            try {
+                const content = fs.readFileSync(gitignorePath, 'utf-8');
+                // ignore 包会自动处理注释和空行
+                this.ignoreManager.add(content);
+                this.log(`Loaded .gitignore from ${gitignorePath}`);
+                if (this.debug) {
+                    const rules = content.split('\n').filter(l => l.trim() && !l.startsWith('#')).length;
+                    this.log(`Added ${rules} rules from ${gitignorePath}`);
+                }
+            } catch (err) {
+                this.warn(`Failed to read .gitignore at ${gitignorePath}: ${err.message}`);
+            }
+        } else {
+            this.log(`.gitignore not found at ${gitignorePath}`);
+        }
+    }
+
+    async search() {
+        this.init(); // Ensure rules are loaded
+        const results = [];
+        await this._walk(this.basePath, '', results);
+        return results;
+    }
+
+    /**
+     * 递归遍历目录
+     * @param {string} currentDir - 当前绝对路径
+     * @param {string} relativeDir - 相对于 basePath 的路径
+     * @param {string[]} results - 结果收集数组
+     */
+    async _walk(currentDir, relativeDir, results) {
+        let entries;
+        try {
+            entries = await readdirPromise(currentDir, { withFileTypes: true });
+        } catch (err) {
+            this.warn(`Failed to read directory ${currentDir}: ${err.message}`);
+            return;
+        }
+
+        for (const entry of entries) {
+            const entryName = entry.name;
+            // 构造相对于 basePath 的路径，用于 ignore 检查
+            // 注意：ignore 库期望的是相对路径，如 "node_modules" 或 "src/file.js"
+            const entryRelativePath = relativeDir ? path.join(relativeDir, entryName) : entryName;
+            
+            // 1. 检查是否被忽略
+            // ignore 库的 ignores 方法对目录需要特殊处理？
+            // 通常如果路径以 / 结尾，ignore 可能会视为目录，但在遍历中我们知道它是目录
+            // 这里我们直接传相对路径。ignore 库通常能处理 "dir" 和 "dir/"
+            
+            // 检测目录命中
+            if (entry.isDirectory()) {
+                // 为了匹配 logs/ 这样的规则，尝试加上 /
+                // 但 ignore 库通常只需路径即可匹配
+                if (this.ignoreManager.ignores(entryRelativePath) || this.ignoreManager.ignores(entryRelativePath + '/')) {
+                    if (this.debug) {
+                        console.log(`IGNORED: ${entryRelativePath}/ by rule`);
+                    }
+                    continue; // 剪枝：整棵子树跳过
+                }
+
+                // 递归
+                // TODO: Handle followNestedGitignore if needed (complex, skipping for now based on 'default false')
+                await this._walk(path.join(currentDir, entryName), entryRelativePath, results);
+            
+            } else if (entry.isFile()) {
+                // 检测文件命中
+                if (this.ignoreManager.ignores(entryRelativePath)) {
+                    if (this.debug) {
+                        console.log(`IGNORED: ${entryRelativePath} by rule`);
+                    }
+                    continue;
+                }
+
+                // 2. 读取内容并匹配正则
+                try {
+                    const content = await readFilePromise(path.join(currentDir, entryName), 'utf-8');
+                    if (this.regex.test(content)) {
+                        results.push(entryRelativePath);
+                    }
+                } catch (err) {
+                    // 读取失败（如二进制文件），忽略并记录警告
+                    // this.warn(`Failed to read file ${entryRelativePath}: ${err.message}`);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * 保持对外 API 兼容
+ */
+async function searchFiles(basePath, regex, ignorePatterns = []) {
+    const searcher = new Searcher(basePath, regex, { ignorePatterns });
+    // 可以通过环境变量或其他方式开启 debug，这里暂不开启
+    // searcher.setDebug(true); 
+    return await searcher.search();
+}
+
+module.exports = {
+    searchFiles,
+    Searcher // 导出类以便测试
+};