endef 2.0.3 → 2.0.5

package/README.md

@@ -2,7 +2,7 @@
 
 `endef` 是一个纯 Node.js 的文件旁路转换工具。
 
-它适合这样的场景：某些常见源码或文本后缀的文件在系统读取、复制、粘贴、编辑器打开时出现乱码或异常，但通过 Node.js 脚本读取仍然正常。`endef` 会先把目标文件内容写到同目录的 `.endef` 副本里，再通过临时 `.tar.gz` 恢复包解压回原文件名。
+它适合这样的场景：某些常见源码或文本后缀的文件在系统读取、复制、粘贴、编辑器打开时出现乱码或异常，但通过 Node.js 脚本读取仍然正常。`endef` 会先把目标文件内容写到同目录的 `.endef` 副本里，再用脚本批量删除原文件并把 `.endef` 改回原文件名。
 
 示例：
 
@@ -16,10 +16,10 @@ README.md -> README.md.endef -> README.md
 
 ## 特性
 
-- 纯 Node.js 实现，不依赖 Bash、find、xargs、grep 等 shell 工具
+- Node.js CLI，恢复阶段可自动调用 Bash 或 PowerShell 脚本
 - 默认旁路后缀为 `.endef`
 - `en` 默认转换所有匹配后缀的文件
-- `de` 会把 `.endef` 临时副本做成恢复包，解压回原文件名，再删除 `.endef`
+- `de` 会用脚本批量删除原文件，并把 `.endef` 临时副本改回原文件名
 - `pack` 会把恢复后的目录打包成 `.tar.gz`
 - 不引入生产依赖
 
@@ -41,7 +41,7 @@ npm install -g endef
 endef en /path/to/project
 ```
 
-通过临时恢复包解压回原文件名，并删除 `.endef`：
+用脚本批量删除原文件，并把 `.endef` 改回原文件名：
 
 ```bash
 endef de /path/to/project
@@ -82,11 +82,11 @@ endef all [directory] [options]
 
 `en` 会扫描目标目录，把匹配后缀的文件读取出来，并写成同目录的 `.endef` 副本。
 
-`de` 会扫描目标目录中的 `.endef` 文件，生成一个临时恢复包，把 `.endef` 内容映射回原文件名并解压，然后删除 `.endef` 副本。这个命令会直接修改文件，请在执行前确认目录和备份策略。
+`de` 会扫描目标目录中的 `.endef` 文件，并用外部脚本批量删除原文件、把 `.endef` 改回原文件名。默认模式是 `auto`：优先使用 Bash 的 `find + xargs -P`，没有 Bash 时在 Windows 上使用 PowerShell。这个命令会直接修改文件，请在执行前确认目录和备份策略。
 
 `pack` 会按当前配置扫描当前目录，把没有被 `excludeDirs` 排除的文件打包成 `.tar.gz`。如果输出文件已存在，会直接覆盖。
 
-`all` 会先执行 `en`，然后生成一次最终恢复包；这个包既会被解压回目录，也会作为最终 `.tar.gz` 保留下来，避免 `de` 和 `pack` 重复打包。
+`all` 会按顺序执行 `en`、`de`、`pack`，适合确认配置后一次性完成旁路转换、脚本恢复和打包。
 
 ## 参数
 
@@ -97,6 +97,8 @@ endef all [directory] [options]
 --exclude <list>      排除目录名，多个值用英文逗号分隔
 --concurrency <n>     并发文件操作数量
 --out <file>          压缩包输出名称
+--mode <mode>         de/all 恢复模式：auto、bash、powershell、node
+--verbose             输出处理明细
 ```
 
 示例：
@@ -166,13 +168,25 @@ endef all . --out recovered
 file.ext.endef
 ```
 
-通过临时恢复包解压为：
+恢复为：
 
 ```text
 file.ext
 ```
 
