lfify 1.1.0 → 1.2.0

package/.github/workflows/cd.yml

@@ -4,13 +4,11 @@ on:
     branches:
       - main
 
-permissions:
-  contents: read # for checkout
-
 jobs:
   release:
     name: Release
     runs-on: ubuntu-latest
+    environment: npm
     permissions:
       contents: write # to be able to publish a GitHub release
       issues: write # to be able to comment on released issues
@@ -22,9 +20,9 @@ jobs:
         with:
           fetch-depth: 0
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        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
@@ -32,5 +30,6 @@ jobs:
       - name: Release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: 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/.releaserc.json

@@ -0,0 +1,21 @@
+{
+  "branches": ["main"],
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    [
+      "@semantic-release/changelog",
+      {
+        "changelogFile": "CHANGELOG.md"
+      }
+    ],
+    "@semantic-release/npm",
+    [
+      "@semantic-release/git",
+      {
+        "assets": ["package.json", "package-lock.json", "CHANGELOG.md"],
+        "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+      }
+    ]
+  ]
+}

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/README.md

@@ -1,13 +1,19 @@
 # LFify
 
-> ⚠️ **Warning**: All files must be encoded in UTF-8. The library is being developed to automatically convert UTF-8 with BOM to UTF-8 without BOM. Using different encodings may cause unexpected issues.
-
-A lightweight Node.js library to convert CRLF to LF line endings.  
-It is useful when your development environment is Windows.  
+A lightweight Node.js program to convert CRLF to LF line endings.  
+It is useful when your development environment is Windows.
 
 ## Getting started
 
-create .lfifyrc.json
+### Using CLI options (no config file needed)
+
+```bash
+npx lfify --include "**/*.js" --exclude "node_modules/**"
+```
+
+### Using config file
+
+Create `.lfifyrc.json`:
 
 ```json
 {
@@ -25,22 +31,52 @@ create .lfifyrc.json
     "build/**",
     "coverage/**"
   ]
-} 
+}
 ```
 
-and then
+Then run:
 
 ```bash
-npx lifify
+npx lfify
 ```
 
-you can add options below.
-
 ## Options
 
