lfify 1.1.1 → 1.2.0

package/.github/workflows/cd.yml

@@ -22,7 +22,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v6
         with:
-          node-version: "lts/*"
+          node-version: "24"
       - name: Install dependencies
         run: npm clean-install
       - name: Verify the integrity of provenance attestations and registry signatures for installed dependencies
@@ -30,4 +30,6 @@ jobs:
       - name: Release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: NODE_AUTH_TOKEN="" npx semantic-release
+        run: |
+          unset NODE_AUTH_TOKEN
+          npx semantic-release

package/.lfifyrc-sample.json

@@ -1,5 +1,6 @@
 {
   "entry": "./",
+  "logLevel": "error",
   "include": [
     "**/*.{js,ts,jsx,tsx}",
     "**/*.{json,md}",

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# [1.2.0](https://github.com/GyeongHoKim/lfify/compare/v1.1.0...v1.2.0) (2026-03-16)
+
+
+### Bug Fixes
+
+* add provenance field to true ([fa1a7ff](https://github.com/GyeongHoKim/lfify/commit/fa1a7ffe9c101ff24ec72dd2a083a0facf414511))
+* add trailing slash to publishConfig.registry for npm OIDC ([85175cd](https://github.com/GyeongHoKim/lfify/commit/85175cd160e4bce4d12af559a23e925baf6d7bd6))
+* chunk process ([a77316f](https://github.com/GyeongHoKim/lfify/commit/a77316f792f26466f083c0f47092c79f135bd55a))
+* declare tar resolutions ([e3d654d](https://github.com/GyeongHoKim/lfify/commit/e3d654df7dc67c4edade2043ee62e3e7d64e35a0)), closes [semantic-release/#2951](https://github.com/GyeongHoKim/lfify/issues/2951)
+* dependencies ([87c9031](https://github.com/GyeongHoKim/lfify/commit/87c903143fde7c8c82d94a94d338e5467968ed4a))
+* node 24 and unset NODE_AUTH_TOKEN for npm OIDC ([a74d183](https://github.com/GyeongHoKim/lfify/commit/a74d183248f25b187ef418127d80917c86dd6d86))
+
+
+### Features
+
+* include, exclude arguments ([9f4f2dc](https://github.com/GyeongHoKim/lfify/commit/9f4f2dc962f28c1ada58d6da556a35ef9dc4411b))
+* log level ([f44f9c4](https://github.com/GyeongHoKim/lfify/commit/f44f9c4f3cd846088728dffe67f33e0526e61ffb))
+
+
+### Reverts
+
+* revert "ci: remove node_auth_token force reset" ([3d76f97](https://github.com/GyeongHoKim/lfify/commit/3d76f97ad85d9874b8998c2ac9940474eb95bb24))

package/__fixtures__/already-lf/src/file.js

@@ -0,0 +1 @@
+const x = 1;

package/__fixtures__/cli-override/.lfifyrc.json

@@ -0,0 +1,6 @@
+{
+  "entry": ".",
+  "logLevel": "error",
+  "include": ["**/*.txt"],
+  "exclude": ["**/none"]
+}

package/__fixtures__/cli-override/src/a.js

@@ -0,0 +1 @@
+const a = 1;

package/__fixtures__/cli-override/src/b.txt

@@ -0,0 +1 @@
+b content

package/__fixtures__/default-sensible/_git/config

@@ -0,0 +1,2 @@
+[core]
+repositoryformatversion = 0

package/__fixtures__/default-sensible/_node_modules/pkg/index.js

@@ -0,0 +1 @@
+module.exports = {};

package/__fixtures__/default-sensible/src/app.js

@@ -0,0 +1 @@
+console.log("app");

package/__fixtures__/default-sensible/src/readme.txt

@@ -0,0 +1,2 @@
+hello
+world

package/__fixtures__/with-config/.lfifyrc.json

@@ -0,0 +1,6 @@
+{
+  "entry": ".",
+  "logLevel": "error",
+  "include": ["**/*.js"],
+  "exclude": ["skip/**"]
+}

package/__fixtures__/with-config/doc.txt

@@ -0,0 +1 @@
+doc content

package/__fixtures__/with-config/lib/main.js

@@ -0,0 +1 @@
+const x = 1;

package/__fixtures__/with-config/skip/other.js

@@ -0,0 +1 @@
+skipped;

package/eslint.config.mjs

@@ -4,7 +4,8 @@ import pluginJs from "@eslint/js";
 
 /** @type {import('eslint').Linter.Config[]} */
 export default [
-  {files: ["**/*.js"], languageOptions: {sourceType: "commonjs"}},
+  { ignores: ["**/__fixtures__/**"] },
+  { files: ["**/*.js"], languageOptions: { sourceType: "commonjs" } },
   {
     languageOptions: {
       globals: {
@@ -14,4 +15,4 @@ export default [
     },
   },
   pluginJs.configs.recommended,
-];
+];

package/index.cjs

@@ -1,18 +1,26 @@
 #!/usr/bin/env node
 
-const fs = require("fs").promises;
-const path = require("path");
-const micromatch = require("micromatch");
+const { readFile, readdir, rename } = require("fs/promises");
+const { createReadStream, createWriteStream } = require("fs");
+const { resolve, join, relative } = require("path");
+const { isMatch } = require("micromatch");
+const { Transform } = require("stream");
+const { pipeline } = require("stream/promises");
+
+/** @type {ReadonlyArray<string>} */
+const LOG_LEVELS = ['error', 'warn', 'info'];
 
 /**
  * @typedef {Object} Config
  * @property {string} entry - 처리할 시작 디렉토리 경로
  * @property {string[]} include - 포함할 파일 패턴 목록
  * @property {string[]} exclude - 제외할 파일 패턴 목록
+ * @property {'error'|'warn'|'info'} [logLevel] - 로그 레벨 (error: 에러만, warn: 에러+경고, info: 전체)
  */
 
 /**
  * @typedef {Object} Logger
+ * @property {function(string): void} setLogLevel - 로그 레벨 설정 ('error'|'warn'|'info')
  * @property {function(string, string): void} warn - 경고 메시지 출력
  * @property {function(string, string, Error=): void} error - 에러 메시지 출력
  * @property {function(string, string): void} info - 정보 메시지 출력
@@ -24,6 +32,7 @@ const micromatch = require("micromatch");
  * @property {string} [entry] - CLI로 지정한 entry 경로
  * @property {string[]} [include] - CLI로 지정한 include 패턴
  * @property {string[]} [exclude] - CLI로 지정한 exclude 패턴
+ * @property {'error'|'warn'|'info'} [logLevel] - CLI로 지정한 로그 레벨
  */
 
 /**
@@ -33,7 +42,8 @@ const micromatch = require("micromatch");
 const DEFAULT_CONFIG = {
   entry: './',
   include: [],
-  exclude: []
+  exclude: [],
+  logLevel: 'error'
 };
 
 /**
@@ -49,7 +59,8 @@ const SENSIBLE_DEFAULTS = {
     'dist/**',
     'build/**',
     'coverage/**'
-  ]
+  ],
+  logLevel: 'error'
 };
 
 /**
@@ -60,16 +71,41 @@ const CONFIG_SCHEMA = {
   entry: (value) => typeof value === 'string',
   include: (value) => Array.isArray(value) && value.length > 0 && value.every(item => typeof item === 'string'),
   exclude: (value) => Array.isArray(value) && value.length > 0 && value.every(item => typeof item === 'string'),
+  logLevel: (value) => LOG_LEVELS.includes(value),
 };
 
 /**
- * Logging utility
- * @type {Logger}
+ * Logging utility. 기본은 error만 출력. setLogLevel로 변경 가능.
+ * @type {Logger & { _level: string, setLogLevel: function(string): void }}
  */
 const logger = {
-  warn: (msg, path) => console.warn(`${msg} ${path}`),
-  error: (msg, path, err) => console.error(`${msg} ${path}`, err),
-  info: (msg, path) => console.log(`${msg} ${path}`),
+  _level: 'error',
+
+  setLogLevel(level) {
+    if (LOG_LEVELS.includes(level)) {
+      this._level = level;
+    }
+  },
+
+  error(msg, path, err) {
+    if (err !== undefined) {
+      console.error(`${msg} ${path}`, err);
+    } else {
+      console.error(`${msg} ${path}`);
+    }
+  },
+
+  warn(msg, path) {
+    if (LOG_LEVELS.indexOf(this._level) >= LOG_LEVELS.indexOf('warn')) {
+      console.warn(`${msg} ${path}`);
+    }
+  },
+
+  info(msg, path) {
+    if (LOG_LEVELS.indexOf(this._level) >= LOG_LEVELS.indexOf('info')) {
+      console.log(`${msg} ${path}`);
+    }
+  },
 };
 
 /**
@@ -80,7 +116,7 @@ const logger = {
  */
 async function readConfig(configPath) {
   try {
-    const configContent = await fs.readFile(configPath, 'utf8');
+    const configContent = await readFile(configPath, 'utf8');
     const config = JSON.parse(configContent);
 
     // Validate required fields
@@ -93,7 +129,7 @@ async function readConfig(configPath) {
     return {
       ...DEFAULT_CONFIG,
       ...config,
-      entry: path.resolve(process.cwd(), config.entry || DEFAULT_CONFIG.entry)
+      entry: resolve(process.cwd(), config.entry || DEFAULT_CONFIG.entry)
     };
   } catch (err) {
     if (err.code === 'ENOENT') {
@@ -101,7 +137,7 @@ async function readConfig(configPath) {
     } else {
       logger.error(`Error reading configuration file: ${err.message}`, configPath);
     }
-    
+
     if (require.main === module) {
       process.exit(1);
     }
@@ -120,7 +156,7 @@ async function resolveConfig(cliOptions) {
   // Try to load config file if it exists
   if (cliOptions.configPath) {
     try {
-      const configContent = await fs.readFile(cliOptions.configPath, 'utf8');
+      const configContent = await readFile(cliOptions.configPath, 'utf8');
       fileConfig = JSON.parse(configContent);
 
       // Validate config file fields
@@ -143,14 +179,16 @@ async function resolveConfig(cliOptions) {
   const hasCLIInclude = Array.isArray(cliOptions.include) && cliOptions.include.length > 0;
   const hasCLIExclude = Array.isArray(cliOptions.exclude) && cliOptions.exclude.length > 0;
   const hasCLIEntry = typeof cliOptions.entry === 'string';
+  const hasCLILogLevel = typeof cliOptions.logLevel === 'string' && LOG_LEVELS.includes(cliOptions.logLevel);
 
   const hasFileConfig = fileConfig !== null;
   const hasFileInclude = hasFileConfig && Array.isArray(fileConfig.include) && fileConfig.include.length > 0;
   const hasFileExclude = hasFileConfig && Array.isArray(fileConfig.exclude) && fileConfig.exclude.length > 0;
   const hasFileEntry = hasFileConfig && typeof fileConfig.entry === 'string';
+  const hasFileLogLevel = hasFileConfig && fileConfig.logLevel && LOG_LEVELS.includes(fileConfig.logLevel);
 
   // Resolve each config property
-  let include, exclude, entry;
+  let include, exclude, entry, logLevel;
 
   // Include: CLI > file > default
   if (hasCLIInclude) {
@@ -179,10 +217,20 @@ async function resolveConfig(cliOptions) {
     entry = SENSIBLE_DEFAULTS.entry;
   }
 
+  // LogLevel: CLI > file > default
+  if (hasCLILogLevel) {
+    logLevel = cliOptions.logLevel;
+  } else if (hasFileLogLevel) {
+    logLevel = fileConfig.logLevel;
+  } else {
+    logLevel = SENSIBLE_DEFAULTS.logLevel;
+  }
+
   return {
-    entry: path.resolve(process.cwd(), entry),
+    entry: resolve(process.cwd(), entry),
     include,
-    exclude
+    exclude,
+    logLevel
   };
 }
 
@@ -230,6 +278,13 @@ function parseArgs() {
           i++;
         }
         break;
+
+      case '--log-level':
+        if (nextArg && LOG_LEVELS.includes(nextArg)) {
+          options.logLevel = nextArg;
+          i++;
+        }
+        break;
     }
   }
 
@@ -243,8 +298,8 @@ function parseArgs() {
  * @returns {boolean} - true if file should be processed
  */
 function shouldProcessFile(filePath, config) {
-  const isIncluded = micromatch.isMatch(filePath, config.include);
-  const isExcluded = micromatch.isMatch(filePath, config.exclude);
+  const isIncluded = isMatch(filePath, config.include);
+  const isExcluded = isMatch(filePath, config.exclude);
 
   return isIncluded && !isExcluded;
 }
@@ -258,14 +313,14 @@ function shouldProcessFile(filePath, config) {
  */
 async function convertCRLFtoLF(dirPath, config) {
   try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const entries = await readdir(dirPath, { withFileTypes: true });
 
     /**
      * @todo Node.js is single-threaded, if I want to convert files in parallel, I need to use worker_threads
      */
     await Promise.all(entries.map(async entry => {
-      const fullPath = path.join(dirPath, entry.name);
-      const relativePath = path.relative(process.cwd(), fullPath).replace(/\\/g, "/");
+      const fullPath = join(dirPath, entry.name);
+      const relativePath = relative(process.cwd(), fullPath).replace(/\\/g, "/");
 
       if (entry.isDirectory()) {
         await convertCRLFtoLF(fullPath, config);
@@ -288,30 +343,46 @@ async function convertCRLFtoLF(dirPath, config) {
  * @throws {Error} - if there's an error reading or writing file
  */
 async function processFile(filePath) {
-  try {
-    const content = await fs.readFile(filePath, "utf8");
-    const updatedContent = content.replace(/\r\n/g, "\n");
-
-    if (content !== updatedContent) {
-      /**
-       * @todo V8 javascript engine with 32-bit system cannot handle more than 2GB file,
-       * so I should use createReadStream and createWriteStream to handle large files
-       */
-      await fs.writeFile(filePath, updatedContent, "utf8");
-      logger.info(`converted: ${filePath}`);
-    } else {
-      logger.info(`no need to convert: ${filePath}`, filePath);
+  const tmpPath = `${filePath}.tmp`;
+  const crlf2lf = new Transform({
+    transform(chunk, encoding, callback) {
+      const enc = encoding === 'buffer' ? 'utf8' : encoding;
+      const prev = this._leftover ?? '';
+      this._leftover = '';
+      const str = prev + chunk.toString(enc);
+      const safe = str.endsWith('\r') ? str.slice(0, -1) : str;
+      this._leftover = str.endsWith('\r') ? '\r' : '';
+      callback(null, safe.replace(/\r\n/g, '\n'));
+    },
+    flush(callback) {
+      callback(null, this._leftover ?? '');
     }
+  });
+  try {
+    await pipeline(
+      createReadStream(filePath, { encoding: 'utf8' }),
+      crlf2lf,
+      createWriteStream(tmpPath, { encoding: 'utf8' })
+    );
+    logger.info(`converted ${filePath}`);
   } catch (err) {
     logger.error(`error processing file: ${filePath}`, filePath, err);
     throw err;
   }
+  try {
+    await rename(tmpPath, filePath);
+  } catch (err) {
+    logger.error(`error rename file: ${tmpPath} to ${filePath}`);
+    throw err;
+  }
 }
 
 async function main() {
   const options = parseArgs();
   const config = await resolveConfig(options);
 
+  logger.setLogLevel(config.logLevel);
+
   logger.info(`converting CRLF to LF in: ${config.entry}`, config.entry);
 
   await convertCRLFtoLF(config.entry, config);

package/index.e2e.test.js

@@ -0,0 +1,129 @@
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { resolveConfig, convertCRLFtoLF } = require('./index.cjs');
+
+const FIXTURES_DIR = path.join(__dirname, '__fixtures__');
+const CRLF = Buffer.from([0x0d, 0x0a]);
+
+/**
+ * Recursively copy a directory from src to dest.
+ * @param {string} src - source directory
+ * @param {string} dest - destination directory
+ */
+async function copyDir(src, dest) {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+describe('E2E: CRLF to LF with real filesystem', () => {
+  let tempDir;
+  let originalCwd;
+
+  beforeEach(async () => {
+    originalCwd = process.cwd();
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lfify-e2e-'));
+  });
+
+  afterEach(async () => {
+    try {
+      process.chdir(originalCwd);
+      if (tempDir) {
+        await fs.rm(tempDir, { recursive: true, force: true });
+      }
+    } catch {
+      // best-effort cleanup
+    }
+  });
+
+  describe('US1: default run (no config)', () => {
+    it('converts files under entry and excludes node_modules and .git', async () => {
+      await copyDir(path.join(FIXTURES_DIR, 'default-sensible'), tempDir);
+      await fs.rename(path.join(tempDir, '_git'), path.join(tempDir, '.git'));
+      await fs.rename(path.join(tempDir, '_node_modules'), path.join(tempDir, 'node_modules'));
+      process.chdir(tempDir);
+
+      const config = await resolveConfig({});
+      await convertCRLFtoLF(config.entry, config);
+
+      const appJs = await fs.readFile(path.join(tempDir, 'src', 'app.js'));
+      expect(appJs.includes(CRLF)).toBe(false);
+      expect(appJs.equals(Buffer.from('console.log("app");\n', 'utf8'))).toBe(true);
+
+      const readmeTxt = await fs.readFile(path.join(tempDir, 'src', 'readme.txt'));
+      expect(readmeTxt.includes(CRLF)).toBe(false);
+      expect(readmeTxt.equals(Buffer.from('hello\nworld\n', 'utf8'))).toBe(true);
+
+      const nodeModulesPkg = await fs.readFile(
+        path.join(tempDir, 'node_modules', 'pkg', 'index.js')
+      );
+      expect(nodeModulesPkg.includes(CRLF)).toBe(true);
+
+      const gitConfig = await fs.readFile(path.join(tempDir, '.git', 'config'));
+      expect(gitConfig.includes(CRLF)).toBe(true);
+    });
+  });
+
+  describe('US2: .lfifyrc.json', () => {
+    it('applies config include/exclude so only matching files are converted', async () => {
+      await copyDir(path.join(FIXTURES_DIR, 'with-config'), tempDir);
+      process.chdir(tempDir);
+
+      const config = await resolveConfig({ configPath: '.lfifyrc.json' });
+      await convertCRLFtoLF(config.entry, config);
+
+      const mainJs = await fs.readFile(path.join(tempDir, 'lib', 'main.js'));
+      expect(mainJs.includes(CRLF)).toBe(false);
+      expect(mainJs.equals(Buffer.from('const x = 1;\n', 'utf8'))).toBe(true);
+
+      const skipOtherJs = await fs.readFile(path.join(tempDir, 'skip', 'other.js'));
+      expect(skipOtherJs.includes(CRLF)).toBe(true);
+
+      const docTxt = await fs.readFile(path.join(tempDir, 'doc.txt'));
+      expect(docTxt.includes(CRLF)).toBe(true);
+    });
+  });
+
+  describe('US3: CLI overrides config', () => {
+    it('CLI include overrides config so only .js files are converted', async () => {
+      await copyDir(path.join(FIXTURES_DIR, 'cli-override'), tempDir);
+      process.chdir(tempDir);
+
+      const config = await resolveConfig({
+        configPath: '.lfifyrc.json',
+        include: ['**/*.js']
+      });
+      await convertCRLFtoLF(config.entry, config);
+
+      const aJs = await fs.readFile(path.join(tempDir, 'src', 'a.js'));
+      expect(aJs.includes(CRLF)).toBe(false);
+      expect(aJs.equals(Buffer.from('const a = 1;\n', 'utf8'))).toBe(true);
+
+      const bTxt = await fs.readFile(path.join(tempDir, 'src', 'b.txt'));
+      expect(bTxt.includes(CRLF)).toBe(true);
+    });
+  });
+
+  describe('US4: already LF', () => {
+    it('does not modify files that already use LF', async () => {
+      await copyDir(path.join(FIXTURES_DIR, 'already-lf'), tempDir);
+      process.chdir(tempDir);
+
+      const config = await resolveConfig({});
+      await convertCRLFtoLF(config.entry, config);
+
+      const fileJs = await fs.readFile(path.join(tempDir, 'src', 'file.js'));
+      expect(fileJs.includes(CRLF)).toBe(false);
+      expect(fileJs.equals(Buffer.from('const x = 1;\n', 'utf8'))).toBe(true);
+    });
+  });
+});

package/index.test.js

@@ -1,48 +1,46 @@
+const mock = require('mock-fs');
 const { readConfig, parseArgs, processFile, resolveConfig, shouldProcessFile, SENSIBLE_DEFAULTS } = require('./index.cjs');
-
-jest.mock('fs');
-jest.mock('path');
-jest.mock('micromatch');
-
-describe('CRLF to LF Converter', () => {
-  const MOCK_FILE_INFO = {
-    './src/file1.txt': 'hello\r\nworld\r\n',
-    './src/file2.js': 'console.log("test");\r\n',
-    './src/subdir/file3.txt': 'test\r\n',
-    './test/file1.txt': 'hello\r\nworld\r\n',
-    './test/file2.js': 'console.log("test");\r\n',
-    './test/subdir/file3.txt': 'test\r\n',
-    './node_modules/file.js': 'console.log("test");\r\n',
-    './node_modules/subdir/file4.txt': 'test\r\n',
-    'index.js': 'console.log("test");\r\n'
+const fs = require('fs');
+
+function baseMock(overrides = {}) {
+  return {
+    'src/file1.txt': 'hello\r\nworld\r\n',
+    'src/file2.js': 'console.log("test");\r\n',
+    'src/subdir/file3.txt': 'test\r\n',
+    'test/file1.txt': 'hello\r\nworld\r\n',
+    'test/file2.js': 'console.log("test");\r\n',
+    'test/subdir/file3.txt': 'test\r\n',
+    'node_modules/file.js': 'console.log("test");\r\n',
+    'node_modules/subdir/file4.txt': 'test\r\n',
+    'index.js': 'console.log("test");\r\n',
+    ...overrides
   };
+}
 
+describe('CRLF to LF Converter', () => {
   let originalArgv;
 
   beforeEach(() => {
-    jest.clearAllMocks();
-    require('fs').__setMockFiles(MOCK_FILE_INFO);
+    mock(baseMock());
     originalArgv = process.argv;
   });
 
   afterEach(() => {
+    mock.restore();
     process.argv = originalArgv;
   });
 
   describe('readConfig', () => {
     it('should return config when valid config file is provided', async () => {
-      // arrange
       const validConfig = {
         entry: './',
         include: ['*.js'],
         exclude: ['node_modules/**']
       };
-      require('fs').__setConfig(JSON.stringify(validConfig));
+      mock(baseMock({ '.lfifyrc.json': JSON.stringify(validConfig) }));
 
-      // act
       const config = await readConfig('.lfifyrc.json');
 
-      // assert
       expect(config).toEqual(expect.objectContaining({
         entry: expect.any(String),
         include: expect.any(Array),
@@ -51,39 +49,30 @@ describe('CRLF to LF Converter', () => {
     });
 
     it('should throw error when config file is not found', async () => {
-      // act & assert
       await expect(readConfig('.lfifyrc.json')).rejects.toThrow();
     });
 
     it('should throw error when config file is invalid json', async () => {
-      // arrange
-      require('fs').__setConfig('invalid json');
+      mock(baseMock({ '.lfifyrc.json': 'invalid json' }));
 
-      // act & assert
       await expect(readConfig('.lfifyrc.json')).rejects.toThrow();
     });
   });
 
   describe('parseArgs', () => {
     it('should return config path when --config option is provided', () => {
-      // arrange
       process.argv = ['node', 'lfify', '--config', './path/for/test/.lfifyrc.json'];
 
-      // act
       const options = parseArgs();
 
-      // assert
       expect(options.configPath).toBe('./path/for/test/.lfifyrc.json');
     });
 
     it('should return default config path when --config option is not provided', () => {
-      // arrange
       process.argv = ['node', 'lfify'];
 
-      // act
       const options = parseArgs();
 
-      // assert
       expect(options.configPath).toBe('.lfifyrc.json');
     });
 
@@ -106,33 +95,25 @@ describe('CRLF to LF Converter', () => {
     });
 
     it('should return multiple exclude patterns when multiple --exclude options are provided', () => {
-      process.argv = ['node', 'lfify', '--exclude', 'node_modules/**', '--exclude', '.git/**'];
+      process.argv = ['node', 'lfify', '--exclude', 'dist/**', '--exclude', 'coverage/**'];
       const options = parseArgs();
-      expect(options.exclude).toEqual(['node_modules/**', '.git/**']);
+      expect(options.exclude).toEqual(['dist/**', 'coverage/**']);
     });
 
     it('should return entry path when --entry option is provided', () => {
       process.argv = ['node', 'lfify', '--entry', './src'];
       const options = parseArgs();
-      expect(options.entry).toBe('./src');
+      expect(options.entry).toContain('src');
     });
 
     it('should handle all options together', () => {
-      process.argv = [
-        'node', 'lfify',
-        '--entry', './src',
-        '--include', '**/*.js',
-        '--include', '**/*.ts',
-        '--exclude', 'node_modules/**',
-        '--config', 'custom.json'
-      ];
+      process.argv = ['node', 'lfify', '--config', 'custom.json', '--include', '*.js', '--exclude', 'dist/**', '--entry', './lib', '--log-level', 'info'];
       const options = parseArgs();
-      expect(options).toEqual({
-        configPath: 'custom.json',
-        entry: './src',
-        include: ['**/*.js', '**/*.ts'],
-        exclude: ['node_modules/**']
-      });
+      expect(options.configPath).toBe('custom.json');
+      expect(options.include).toEqual(['*.js']);
+      expect(options.exclude).toEqual(['dist/**']);
+      expect(options.entry).toContain('lib');
+      expect(options.logLevel).toBe('info');
     });
 
     it('should return undefined for include/exclude/entry when not provided', () => {
@@ -142,77 +123,68 @@ describe('CRLF to LF Converter', () => {
       expect(options.exclude).toBeUndefined();
       expect(options.entry).toBeUndefined();
     });
+
+    it('should return logLevel when --log-level option is provided', () => {
+      process.argv = ['node', 'lfify', '--log-level', 'warn'];
+      const options = parseArgs();
+      expect(options.logLevel).toBe('warn');
+    });
+
+    it('should accept error, warn, info for --log-level', () => {
+      for (const level of ['error', 'warn', 'info']) {
+        process.argv = ['node', 'lfify', '--log-level', level];
+        expect(parseArgs().logLevel).toBe(level);
+      }
+    });
   });
 
   describe('shouldProcessFile', () => {
     it('should return true when file matches include pattern and does not match exclude pattern', () => {
-      const config = {
-        include: ['**/*.js'],
-        exclude: ['node_modules/**']
-      };
-      expect(shouldProcessFile('src/file.js', config)).toBe(true);
+      const config = { include: ['**/*.js'], exclude: ['node_modules/**'] };
+      expect(shouldProcessFile('src/app.js', config)).toBe(true);
     });
 
     it('should return false when file matches exclude pattern', () => {
-      const config = {
-        include: ['**/*.js'],
-        exclude: ['node_modules/**']
-      };
-      expect(shouldProcessFile('node_modules/package/index.js', config)).toBe(false);
+      const config = { include: ['**/*.js'], exclude: ['node_modules/**'] };
+      expect(shouldProcessFile('node_modules/pkg/index.js', config)).toBe(false);
     });
 
     it('should return false when file does not match include pattern', () => {
-      const config = {
-        include: ['**/*.js'],
-        exclude: ['node_modules/**']
-      };
-      expect(shouldProcessFile('src/file.txt', config)).toBe(false);
+      const config = { include: ['**/*.js'], exclude: ['node_modules/**'] };
+      expect(shouldProcessFile('src/readme.txt', config)).toBe(false);
     });
 
     it('should handle multiple include patterns', () => {
-      const config = {
-        include: ['**/*.js', '**/*.ts'],
-        exclude: []
-      };
-      expect(shouldProcessFile('src/file.js', config)).toBe(true);
-      expect(shouldProcessFile('src/file.ts', config)).toBe(true);
-      expect(shouldProcessFile('src/file.txt', config)).toBe(false);
+      const config = { include: ['**/*.js', '**/*.ts'], exclude: ['node_modules/**'] };
+      expect(shouldProcessFile('src/app.js', config)).toBe(true);
+      expect(shouldProcessFile('src/app.ts', config)).toBe(true);
     });
 
     it('should handle multiple exclude patterns', () => {
-      const config = {
-        include: ['**/*.js'],
-        exclude: ['node_modules/**', 'dist/**', 'test/**']
-      };
+      const config = { include: ['**/*.js'], exclude: ['node_modules/**', 'dist/**', 'build/**', 'coverage/**'] };
       expect(shouldProcessFile('src/file.js', config)).toBe(true);
-      expect(shouldProcessFile('node_modules/pkg/index.js', config)).toBe(false);
+      expect(shouldProcessFile('node_modules/pkg/file.js', config)).toBe(false);
       expect(shouldProcessFile('dist/bundle.js', config)).toBe(false);
-      expect(shouldProcessFile('test/unit.js', config)).toBe(false);
+      expect(shouldProcessFile('test/unit.js', config)).toBe(true);
     });
   });
 
   describe('processFile', () => {
     it('should convert CRLF to LF when file is processed', async () => {
-      // arrange
       const shouldbe = 'hello\nworld\n';
 
-      // act
       await processFile('./src/file1.txt');
-      const content = await require('fs').promises.readFile('./src/file1.txt', 'utf8');
+      const content = await fs.promises.readFile('./src/file1.txt', 'utf8');
 
-      // assert
       expect(content).toBe(shouldbe);
     });
 
     it('should not modify file when no CRLF exists', async () => {
-      // arrange
-      require('fs').__setMockFiles({ './src/clean.txt': 'hello\nworld\n' });
+      mock(baseMock({ 'src/clean.txt': 'hello\nworld\n' }));
 
-      // act
       await processFile('./src/clean.txt');
-      const content = await require('fs').promises.readFile('./src/clean.txt', 'utf8');
+      const content = await fs.promises.readFile('./src/clean.txt', 'utf8');
 
-      // assert
       expect(content).toBe('hello\nworld\n');
     });
   });
@@ -239,27 +211,31 @@ describe('CRLF to LF Converter', () => {
     });
 
     it('should override config file values with CLI options', async () => {
-      require('fs').__setConfig(JSON.stringify({
-        entry: './',
-        include: ['**/*.md'],
-        exclude: ['dist/**']
+      mock(baseMock({
+        '.lfifyrc.json': JSON.stringify({
+          entry: './',
+          include: ['**/*.md'],
+          exclude: ['dist/**']
+        })
       }));
 
       const options = {
         configPath: '.lfifyrc.json',
-        include: ['**/*.js'] // CLI should override config
+        include: ['**/*.js']
       };
       const config = await resolveConfig(options);
 
-      expect(config.include).toEqual(['**/*.js']); // CLI override
-      expect(config.exclude).toEqual(['dist/**']); // from config file
+      expect(config.include).toEqual(['**/*.js']);
+      expect(config.exclude).toEqual(['dist/**']);
     });
 
     it('should load config file when configPath is provided and file exists', async () => {
-      require('fs').__setConfig(JSON.stringify({
-        entry: './lib',
-        include: ['**/*.ts'],
-        exclude: ['test/**']
+      mock(baseMock({
+        '.lfifyrc.json': JSON.stringify({
+          entry: './lib',
+          include: ['**/*.ts'],
+          exclude: ['test/**']
+        })
       }));
 
       const options = { configPath: '.lfifyrc.json' };
@@ -270,7 +246,6 @@ describe('CRLF to LF Converter', () => {
     });
 
     it('should use defaults when config file not found and no CLI options', async () => {
-      // No config file set up - mock will throw ENOENT
       const options = { configPath: 'nonexistent.json' };
       const config = await resolveConfig(options);
 
@@ -293,5 +268,39 @@ describe('CRLF to LF Converter', () => {
       expect(config.include).toEqual(SENSIBLE_DEFAULTS.include);
       expect(config.exclude).toEqual(['custom/**']);
     });
+
+    it('should include logLevel in config, defaulting to error', async () => {
+      const config = await resolveConfig({});
+      expect(config.logLevel).toBe('error');
+    });
+
+    it('should use logLevel from config file when provided', async () => {
+      mock(baseMock({
+        '.lfifyrc.json': JSON.stringify({
+          entry: './',
+          include: ['**/*.js'],
+          exclude: ['node_modules/**'],
+          logLevel: 'info'
+        })
+      }));
+      const config = await resolveConfig({ configPath: '.lfifyrc.json' });
+      expect(config.logLevel).toBe('info');
+    });
+
+    it('should override config file logLevel with CLI --log-level', async () => {
+      mock(baseMock({
+        '.lfifyrc.json': JSON.stringify({
+          entry: './',
+          include: ['**/*.js'],
+          exclude: ['node_modules/**'],
+          logLevel: 'warn'
+        })
+      }));
+      const config = await resolveConfig({
+        configPath: '.lfifyrc.json',
+        logLevel: 'info'
+      });
+      expect(config.logLevel).toBe('info');
+    });
   });
-}); 
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lfify",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "private": false,
   "description": "make your crlf to lf",
   "main": "index.cjs",
@@ -9,7 +9,9 @@
     "lfify": "./index.cjs"
   },
   "scripts": {
-    "test": "jest",
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:unit": "jest --testPathPattern=\"index\\.test\\.js\"",
+    "test:e2e": "jest --testPathPattern=\"index\\.e2e\\.test\\.js\"",
     "lint": "eslint ."
   },
   "repository": {
@@ -17,7 +19,8 @@
     "url": "https://github.com/GyeongHoKim/lfify.git"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true,
     "tag": "latest"
   },
   "keywords": [
@@ -44,6 +47,7 @@
     "eslint": "^9.15.0",
     "globals": "^15.12.0",
     "jest": "^29.7.0",
+    "mock-fs": "^5.5.0",
     "semantic-release": "^25.0.2"
   }
 }

package/__mocks__/fs.js

@@ -1,56 +0,0 @@
-const fs = jest.createMockFromModule('fs');
-
-const mockFiles = new Map();
-
-function __setMockFiles(newMockFiles) {
-  mockFiles.clear();
-  for (const [path, content] of Object.entries(newMockFiles)) {
-    mockFiles.set(path, content);
-  }
-}
-
-function __setConfig(stringifiedConfig, path = '.lfifyrc.json') {
-  mockFiles.set(path, stringifiedConfig);
-}
-
-const promises = {
-  /* eslint-disable-next-line no-unused-vars */
-  readFile: jest.fn().mockImplementation((path, ...rest) => {
-    if (mockFiles.has(path)) {
-      return Promise.resolve(mockFiles.get(path));
-    }
-    const error = new Error(`ENOENT: no such file or directory, open '${path}'`);
-    error.code = 'ENOENT';
-    return Promise.reject(error);
-  }),
-
-  writeFile: jest.fn().mockImplementation((path, content) => {
-    mockFiles.set(path, content);
-    return Promise.resolve();
-  }),
-
-  /* eslint-disable-next-line no-unused-vars */
-  readdir: jest.fn().mockImplementation((path, ...rest) => {
-    const entries = [];
-    for (const filePath of mockFiles.keys()) {
-      if (filePath.startsWith(path)) {
-        const relativePath = filePath.slice(path.length + 1);
-        const name = relativePath.split('/')[0];
-        if (name && !entries.some(e => e.name === name)) {
-          entries.push({
-            name,
-            isFile: () => !name.includes('/'),
-            isDirectory: () => name.includes('/')
-          });
-        }
-      }
-    }
-    return Promise.resolve(entries);
-  })
-};
-
-fs.promises = promises;
-fs.__setMockFiles = __setMockFiles;
-fs.__setConfig = __setConfig;
-
-module.exports = fs;

package/__mocks__/micromatch.js

@@ -1,39 +0,0 @@
-const micromatch = jest.createMockFromModule('micromatch');
-
-micromatch.isMatch = jest.fn().mockImplementation((filePath, patterns) => {
-  if (!Array.isArray(patterns)) {
-    patterns = [patterns];
-  }
-
-  // 간단한 glob 패턴 매칭 구현
-  return patterns.some(pattern => {
-    // 정확한 매칭
-    if (pattern === filePath) return true;
-
-    // glob 패턴을 정규식으로 변환
-    // 플레이스홀더를 사용해서 순서 문제 해결
-    const GLOBSTAR_SLASH = '___GLOBSTARSLASH___';
-    const GLOBSTAR = '___GLOBSTAR___';
-
-    let regexPattern = pattern
-      // **/ 패턴을 플레이스홀더로 임시 변환
-      .replace(/\*\*\//g, GLOBSTAR_SLASH)
-      // ** 패턴을 플레이스홀더로 임시 변환
-      .replace(/\*\*/g, GLOBSTAR)
-      // {a,b} 패턴
-      .replace(/\{([^}]+)\}/g, (_, group) => `(${group.split(',').join('|')})`)
-      // 특수문자 이스케이프 (*, ?, / 제외)
-      .replace(/[.+^$|()[\]\\]/g, '\\$&')
-      // * 패턴: 슬래시를 제외한 모든 것 매칭
-      .replace(/\*/g, '[^/]*')
-      // ? 패턴: 슬래시를 제외한 한 문자 매칭
-      .replace(/\?/g, '[^/]')
-      // 플레이스홀더를 실제 정규식으로 변환
-      .replace(new RegExp(GLOBSTAR_SLASH, 'g'), '(?:.*/)?')
-      .replace(new RegExp(GLOBSTAR, 'g'), '.*');
-
-    return new RegExp(`^${regexPattern}$`).test(filePath);
-  });
-});
-
-module.exports = micromatch;