-`de` 会先生成临时 `.tar.gz` 恢复包，包内路径使用原文件名；随后解压这个恢复包覆盖原文件，解压成功后删除 `file.ext.endef` 和临时恢复包。这个行为符合工具的核心假设：原文件可能已经被异常内容污染，而 `.endef` 是通过旁路读取保存出来的可恢复内容。
+`de` 默认使用脚本恢复。`auto` 模式会优先尝试 Bash，因为 `find + xargs -P` 可以并行处理大量文件；如果没有 Bash，则在 Windows 上使用单个 PowerShell 进程批量处理。恢复时会把：
+
+```text
+file.ext.endef
+```
+
+改回：
+
+```text
+file.ext
+```
+
+如果 `file.ext` 已经存在，会先被删除。这个行为符合工具的核心假设：原文件可能已经被异常内容污染，而 `.endef` 是通过旁路读取保存出来的可恢复内容。
 
 ## 打包策略
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "endef",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "Recover text and source files through safe .endef sidecar copies.",
   "bin": {
     "endef": "bin/main.js"

package/src/config.js

@@ -35,7 +35,8 @@ const defaultConfig = {
   ],
   excludeDirs: ['node_modules', '.git', 'dist', '.next', '.nuxt', '.cache'],
   excludeFiles: ['.endef.json'],
-  concurrency: 32
+  concurrency: 32,
+  restoreMode: 'auto'
 }
 
 function loadConfig(cwd, explicitConfigFile, targetDirectory) {

package/src/de.js

@@ -1,48 +1,261 @@
 const fs = require('fs/promises')
 const path = require('path')
+const { execFile } = require('child_process')
+const { promisify } = require('util')
 const { defaultConfig } = require('./config')
-const {
-  collectRecoveryEntries,
-  createPackConfig,
-  extractTarGz,
-  removeSidecars,
-  writeTarGz
-} = require('./pack')
+
+const execFileAsync = promisify(execFile)
 
 async function restoreFiles(directory, options = {}) {
-  const config = createPackConfig(directory, {
+  const config = {
     ...defaultConfig,
-    ...options
-  })
-  const archivePath = path.join(config.directory, `.endef-restore-${Date.now()}.tar.gz`)
-  const entries = await collectRecoveryEntries(config, {
-    onlySidecars: true,
-    outputPath: archivePath
+    ...options,
+    directory: path.resolve(directory || process.cwd()),
+    restoreMode: options.restoreMode || 'auto'
+  }
+  const mode = await resolveRestoreMode(config.restoreMode)
+
+  if (mode === 'bash') {
+    return restoreWithBash(config)
+  }
+
+  if (mode === 'powershell') {
+    return restoreWithPowerShell(config)
+  }
+
+  return restoreWithNode(config)
+}
+
+async function resolveRestoreMode(mode) {
+  if (mode !== 'auto') {
+    return mode
+  }
+
+  if (await hasCommand('bash', ['--version'])) {
+    return 'bash'
+  }
+
+  if (process.platform === 'win32') {
+    return 'powershell'
+  }
+
+  return 'node'
+}
+
+async function hasCommand(command, args) {
+  try {
+    await execFileAsync(command, args, { windowsHide: true })
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+async function restoreWithBash(config) {
+  const root = await toBashPath(config.directory)
+  const excludeDirs = config.excludeDirs.join('\n')
+  const jobs = String(config.concurrency || 32)
+  const script = `
+set -e
+root=$1
+suffix=$2
+jobs=$3
+cd "$root"
+find_args=(.)
+while IFS= read -r dir; do
+  if [ -n "$dir" ]; then
+    find_args+=( -path "*/$dir" -prune -o )
+  fi
+done <<< "$ENDEF_EXCLUDE_DIRS"
+find_args+=( -type f -name "*$suffix" -print0 )
+find "\${find_args[@]}" | xargs -0 -r -P "$jobs" -I{} bash -c '
+  suffix="$1"
+  file="$2"
+  target="\${file%$suffix}"
+  rm -f -- "$target"
+  mv -f -- "$file" "$target"
+  printf "%s\\0" "$target"
+' _ "$suffix" {}
+`
+
+  const { stdout } = await execFileAsync('bash', ['-lc', script, '_', root, config.suffix, jobs], {
+    env: {
+      ...process.env,
+      ENDEF_EXCLUDE_DIRS: excludeDirs
+    },
+    maxBuffer: 1024 * 1024 * 64,
+    windowsHide: true
   })
+  const restoredFiles = splitNullSeparated(stdout)
+  const restored = restoredFiles.length
 
-  if (entries.length === 0) {
-    console.log('Done. restored=0, deleted=0, failed=0')
-    return {
-      restored: 0,
-      deleted: 0,
-      failed: 0
-    }
+  if (config.verbose) {
+    restoredFiles.forEach(file => {
+      console.log(`Restored: ${file}`)
+    })
+  }
+
+  console.log(`Done. mode=bash, restored=${restored}, failed=0`)
+  return {
+    mode: 'bash',
+    restored,
+    failed: 0
+  }
+}
+
+async function toBashPath(filePath) {
+  if (process.platform !== 'win32') {
+    return filePath
   }
 
   try {
-    await writeTarGz(config.directory, archivePath, entries)
-    const restored = await extractTarGz(archivePath, config.directory)
-    const deleted = await removeSidecars(config.directory, config)
-
-    console.log(`Done. restored=${restored}, deleted=${deleted}, failed=0`)
-    return {
-      restored,
-      deleted,
-      failed: 0
+    const { stdout } = await execFileAsync('bash', ['-lc', 'cygpath -u "$1"', '_', filePath], {
+      windowsHide: true
+    })
+
+    return stdout.trim() || filePath
+  } catch (error) {
+    return filePath
+  }
+}
+
+async function restoreWithPowerShell(config) {
+  const script = `
+$root = $env:ENDEF_ROOT
+$suffix = $env:ENDEF_SUFFIX
+$excludeText = $env:ENDEF_EXCLUDE_DIRS
+$excludeDirs = @()
+$verbose = $env:ENDEF_VERBOSE -eq '1'
+if ($excludeText) {
+  $excludeDirs = $excludeText -split "\\n" | Where-Object { $_ }
+}
+$restored = 0
+$restoredFiles = New-Object System.Collections.Generic.List[string]
+Get-ChildItem -LiteralPath $root -Recurse -File -Filter "*$suffix" | Where-Object {
+  $cleanRoot = $root.TrimEnd('\\', '/')
+  $relative = $_.FullName.Substring($cleanRoot.Length).TrimStart('\\', '/')
+  $parts = $relative -split '[\\\\/]'
+  $skip = $false
+  foreach ($dir in $excludeDirs) {
+    if ($parts -contains $dir) {
+      $skip = $true
+      break
     }
-  } finally {
-    await fs.rm(archivePath, { force: true })
   }
+  -not $skip
+} | ForEach-Object {
+  $target = $_.FullName.Substring(0, $_.FullName.Length - $suffix.Length)
+  Remove-Item -LiteralPath $target -Force -ErrorAction SilentlyContinue
+  Move-Item -LiteralPath $_.FullName -Destination $target -Force
+  $restored += 1
+  if ($verbose) {
+    $restoredFiles.Add($target)
+  }
+}
+if ($verbose) {
+  foreach ($file in $restoredFiles) {
+    Write-Output "Restored: $file"
+  }
+}
+Write-Output $restored
+`
+  const { stdout } = await execFileAsync(
+    'powershell.exe',
+    [
+      '-NoProfile',
+      '-NonInteractive',
+      '-ExecutionPolicy',
+      'Bypass',
+      '-Command',
+      script
+    ],
+    {
+      env: {
+        ...process.env,
+        ENDEF_ROOT: config.directory,
+        ENDEF_SUFFIX: config.suffix,
+        ENDEF_EXCLUDE_DIRS: config.excludeDirs.join('\n'),
+        ENDEF_VERBOSE: config.verbose ? '1' : ''
+      },
+      maxBuffer: 1024 * 1024 * 64,
+      windowsHide: true
+    }
+  )
+  const lines = stdout.trim().split(/\r?\n/).filter(Boolean)
+  const restored = Number(lines[lines.length - 1]) || 0
+
+  if (config.verbose) {
+    lines.slice(0, -1).forEach(line => {
+      console.log(line)
+    })
+  }
+
+  console.log(`Done. mode=powershell, restored=${restored}, failed=0`)
+  return {
+    mode: 'powershell',
+    restored,
+    failed: 0
+  }
+}
+
+async function restoreWithNode(config) {
+  const stats = {
+    restored: 0,
+    failed: 0
+  }
+
+  await restoreNodeDirectory(config.directory, config, stats)
+  console.log(`Done. mode=node, restored=${stats.restored}, failed=${stats.failed}`)
+  return {
+    mode: 'node',
+    restored: stats.restored,
+    failed: stats.failed
+  }
+}
+
+async function restoreNodeDirectory(directory, config, stats) {
+  const entries = await fs.readdir(directory, { withFileTypes: true })
+
+  await Promise.all(
+    entries.map(async entry => {
+      const filePath = path.join(directory, entry.name)
+
+      if (entry.isDirectory()) {
+        if (config.excludeDirs.includes(entry.name)) {
+          return
+        }
+
+        await restoreNodeDirectory(filePath, config, stats)
+        return
+      }
+
+      if (!entry.isFile() || !filePath.endsWith(config.suffix)) {
+        return
+      }
+
+      try {
+        const targetPath = filePath.slice(0, -config.suffix.length)
+        await fs.rm(targetPath, { force: true })
+        await fs.rename(filePath, targetPath)
+        stats.restored += 1
+        if (config.verbose) {
+          console.log(`Restored: ${targetPath}`)
+        }
+      } catch (error) {
+        stats.failed += 1
+        console.error(`Failed: ${filePath}`)
+        console.error(error && error.message ? error.message : error)
+      }
+    })
+  )
+}
+
+function splitNullSeparated(value) {
+  if (!value) {
+    return []
+  }
+
+  return value.split('\0').filter(Boolean)
 }
 
 module.exports = restoreFiles

package/src/en.js

@@ -30,7 +30,9 @@ async function processFiles(directory, options = {}) {
         const data = await fs.readFile(filePath)
 
         await fs.writeFile(outputPath, data)
-        console.log(`Written: ${outputPath}`)
+        if (config.verbose) {
+          console.log(`Written: ${outputPath}`)
+        }
         stats.written += 1
       }).catch(error => {
         stats.failed += 1

package/src/run.js

@@ -2,14 +2,6 @@ const enF = require('./en')
 const deF = require('./de')
 const packF = require('./pack')
 const { loadConfig } = require('./config')
-const {
-  collectRecoveryEntries,
-  createPackConfig,
-  extractTarGz,
-  removeSidecars,
-  resolveOutputPath,
-  writeTarGz
-} = require('./pack')
 
 function printHelp() {
   console.log(`Usage:
@@ -25,6 +17,8 @@ Options:
   --exclude <list>      Comma separated excluded directory names
   --concurrency <n>     Concurrent file operation limit
   --out <file>          Archive output name
+  --mode <mode>         Restore mode for de/all: auto, bash, powershell, node
+  --verbose             Print each processed file
 `)
 }
 
@@ -103,6 +97,22 @@ function parseArgs(command, args) {
       continue
     }
 
+    if (arg === '--verbose') {
+      result.verbose = true
+      continue
+    }
+
+    if (arg.startsWith('--mode=')) {
+      result.restoreMode = arg.slice('--mode='.length)
+      continue
+    }
+
+    if (arg === '--mode') {
+      result.restoreMode = args[index + 1]
+      index += 1
+      continue
+    }
+
     if (!arg.startsWith('-')) {
       result.positionals.push(arg)
     }
@@ -168,28 +178,14 @@ async function run(args) {
 
   if (command === 'all') {
     await enF(options.directory, options)
-    await runAll(options.directory, options)
+    await deF(options.directory, options)
+    await packF(options.directory, options)
     return
   }
 
   printHelp()
 }
 
-async function runAll(directory, options) {
-  const config = createPackConfig(directory, options)
-  const outputPath = resolveOutputPath(config.directory, config.out)
-  const entries = await collectRecoveryEntries(config, {
-    outputPath
-  })
-
-  await writeTarGz(config.directory, outputPath, entries)
-  const restored = await extractTarGz(outputPath, config.directory)
-  const deleted = await removeSidecars(config.directory, config)
-
-  console.log(`Packed: ${outputPath}`)
-  console.log(`Done. files=${entries.length}, restored=${restored}, deleted=${deleted}`)
-}
-
 function omitUndefined(value) {
   return Object.keys(value).reduce((result, key) => {
     if (value[key] !== undefined) {