-| Option | Description |
-|--------|-------------|
-| `--config <path>` | Specify a custom path for the configuration file. Default is `.lfifyrc.json` in the current directory. |
+| Option               | Description                                                                 |
+| -------------------- | --------------------------------------------------------------------------- |
+| `--config <path>`    | Specify a custom path for the configuration file. Default is `.lfifyrc.json`. |
+| `--entry <path>`     | Specify the entry directory to process. Default is `./`.                    |
+| `--include <pattern>`| Glob pattern(s) to include. Can be used multiple times.                     |
+| `--exclude <pattern>`| Glob pattern(s) to exclude. Can be used multiple times.                     |
+
+## Examples
+
+```bash
+# Process all JavaScript files, exclude node_modules
+npx lfify --include "**/*.js" --exclude "node_modules/**"
+
+# Process multiple file types
+npx lfify --include "**/*.js" --include "**/*.ts" --exclude "node_modules/**" --exclude ".git/**"
+
+# Process files in a specific directory
+npx lfify --entry ./src --include "**/*.js"
+
+# Use a custom config file
+npx lfify --config ./custom-config.json
+```
+
+## Default behavior
+
+When no config file is found and no CLI options are provided, lfify uses sensible defaults:
+- **include**: `**/*` (all files)
+- **exclude**: `node_modules/**`, `.git/**`, `dist/**`, `build/**`, `coverage/**`
+
+## Priority
+
+CLI options take precedence over config file values:
+1. CLI arguments (highest)
+2. Config file
+3. Default values (lowest)
 
 # Development
 

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 - 정보 메시지 출력
@@ -20,7 +28,11 @@ const micromatch = require("micromatch");
 
 /**
  * @typedef {Object} CommandOptions
- * @property {string} configPath - 설정 파일 경로
+ * @property {string} [configPath] - 설정 파일 경로
+ * @property {string} [entry] - CLI로 지정한 entry 경로
+ * @property {string[]} [include] - CLI로 지정한 include 패턴
+ * @property {string[]} [exclude] - CLI로 지정한 exclude 패턴
+ * @property {'error'|'warn'|'info'} [logLevel] - CLI로 지정한 로그 레벨
  */
 
 /**
@@ -30,7 +42,25 @@ const micromatch = require("micromatch");
 const DEFAULT_CONFIG = {
   entry: './',
   include: [],
-  exclude: []
+  exclude: [],
+  logLevel: 'error'
+};
+
+/**
+ * Sensible defaults when no config file is provided
+ * @type {Config}
+ */
+const SENSIBLE_DEFAULTS = {
+  entry: './',
+  include: ['**/*'],
+  exclude: [
+    'node_modules/**',
+    '.git/**',
+    'dist/**',
+    'build/**',
+    'coverage/**'
+  ],
+  logLevel: 'error'
 };
 
 /**
@@ -41,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}`);
+    }
+  },
 };
 
 /**
@@ -61,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
@@ -74,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') {
@@ -82,7 +137,7 @@ async function readConfig(configPath) {
     } else {
       logger.error(`Error reading configuration file: ${err.message}`, configPath);
     }
-    
+
     if (require.main === module) {
       process.exit(1);
     }
@@ -90,6 +145,95 @@ async function readConfig(configPath) {
   }
 }
 
+/**
+ * Resolve final configuration from CLI options, config file, and defaults
+ * @param {CommandOptions} cliOptions - parsed CLI options
+ * @returns {Promise<Config>} - resolved configuration
+ */
+async function resolveConfig(cliOptions) {
+  let fileConfig = null;
+
+  // Try to load config file if it exists
+  if (cliOptions.configPath) {
+    try {
+      const configContent = await readFile(cliOptions.configPath, 'utf8');
+      fileConfig = JSON.parse(configContent);
+
+      // Validate config file fields
+      for (const [key, validator] of Object.entries(CONFIG_SCHEMA)) {
+        if (fileConfig[key] && !validator(fileConfig[key])) {
+          throw new Error(`Invalid "${key}" in configuration file`);
+        }
+      }
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        // Re-throw parsing/validation errors
+        logger.error(`Error reading configuration file: ${err.message}`, cliOptions.configPath);
+        throw err;
+      }
+      // ENOENT is okay - config file is optional now
+    }
+  }
+
+  // Determine final values with precedence: CLI > config file > defaults
+  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, logLevel;
+
+  // Include: CLI > file > default
+  if (hasCLIInclude) {
+    include = cliOptions.include;
+  } else if (hasFileInclude) {
+    include = fileConfig.include;
+  } else {
+    include = SENSIBLE_DEFAULTS.include;
+  }
+
+  // Exclude: CLI > file > default
+  if (hasCLIExclude) {
+    exclude = cliOptions.exclude;
+  } else if (hasFileExclude) {
+    exclude = fileConfig.exclude;
+  } else {
+    exclude = SENSIBLE_DEFAULTS.exclude;
+  }
+
+  // Entry: CLI > file > default
+  if (hasCLIEntry) {
+    entry = cliOptions.entry;
+  } else if (hasFileEntry) {
+    entry = fileConfig.entry;
+  } else {
+    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: resolve(process.cwd(), entry),
+    include,
+    exclude,
+    logLevel
+  };
+}
+
 /**
  * Parse command line arguments
  * @returns {CommandOptions} - parsed arguments
@@ -101,9 +245,46 @@ function parseArgs() {
   };
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--config' && args[i + 1]) {
-      options.configPath = args[i + 1];
-      i++;
+    const arg = args[i];
+    const nextArg = args[i + 1];
+
+    switch (arg) {
+      case '--config':
+        if (nextArg) {
+          options.configPath = nextArg;
+          i++;
+        }
+        break;
+
+      case '--entry':
+        if (nextArg) {
+          options.entry = nextArg;
+          i++;
+        }
+        break;
+
+      case '--include':
+        if (nextArg) {
+          options.include = options.include || [];
+          options.include.push(nextArg);
+          i++;
+        }
+        break;
+
+      case '--exclude':
+        if (nextArg) {
+          options.exclude = options.exclude || [];
+          options.exclude.push(nextArg);
+          i++;
+        }
+        break;
+
+      case '--log-level':
+        if (nextArg && LOG_LEVELS.includes(nextArg)) {
+          options.logLevel = nextArg;
+          i++;
+        }
+        break;
     }
   }
 
@@ -117,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;
 }
@@ -132,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);
@@ -162,29 +343,45 @@ 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 readConfig(options.configPath);
+  const config = await resolveConfig(options);
+
+  logger.setLogLevel(config.logLevel);
 
   logger.info(`converting CRLF to LF in: ${config.entry}`, config.entry);
 
@@ -202,4 +399,7 @@ module.exports = {
   processFile,
   readConfig,
   parseArgs,
+  resolveConfig,
+  shouldProcessFile,
+  SENSIBLE_DEFAULTS,
 };

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,41 +1,46 @@
-const { readConfig, parseArgs, processFile } = require('./index.cjs');
+const mock = require('mock-fs');
+const { readConfig, parseArgs, processFile, resolveConfig, shouldProcessFile, SENSIBLE_DEFAULTS } = require('./index.cjs');
+const fs = require('fs');
 
-jest.mock('fs');
-jest.mock('path');
-jest.mock('micromatch');
+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', () => {
-  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'
-  };
-  
+  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),
@@ -44,64 +49,258 @@ 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');
     });
+
+    it('should return include patterns when single --include option is provided', () => {
+      process.argv = ['node', 'lfify', '--include', '**/*.js'];
+      const options = parseArgs();
+      expect(options.include).toEqual(['**/*.js']);
+    });
+
+    it('should return multiple include patterns when multiple --include options are provided', () => {
+      process.argv = ['node', 'lfify', '--include', '**/*.js', '--include', '**/*.ts'];
+      const options = parseArgs();
+      expect(options.include).toEqual(['**/*.js', '**/*.ts']);
+    });
+
+    it('should return exclude patterns when --exclude option is provided', () => {
+      process.argv = ['node', 'lfify', '--exclude', 'node_modules/**'];
+      const options = parseArgs();
+      expect(options.exclude).toEqual(['node_modules/**']);
+    });
+
+    it('should return multiple exclude patterns when multiple --exclude options are provided', () => {
+      process.argv = ['node', 'lfify', '--exclude', 'dist/**', '--exclude', 'coverage/**'];
+      const options = parseArgs();
+      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).toContain('src');
+    });
+
+    it('should handle all options together', () => {
+      process.argv = ['node', 'lfify', '--config', 'custom.json', '--include', '*.js', '--exclude', 'dist/**', '--entry', './lib', '--log-level', 'info'];
+      const options = parseArgs();
+      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', () => {
+      process.argv = ['node', 'lfify'];
+      const options = parseArgs();
+      expect(options.include).toBeUndefined();
+      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', () => {
-      /**
-       * This function uses micromatch to check config.include and config.exclude
-       * so this test case is already tested in micromatch's test file
-       * so I'm not going to test this function
-       */
+      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/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/readme.txt', config)).toBe(false);
+    });
+
+    it('should handle multiple include patterns', () => {
+      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/**', 'build/**', 'coverage/**'] };
+      expect(shouldProcessFile('src/file.js', config)).toBe(true);
+      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(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 () => {
+      mock(baseMock({ 'src/clean.txt': 'hello\nworld\n' }));
+
+      await processFile('./src/clean.txt');
+      const content = await fs.promises.readFile('./src/clean.txt', 'utf8');
+
+      expect(content).toBe('hello\nworld\n');
+    });
+  });
+
+  describe('resolveConfig', () => {
+    it('should use CLI options when provided without config file', async () => {
+      const options = {
+        include: ['**/*.js'],
+        exclude: ['node_modules/**'],
+        entry: './src'
+      };
+      const config = await resolveConfig(options);
+
+      expect(config.include).toEqual(['**/*.js']);
+      expect(config.exclude).toEqual(['node_modules/**']);
+      expect(config.entry).toContain('src');
+    });
+
+    it('should use sensible defaults when no config file and no CLI options', async () => {
+      const config = await resolveConfig({});
+
+      expect(config.include).toEqual(SENSIBLE_DEFAULTS.include);
+      expect(config.exclude).toEqual(SENSIBLE_DEFAULTS.exclude);
+    });
+
+    it('should override config file values with CLI options', async () => {
+      mock(baseMock({
+        '.lfifyrc.json': JSON.stringify({
+          entry: './',
+          include: ['**/*.md'],
+          exclude: ['dist/**']
+        })
+      }));
+
+      const options = {
+        configPath: '.lfifyrc.json',
+        include: ['**/*.js']
+      };
+      const config = await resolveConfig(options);
+
+      expect(config.include).toEqual(['**/*.js']);
+      expect(config.exclude).toEqual(['dist/**']);
+    });
+
+    it('should load config file when configPath is provided and file exists', async () => {
+      mock(baseMock({
+        '.lfifyrc.json': JSON.stringify({
+          entry: './lib',
+          include: ['**/*.ts'],
+          exclude: ['test/**']
+        })
+      }));
+
+      const options = { configPath: '.lfifyrc.json' };
+      const config = await resolveConfig(options);
+
+      expect(config.include).toEqual(['**/*.ts']);
+      expect(config.exclude).toEqual(['test/**']);
+    });
+
+    it('should use defaults when config file not found and no CLI options', async () => {
+      const options = { configPath: 'nonexistent.json' };
+      const config = await resolveConfig(options);
+
+      expect(config.include).toEqual(SENSIBLE_DEFAULTS.include);
+      expect(config.exclude).toEqual(SENSIBLE_DEFAULTS.exclude);
+    });
+
+    it('should use CLI include with default exclude when only include provided', async () => {
+      const options = { include: ['**/*.js'] };
+      const config = await resolveConfig(options);
+
+      expect(config.include).toEqual(['**/*.js']);
+      expect(config.exclude).toEqual(SENSIBLE_DEFAULTS.exclude);
+    });
+
+    it('should use CLI exclude with default include when only exclude provided', async () => {
+      const options = { exclude: ['custom/**'] };
+      const config = await resolveConfig(options);
+
+      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.0",
+  "version": "1.2.0",
   "private": false,
   "description": "make your crlf to lf",
   "main": "index.cjs",
@@ -9,15 +9,19 @@
     "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": {
     "type": "git",
-    "url": "https://github.com/GyeongHoKim/lfify"
+    "url": "https://github.com/GyeongHoKim/lfify.git"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org"
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true,
+    "tag": "latest"
   },
   "keywords": [
     "eol",
@@ -35,8 +39,15 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.15.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^13.1.3",
+    "@semantic-release/release-notes-generator": "^14.1.0",
     "eslint": "^9.15.0",
     "globals": "^15.12.0",
-    "jest": "^29.7.0"
+    "jest": "^29.7.0",
+    "mock-fs": "^5.5.0",
+    "semantic-release": "^25.0.2"
   }
 }

package/__mocks__/fs.js

@@ -1,54 +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));
-    }
-    return Promise.reject(new Error(`ENOENT: no such file or directory, open '${path}'`));
-  }),
-
-  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,23 +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;
-
-    // 와일드카드 매칭
-    const regexPattern = pattern
-      .replace(/\./g, '\\.')
-      .replace(/\*/g, '.*')
-      .replace(/\?/g, '.');
-    
-    return new RegExp(`^${regexPattern}$`).test(filePath);
-  });
-});
-
-module.exports = micromatch;