파일 이름 변환기 기능 추가: README 문서 작성 및 CLI 도구와 백그라운드 프로세스 구현

2025-12-19 20:14:39 +09:00 · 2024-12-18 02:35:22 +09:00
parent 3f849808ac
commit 94059a0947
29 changed files with 3898 additions and 0 deletions
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -0,0 +1,43 @@
 name: Build and Package
 on:
  push:
    branches:
      - main
  pull_request:
 jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16'
      - name: Install dependencies
        run: npm install
      - name: Build package
        run: npm run build
      - name: Build with pkg
        run: npx pkg .
      - name: Build .app file
        run: |
          npm install electron-packager --save-dev
          npx electron-packager . MyApp --platform=darwin --arch=arm64,x64 --out=release-builds
      - name: Upload artifacts
        uses: actions/upload-artifact@v3
        with:
          name: build-artifacts
          path: |
            *.exe
            *.app
            release-builds/**
--- a/MACOS-APP/README.md
+++ b/MACOS-APP/README.md
@@ -0,0 +1,34 @@
 # 파일 이름 변환기
 macos 에서 파일 이름을 NFD에서 NFC 인코딩으로 변환하는 패키지입니다.
 ## 목적
 macos에서 한글 파일 이름을 사용할 때 NFD 인코딩으로 저장되는 문제를 해결하기 위해 개발되었습니다.
 매번 파일 이름을 수동으로 변경하는 것은 번거롭기 때문에 자동으로 변환하는 프로그램을 개발하였습니다.
 디렉토리를 지정하면 하위 디렉토리까지 변환하며, 백그라운드 실행을 지원합니다.
 ## 특징
 - NFD에서 NFC 변환 지원
 - 하위 디렉토리 변환 지원
 - 백그라운드 실행 지원
 ## 설치
 ```bash
 # 전역 설치
 npm install -g @pieroot/nfd2nfc
 # 또는 로컬 설치
 npm i @pieroot/nfd2nfc
 ```
 ## 사용법
 ## 라이선스
 MIT 라이선스
--- a/MACOS-APP/build/icons/MacIcon-dev.icns
+++ b/MACOS-APP/build/icons/MacIcon-dev.icns
--- a/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_1024x1024.png
+++ b/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_1024x1024.png
--- a/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_128x128.png
+++ b/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_128x128.png
--- a/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_16x16.png
+++ b/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_16x16.png
--- a/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_256x256.png
+++ b/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_256x256.png
--- a/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_32x32.png
+++ b/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_32x32.png
--- a/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_512x512.png
+++ b/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_512x512.png
--- a/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_64x64.png
+++ b/MACOS-APP/build/icons/MacIcon-dev.iconset/icon_64x64.png
--- a/MACOS-APP/build/icons/Macicon.icns
+++ b/MACOS-APP/build/icons/Macicon.icns
--- a/MACOS-APP/build/icons/Macicon.iconset/icon_1024x1024.png
+++ b/MACOS-APP/build/icons/Macicon.iconset/icon_1024x1024.png
--- a/MACOS-APP/build/icons/Macicon.iconset/icon_128x128.png
+++ b/MACOS-APP/build/icons/Macicon.iconset/icon_128x128.png
--- a/MACOS-APP/build/icons/Macicon.iconset/icon_16x16.png
+++ b/MACOS-APP/build/icons/Macicon.iconset/icon_16x16.png
--- a/MACOS-APP/build/icons/Macicon.iconset/icon_256x256.png
+++ b/MACOS-APP/build/icons/Macicon.iconset/icon_256x256.png
--- a/MACOS-APP/build/icons/Macicon.iconset/icon_32x32.png
+++ b/MACOS-APP/build/icons/Macicon.iconset/icon_32x32.png
--- a/MACOS-APP/build/icons/Macicon.iconset/icon_512x512.png
+++ b/MACOS-APP/build/icons/Macicon.iconset/icon_512x512.png
--- a/MACOS-APP/build/icons/Macicon.iconset/icon_64x64.png
+++ b/MACOS-APP/build/icons/Macicon.iconset/icon_64x64.png
--- a/MACOS-APP/index.html
+++ b/MACOS-APP/index.html
@@ -0,0 +1,166 @@
 <!-- index.html -->
 <!DOCTYPE html>
 <html lang="ko">
 <head>
  <meta charset="UTF-8">
  <title>Directory Watcher App</title>
  <style>
    body {
      font-family: Arial, sans-serif;
      text-align: center;
      padding: 20px;
    }
    #selected-directories {
      margin-top: 20px;
      max-width: 700px;
      margin-left: auto;
      margin-right: auto;
      text-align: left;
    }
    table {
      width: 100%;
      border-collapse: collapse;
    }
    th,
    td {
      padding: 12px;
      border: 1px solid #ddd;
    }
    th {
      background-color: #f2f2f2;
    }
    .remove-button {
      background-color: #ff4d4d;
      border: none;
      color: white;
      padding: 5px 10px;
      border-radius: 3px;
      cursor: pointer;
    }
    #log {
      margin-top: 20px;
      text-align: left;
      white-space: pre-wrap;
      background-color: #f0f0f0;
      padding: 10px;
      border-radius: 5px;
      height: 150px;
      overflow-y: scroll;
      max-width: 700px;
      margin-left: auto;
      margin-right: auto;
    }
    button {
      padding: 10px 20px;
      font-size: 16px;
      cursor: pointer;
      margin-bottom: 10px;
    }
  </style>
 </head>
 <body>
  <h1>디렉토리 감시 애플리케이션</h1>
  <button id="select-directory">디렉토리 선택</button>
  <div id="selected-directories">
    <h2>감시 중인 디렉토리</h2>
    <table>
      <thead>
        <tr>
          <th>디렉토리 경로</th>
          <th>제거</th>
        </tr>
      </thead>
      <tbody id="directories-list">
        <!-- 선택된 디렉토리 목록이 여기에 표시됩니다 -->
      </tbody>
    </table>
  </div>
  <div id="log">
    로그가 여기에 표시됩니다.
  </div>
  <script>
    const selectDirButton = document.getElementById('select-directory');
    const directoriesList = document.getElementById('directories-list');
    const logDiv = document.getElementById('log');
    selectDirButton.addEventListener('click', async () => {
      const result = await window.electronAPI.selectDirectories();
      if (!result.canceled) {
        refreshDirectories(); // 즉시 갱신
      }
    });
    function addDirectoryToList(dirPath) {
      if (document.querySelector(`[data-path="${ dirPath }"]`)) {
        return;
      }
      const directoryRow = document.createElement('tr');
      directoryRow.setAttribute('data-path', dirPath);
      const pathCell = document.createElement('td');
      pathCell.textContent = dirPath;
      const removeCell = document.createElement('td');
      const removeBtn = document.createElement('button');
      removeBtn.className = 'remove-button';
      removeBtn.textContent = '제거';
      removeBtn.addEventListener('click', async () => {
        const response = await window.electronAPI.removeDirectory(dirPath);
        if (response.success) {
          directoriesList.removeChild(directoryRow);
          appendLog(`디렉토리 감시 중지: "${ dirPath }"`);
        } else {
          appendLog(`디렉토리 제거 실패: "${ response.message }"`);
        }
      });
      removeCell.appendChild(removeBtn);
      directoryRow.appendChild(pathCell);
      directoryRow.appendChild(removeCell);
      directoriesList.appendChild(directoryRow);
    }
    function refreshDirectories() {
      window.electronAPI.getDirectories().then((directories) => {
        directoriesList.innerHTML = '';
        for (const dirPath of Object.keys(directories)) {
          addDirectoryToList(dirPath);
        }
      });
    }
    window.addEventListener('DOMContentLoaded', () => {
      // Initially load directories
      refreshDirectories();
      // Then refresh every 10 seconds
      setInterval(refreshDirectories, 10000);
    });
    // Listen for refresh-directories event
    window.electronAPI.on('refresh-directories', refreshDirectories);
    function appendLog(message) {
      logDiv.textContent += `${ message }\n`;
      logDiv.scrollTop = logDiv.scrollHeight;
    }
    window.electronAPI.onLog((message) => {
      appendLog(message);
    });
  </script>
 </body>
 </html>
--- a/MACOS-APP/main.js
+++ b/MACOS-APP/main.js
@@ -0,0 +1,436 @@
 // main.js
 const {
  app,
  BrowserWindow,
  dialog,
  ipcMain,
  Notification,
  Tray,
  Menu,
 } = require("electron");
 const path = require("path");
 const chokidar = require("chokidar");
 const fs = require("fs").promises;
 const fsSync = require("fs"); // For synchronous path checks
 let tray = null;
 let mainWindow = null;
 let watchers = {}; // To keep track of file watchers
 // 로그 파일 경로 지정
 const logFilePath = path.join(app.getPath("userData"), "watcher.log");
 // JSON 파일 경로 지정
 const watchedDirectoriesPath = path.join(
  app.getPath("userData"),
  "watchedDirectories.json"
 );
 // 현재 감시 중인 디렉토리 목록 및 마지막 갱신 시간
 let watchedDirectories = {}; // { "path/to/dir": "2024-12-16T23:30:25.615Z", ... }
 // Load the directories from JSON
 async function loadWatchedDirectories() {
  try {
    const data = await fs.readFile(watchedDirectoriesPath, "utf-8");
    watchedDirectories = JSON.parse(data);
    for (const dirPath of Object.keys(watchedDirectories)) {
      watchDirectory(dirPath);
    }
  } catch (error) {
    if (error.code !== "ENOENT") {
      console.error(`Error loading directories: ${error}`);
      new Notification({
        title: "Error",
        body: `Error loading directories: ${error.message}`,
      }).show();
    } else {
      console.log("No watched directories found. Starting fresh.");
      watchedDirectories = {};
    }
  }
 }
 // Save directories to JSON
 async function saveWatchedDirectories() {
  try {
    await fs.writeFile(
      watchedDirectoriesPath,
      JSON.stringify(watchedDirectories, null, 2),
      "utf-8"
    );
  } catch (error) {
    console.error(`Error saving directories: ${error}`);
  }
 }
 // 로그 기록 함수
 async function log(message) {
  const timestamp = new Date().toISOString();
  const logMessage = `[${timestamp}] ${message}\n`;
  try {
    await fs.appendFile(logFilePath, logMessage);
  } catch (error) {
    console.error("로그 파일 작성 실패:", error);
  }
 }
 // 무시할 파일/디렉토리를 결정하는 함수
 function shouldIgnore(itemName) {
  const ignoredItems = [".git", "node_modules", ".env"];
  return ignoredItems.includes(itemName);
 }
 // 파일 이름을 정규화하는 함수
 async function normalizeFileName(filePath) {
  const dir = path.dirname(filePath);
  const oldName = path.basename(filePath);
  const newName = oldName.normalize("NFC");
  if (oldName !== newName && !shouldIgnore(oldName)) {
    const newPath = path.join(dir, newName);
    try {
      await fs.rename(filePath, newPath);
      // watchedDirectories[newPath] = new Date().toISOString();
      // delete watchedDirectories[filePath];
      await saveWatchedDirectories();
      await log(`이름 변경: "${oldName}" -> "${newName}"`);
      // 알림 생성
      new Notification({
        title: "이름 변경 완료",
        body: `"${oldName}"이 "${newName}"으로 변경되었습니다.`,
      }).show();
      // 렌더러 프로세스로 알림 전송
      if (mainWindow) {
        mainWindow.webContents.send(
          "log-message",
          `이름 변경: "${oldName}" -> "${newName}"`
        );
      }
      return newPath;
    } catch (error) {
      await log(`이름 변경 실패 ("${oldName}"): ${error}`);
      if (mainWindow) {
        mainWindow.webContents.send(
          "log-message",
          `이름 변경 실패 ("${oldName}"): ${error}`
        );
      }
      return filePath;
    }
  }
  // 변경 시 마지막 갱신 시간 업데이트
  // watchedDirectories[filePath] = new Date().toISOString();
  // await saveWatchedDirectories();
  return filePath;
 }
 // 디렉토리를 재귀적으로 처리하는 함수
 async function processDirectory(dirPath) {
  try {
    await log(`디렉토리 처리 시작: "${dirPath}"`);
    if (mainWindow) {
      mainWindow.webContents.send(
        "log-message",
        `디렉토리 처리 시작: "${dirPath}"`
      );
    }
    const entries = await fs.readdir(dirPath, { withFileTypes: true });
    for (const entry of entries) {
      const fullPath = path.join(dirPath, entry.name);
      if (entry.isDirectory()) {
        if (!shouldIgnore(entry.name)) {
          await processDirectory(fullPath);
          await normalizeFileName(fullPath);
        }
      } else {
        await normalizeFileName(fullPath);
      }
    }
    await normalizeFileName(dirPath);
    // console.log(`디렉토리 처리 완료: "${dirPath}"`);
    // watchedDirectories[dirPath] = new Date().toISOString();
    // await saveWatchedDirectories();
    await log(`디렉토리 처리 완료: "${dirPath}"`);
    if (mainWindow) {
      mainWindow.webContents.send(
        "log-message",
        `디렉토리 처리 완료: "${dirPath}"`
      );
    }
  } catch (error) {
    await log(`디렉토리 처리 중 오류 발생 ("${dirPath}"): ${error}`);
    if (mainWindow) {
      mainWindow.webContents.send(
        "log-message",
        `디렉토리 처리 중 오류 발생 ("${dirPath}"): ${error}`
      );
    }
  }
 }
 // 디렉토리를 감시하는 함수
 function watchDirectory(directory) {
  const watcher = chokidar.watch(directory, {
    ignored: (pathStr) => {
      const baseName = path.basename(pathStr);
      return shouldIgnore(baseName);
    },
    persistent: true,
    ignoreInitial: false,
    awaitWriteFinish: {
      stabilityThreshold: 200,
      pollInterval: 100,
    },
    depth: Infinity,
  });
  watchers[directory] = watcher;
  watcher
    .on("add", async (filePath) => {
      // await log(`파일 추가됨: "${filePath}"`);
      // if (mainWindow) {
      //   mainWindow.webContents.send(
      //     "log-message",
      //     `파일 추가됨: "${filePath}"`
      //   );
      // }
      await normalizeFileName(filePath);
    })
    .on("change", async (filePath) => {
      // await log(`파일 변경됨: "${filePath}"`);
      // if (mainWindow) {
      //   mainWindow.webContents.send(
      //     "log-message",
      //     `파일 변경됨: "${filePath}"`
      //   );
      // }
      await normalizeFileName(filePath);
    })
    .on("unlink", async (filePath) => {
      // await log(`파일 삭제됨: "${filePath}"`);
      // if (mainWindow) {
      //   mainWindow.webContents.send(
      //     "log-message",
      //     `파일 삭제됨: "${filePath}"`
      //   );
      // }
    })
    .on("addDir", async (dirPath) => {
      // await log(`디렉토리 추가됨: "${dirPath}"`);
      // if (mainWindow) {
      //   mainWindow.webContents.send(
      //     "log-message",
      //     `디렉토리 추가됨: "${dirPath}"`
      //   );
      // }
      await processDirectory(dirPath);
    })
    .on("unlinkDir", async (dirPath) => {
      // await log(`디렉토리 삭제됨: "${dirPath}"`);
      // if (mainWindow) {
      //   mainWindow.webContents.send(
      //     "log-message",
      //     `디렉토리 삭제됨: "${dirPath}"`
      //   );
      // }
    })
    .on("error", async (error) => {
      await log(`Watcher error: ${error}`);
      if (mainWindow) {
        mainWindow.webContents.send("log-message", `Watcher error: ${error}`);
      }
      new Notification({
        title: "Watcher Error",
        body: `Error watching directory: ${error.message}`,
      }).show();
    })
    .on("ready", () => {
      log(
        `초기 스캔 완료. "${directory}"에서 변경 사항을 감시 중입니다.`
      ).catch(console.error);
      if (mainWindow) {
        mainWindow.webContents.send(
          "log-message",
          `초기 스캔 완료. "${directory}"에서 변경 사항을 감시 중입니다.`
        );
      }
    });
 }
 function setTray() {
  const iconPath = path.join(
    __dirname,
    "build/icons/Macicon.iconset/icon_32x32.png"
  ); // Define iconPath here
  if (!fsSync.existsSync(iconPath)) {
    console.error("Tray icon not found at:", iconPath);
    new Notification({
      title: "Error",
      body: `Tray icon not found at ${iconPath}`,
    }).show();
    return;
  }
  tray = new Tray(iconPath);
  const contextMenu = Menu.buildFromTemplate([
    {
      label: "열기",
      click: () => {
        if (mainWindow === null) {
          createWindow();
        } else {
          mainWindow.show();
        }
      },
    },
    {
      label: "종료",
      click: () => {
        app.quit();
      },
    },
  ]);
  tray.setToolTip("Directory Watcher App");
  tray.setContextMenu(contextMenu);
  // 더블 클릭 시 창 열기
  tray.on("double-click", () => {
    if (mainWindow === null) {
      createWindow();
    } else {
      mainWindow.show();
    }
  });
 }
 // 애플리케이션 준비 시 창 및 트레이 설정 후 디렉토리 목록 로드
 app.whenReady().then(async () => {
  createWindow();
  setTray();
  await loadWatchedDirectories();
  if (process.platform === "darwin") {
    app.dock.hide();
  }
  app.on("activate", function () {
    if (BrowserWindow.getAllWindows().length === 0) createWindow();
  });
 });
 // 모든 창이 닫히면 애플리케이션 종료 (macOS 특성)
 app.on("window-all-closed", function () {
  if (process.platform !== "darwin") app.quit();
 });
 // 디렉토리 감시 로직 처리
 ipcMain.handle("select-directories", async () => {
  const result = await dialog.showOpenDialog({
    properties: ["openDirectory", "multiSelections"],
  });
  if (result.canceled) {
    return { canceled: true };
  } else {
    const selectedPaths = result.filePaths;
    await log(`선택된 디렉토리: "${selectedPaths.join('", "')}"`);
    if (mainWindow) {
      mainWindow.webContents.send(
        "log-message",
        `선택된 디렉토리: "${selectedPaths.join('", "')}"`
      );
    }
    for (const selectedPath of selectedPaths) {
      if (!watchedDirectories.hasOwnProperty(selectedPath)) {
        watchedDirectories[selectedPath] = new Date().toISOString();
        watchDirectory(selectedPath);
      }
    }
    await saveWatchedDirectories();
    // 렌더러 프로세스로 선택된 디렉토리 목록 업데이트 요청
    if (mainWindow) {
      mainWindow.webContents.send("update-directories", watchedDirectories);
    }
    return { canceled: false, paths: selectedPaths };
  }
 });
 // 디렉토리 제거 핸들러
 ipcMain.handle("remove-directory", async (event, dirPath) => {
  if (watchedDirectories.hasOwnProperty(dirPath)) {
    watchedDirectories = Object.keys(watchedDirectories)
      .filter((key) => key !== dirPath)
      .reduce((obj, key) => {
        obj[key] = watchedDirectories[key];
        return obj;
      }, {});
    if (watchers[dirPath]) {
      await watchers[dirPath].close();
      delete watchers[dirPath];
      await log(`디렉토리 감시 중지: "${dirPath}"`);
      if (mainWindow) {
        mainWindow.webContents.send(
          "log-message",
          `디렉토리 감시 중지: "${dirPath}"`
        );
        mainWindow.webContents.send("update-directories", watchedDirectories);
      }
    }
    await saveWatchedDirectories();
    return { success: true };
  } else {
    return { success: false, message: "디렉토리가 감시 목록에 없습니다." };
  }
 });
 ipcMain.handle("get-directories", async () => {
  return watchedDirectories;
 });
 process.on("unhandledRejection", (reason, promise) => {
  new Notification({
    title: "Unhandled Promise Rejection",
    body: reason.message || "Unknown error",
  }).show();
 });
 // 창을 생성하는 함수
 function createWindow() {
  mainWindow = new BrowserWindow({
    width: 550, // 너비 조정
    height: 550, // 높이 조정
    webPreferences: {
      preload: path.join(__dirname, "preload.js"), // 보안상 추천
      nodeIntegration: false,
      contextIsolation: true,
    },
  });
  mainWindow.loadFile("index.html");
  mainWindow.on("show", () => {
    mainWindow.webContents.send("get-directories");
  });
  mainWindow.on("closed", function () {
    mainWindow = null;
  });
 }
--- a/MACOS-APP/package-lock.json
+++ b/MACOS-APP/package-lock.json
--- a/MACOS-APP/package.json
+++ b/MACOS-APP/package.json
@@ -0,0 +1,50 @@
 {
  "name": "nfd2nfc",
  "version": "1.0.0",
  "main": "main.js",
  "description": "Convert NFD to NFC",
  "dependencies": {
    "chokidar": "^4.0.1",
    "electron": "^33.2.1",
    "minimist": "^1.2.8",
    "readdirp": "^4.0.2"
  },
  "scripts": {
    "start": "electron .",
    "package": "electron-packager . NFD2NFC --platform=darwin --arch=arm64,x64 --icon=build/icons/MacIcon.icns --overwrite --prune=true --out=dist --asar --app-bundle-id=com.pieroot.nfd2nfc",
    "package dev": "electron-packager . NFD2NFC --platform=darwin --arch=arm64,x64 --icon=build/icons/MacIcon-dev.icns --overwrite --prune=true --out=dist --asar --app-bundle-id=com.pieroot.nfd2nfc",
    "dmg": "electron-installer-dmg ./dist/NFD2NFC-darwin-arm64/NFD2NFC.app NFD2NFC --overwrite --icon=build/icons/Macicon.icns --out=dist",
    "build": "npm run package && npm run dmg"
  },
  "bin": {
    "nfd2nfc": "normalize.js"
  },
  "directories": {
    "output": "dist",
    "buildResources": "build"
  },
  "keywords": [
    "NFD",
    "NFC",
    "Unicode",
    "Normalization",
    "macOS",
    "Linux",
    "korean"
  ],
  "author": "jung-geun <pieroot.02@gmail.com>",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/jung-geun/NFD2NFC.git"
  },
  "license": "MIT",
  "devDependencies": {
    "electron": "^33.2.1",
    "electron-installer-dmg": "^5.0.1",
    "electron-packager": "^17.1.2"
  },
  "bugs": {
    "url": "https://github.com/jung-geun/NFD2NFC/issues"
  },
  "homepage": "https://github.com/jung-geun/NFD2NFC#readme"
 }
--- a/MACOS-APP/preload.js
+++ b/MACOS-APP/preload.js
@@ -0,0 +1,14 @@
 // preload.js
 const { contextBridge, ipcRenderer } = require("electron");
 contextBridge.exposeInMainWorld("electronAPI", {
  selectDirectories: () => ipcRenderer.invoke("select-directories"),
  removeDirectory: (dirPath) => ipcRenderer.invoke("remove-directory", dirPath),
  getDirectories: () => ipcRenderer.invoke("get-directories"),
  onLog: (callback) =>
    ipcRenderer.on("log-message", (event, message) => callback(message)),
  onUpdateDirectories: (callback) =>
    ipcRenderer.on("update-directories", (event, directories) =>
      callback(directories)
    ),
 });
--- a/convert/.gitkeep
+++ b/convert/.gitkeep
--- a/nfd2nfc/README.md
+++ b/nfd2nfc/README.md
@@ -0,0 +1,35 @@
 # 파일 이름 변환기
 백그라운드에서 파일을 감지하고 변환하여 파일 이름을 NFD에서 NFC 인코딩으로 자동 변환하는 macOS 패키지입니다.
 npm 패키지는 명령어를 통해 사용할 수 있는 CLI 도구를 제공합니다.
 Application 패키지는 macOS에서 백그라운드 프로세스로 실행되며, 파일 변환을 자동으로 처리합니다.
 ## 특징
 - 자동 파일 감지
 - 백그라운드 변환 프로세스
 - NFD에서 NFC 변환 지원
 ## 설치
 ```bash
 # 설치 지침을 여기에 작성하세요
 npm install -g @pieroot/nfd2nfc
 # or
 npm i @pieroot/nfd2nfc
 ```
 ## 사용법
 ```bash
 nfd2nfc [options] <path>
 Options:
  -V, --version  output the version number
  -h, --help     display help for command
 ```
 ## 라이선스
 MIT 라이선스
--- a/nfd2nfc/normalize.js
+++ b/nfd2nfc/normalize.js
@@ -0,0 +1,127 @@
 #!/usr/bin/env node
 const fs = require("fs").promises;
 const path = require("path");
 const minimist = require("minimist");
 const cliProgress = require("cli-progress");
 // Parse command-line arguments
 const args = minimist(process.argv.slice(2), {
  alias: { v: "verbose", h: "help" },
  boolean: ["verbose", "help"],
 });
 // Function to display help message
 function displayHelp() {
  console.log(`
    Usage: node index.js [path] [options]
    Options:
      -v, --verbose     Enable verbose logging with progress bar
      -h, --help        Display this help message
    Provide a path directly as an argument
  `);
 }
 // Check for help flag
 if (args.help) {
  displayHelp();
  process.exit(0);
 }
 // Main processing logic
 async function processPath(targetPath) {
  try {
    const stats = await fs.lstat(targetPath);
    const depth = 0;
    if (stats.isDirectory()) {
      await processDirectory(targetPath, depth);
    } else if (stats.isFile()) {
      await normalizeFileName(targetPath);
    }
  } catch (error) {
    console.error(`Error processing path "${targetPath}":`, error);
  }
 }
 // Function to determine if a file/directory should be ignored
 function shouldIgnore(itemName) {
  const ignoredItems = [".git", "node_modules", ".env"];
  return ignoredItems.includes(itemName);
 }
 // Function to normalize file names
 async function normalizeFileName(filePath) {
  const dir = path.dirname(filePath);
  const oldName = path.basename(filePath);
  const newName = oldName.normalize("NFC");
  if (oldName !== newName && !shouldIgnore(oldName)) {
    const newPath = path.join(dir, newName);
    try {
      await fs.rename(filePath, newPath);
      return newPath;
    } catch (error) {
      console.error(`Failed to rename "${oldName}":`, error);
      return filePath;
    }
  }
  return filePath;
 }
 let entriesLength = 0;
 // Function to process directories recursively
 async function processDirectory(dirPath, depth = 0) {
  try {
    const entries = await fs.readdir(dirPath, { withFileTypes: true });
    const filesToProcess = entries.filter(
      (entry) => !entry.isDirectory()
    ).length;
    let processedFiles = 0;
    if (args.verbose && depth == 0) {
      entriesLength = entries.length;
      console.log("Processing directory:", dirPath);
      progressBar.start(entriesLength, 0);
    }
    for (const entry of entries) {
      const fullPath = path.join(dirPath, entry.name);
      if (entry.isDirectory()) {
        if (!shouldIgnore(entry.name)) {
          await processDirectory(fullPath, depth + 1);
        }
      } else {
        await normalizeFileName(fullPath);
      }
      if (args.verbose && filesToProcess > 0 && depth == 0) {
        processedFiles++;
        progressBar.update((processedFiles / entriesLength) * entriesLength);
      }
    }
    await normalizeFileName(dirPath);
    if (args.verbose && depth == 0) {
      progressBar.stop();
    }
  } catch (error) {
    console.error(`Error processing directory "${dirPath}":`, error);
  }
 }
 // Initialize progress bar
 const progressBar = new cliProgress.SingleBar(
  {
    format: "{bar} {percentage}% | {value}/{total}",
    clearOnComplete: false,
  },
  cliProgress.Presets.shades_classic
 );
 // Handle input: if no flags, assume first non-flag argument is a path
 const nonFlagArgs = args._;
 if (nonFlagArgs.length > 0) {
  processPath(nonFlagArgs[0]);
 } else {
  displayHelp();
 }
--- a/nfd2nfc/normalize_ko.js
+++ b/nfd2nfc/normalize_ko.js
@@ -0,0 +1,114 @@
 #!/usr/bin/env node
 const fs = require("fs").promises;
 const path = require("path");
 const minimist = require("minimist");
 function containsKorean(text) {
  // 한글 유니코드 범위: 가-힣, ㄱ-ㅎ, ㅏ-ㅣ
  return /[가-힣ㄱ-ㅎㅏ-ㅣ]/.test(text);
 }
 // Parse command-line arguments
 const args = minimist(process.argv.slice(2), {
  alias: { d: "directory", f: "file", v: "verbose", h: "help" },
 });
 // Function to display help message
 function displayHelp() {
  console.log(`
    Usage: node index.js [options]
    Options:
      -d, --directory   Specify a directory to process
      -f, --file        Specify a file to process
      -v, --verbose     Enable verbose logging
      -h, --help        Display this help message
  `);
 }
 // Check for help flag or no arguments
 if (args.help || (!args.directory && !args.file)) {
  displayHelp();
  process.exit(0);
 }
 // Main processing logic
 async function processPath(targetPath) {
  if (!targetPath) {
    console.error("Please provide a path using -d or -f");
    process.exit(1);
  }
  try {
    const stats = await fs.lstat(targetPath);
    if (stats.isDirectory()) {
      await processDirectory(targetPath);
    } else if (stats.isFile()) {
      await normalizeFileName(targetPath);
    }
  } catch (error) {
    console.error(`Error processing path "${targetPath}":`, error);
  }
 }
 // Function to determine if a file/directory should be ignored
 function shouldIgnore(itemName) {
  const ignoredItems = [".git", "node_modules", ".env"];
  return ignoredItems.includes(itemName);
 }
 // Function to normalize file names
 async function normalizeFileName(filePath) {
  const dir = path.dirname(filePath);
  const oldName = path.basename(filePath);
  const newName = oldName.normalize("NFC");
  if (
    oldName !== newName &&
    !shouldIgnore(oldName) &&
    containsKorean(oldName)
  ) {
    const newPath = path.join(dir, newName);
    try {
      await fs.rename(filePath, newPath);
      if (args.verbose) {
        console.log(`Renamed: "${oldName}" -> "${newName}"`);
      }
      return newPath;
    } catch (error) {
      console.error(`Failed to rename "${oldName}":`, error);
      return filePath;
    }
  }
  return filePath;
 }
 // Function to process directories recursively
 async function processDirectory(dirPath) {
  if (args.verbose) {
    console.log(`Processing directory: "${dirPath}"`);
  }
  try {
    const entries = await fs.readdir(dirPath, { withFileTypes: true });
    for (const entry of entries) {
      const fullPath = path.join(dirPath, entry.name);
      if (entry.isDirectory()) {
        if (!shouldIgnore(entry.name)) {
          await processDirectory(fullPath);
          await normalizeFileName(fullPath);
        }
      } else {
        await normalizeFileName(fullPath);
      }
    }
    await normalizeFileName(dirPath);
  } catch (error) {
    console.error(`Error processing directory "${dirPath}":`, error);
  }
 }
 // Process the given path based on arguments
 if (args.directory) {
  processPath(args.directory);
 } else if (args.file) {
  processPath(args.file);
 }
--- a/nfd2nfc/package-lock.json
+++ b/nfd2nfc/package-lock.json
@@ -0,0 +1,91 @@
 {
  "name": "@pieroot/nfd2nfc",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@pieroot/nfd2nfc",
      "version": "1.0.0",
      "license": "MIT",
      "dependencies": {
        "cli-progress": "^3.12.0",
        "minimist": "^1.2.8"
      },
      "bin": {
        "nfd2nfc": "normalize.js"
      }
    },
    "node_modules/ansi-regex": {
      "version": "5.0.1",
      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/cli-progress": {
      "version": "3.12.0",
      "resolved": "https://registry.npmjs.org/cli-progress/-/cli-progress-3.12.0.tgz",
      "integrity": "sha512-tRkV3HJ1ASwm19THiiLIXLO7Im7wlTuKnvkYaTkyoAPefqjNg7W7DHKUlGRxy9vxDvbyCYQkQozvptuMkGCg8A==",
      "license": "MIT",
      "dependencies": {
        "string-width": "^4.2.3"
      },
      "engines": {
        "node": ">=4"
      }
    },
    "node_modules/emoji-regex": {
      "version": "8.0.0",
      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
      "license": "MIT"
    },
    "node_modules/is-fullwidth-code-point": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
      "license": "MIT",
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/minimist": {
      "version": "1.2.8",
      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
      "license": "MIT",
      "funding": {
        "url": "https://github.com/sponsors/ljharb"
      }
    },
    "node_modules/string-width": {
      "version": "4.2.3",
      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
      "license": "MIT",
      "dependencies": {
        "emoji-regex": "^8.0.0",
        "is-fullwidth-code-point": "^3.0.0",
        "strip-ansi": "^6.0.1"
      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/strip-ansi": {
      "version": "6.0.1",
      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
      "license": "MIT",
      "dependencies": {
        "ansi-regex": "^5.0.1"
      },
      "engines": {
        "node": ">=8"
      }
    }
  }
 }
--- a/nfd2nfc/package.json
+++ b/nfd2nfc/package.json
@@ -0,0 +1,38 @@
 {
  "name": "@pieroot/nfd2nfc",
  "version": "1.0.0",
  "main": "main.js",
  "description": "Convert NFD to NFC",
  "dependencies": {
    "cli-progress": "^3.12.0",
    "minimist": "^1.2.8"
  },
  "scripts": {
    "build": "pkg normalize.js --target node16-macos-x64,node16-linux-x64,node16-win-x64 --output ./dist/NFD2NFC"
  },
  "bin": {
    "nfd2nfc": "normalize.js"
  },
  "directories": {
    "output": "dist"
  },
  "keywords": [
    "NFD",
    "NFC",
    "Unicode",
    "Normalization",
    "macOS",
    "Linux",
    "korean"
  ],
  "author": "jung-geun <pieroot.02@gmail.com>",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/jung-geun/NFD2NFC.git"
  },
  "license": "MIT",
  "bugs": {
    "url": "https://github.com/jung-geun/NFD2NFC/issues"
  },
  "homepage": "https://github.com/jung-geun/NFD2NFC#readme"
 }