com.wallstop-studios.dxmessaging 2.1.3 → 2.1.5

package/scripts/check-eol.js

@@ -5,8 +5,33 @@
 */
 const fs = require('fs');
 const path = require('path');
+const { spawnSync } = require('child_process');
 
-const repoRoot = process.cwd();
+function getGitRepoRoot() {
+  const result = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd: process.cwd(),
+    encoding: 'utf8'
+  });
+  if (result.status === 0 && result.stdout) {
+    return result.stdout.trim();
+  }
+  // Fallback to cwd if not in a git repo
+  return process.cwd();
+}
+
+const repoRoot = getGitRepoRoot();
+const argv = process.argv.slice(2);
+let checkEntireRepo = false;
+const targetArgs = [];
+
+// Parse arguments: --all checks entire repo, otherwise paths are checked
+for (const arg of argv) {
+  if (arg === '--all') {
+    checkEntireRepo = true;
+    continue;
+  }
+  targetArgs.push(arg);
+}
 
 // Exclude directory patterns (match anywhere in path)
 const excludeRegexes = [
@@ -16,12 +41,16 @@ const excludeRegexes = [
   /(^|[\/\\])(Obj|obj)([\/\\]|$)/,
   /(^|[\/\\])Temp([\/\\]|$)/,
   /(^|[\/\\])Samples~([\/\\]|$)/,
-  /(^|[\/\\])\.vs([\/\\]|$)/
+  /(^|[\/\\])\.vs([\/\\]|$)/,
+  /(^|[\/\\])\.venv([\/\\]|$)/,
+  /(^|[\/\\])\.artifacts([\/\\]|$)/,
+  /(^|[\/\\])site([\/\\]|$)/
 ];
 
-// Text file extensions to validate
-const exts = new Set([
+// Text file extensions that require CRLF line endings
+const crlfExts = new Set([
   '.cs', '.csproj', '.sln',
+  '.js', '.cjs', '.mjs',
   '.json', '.jsonc', '.toml',
   '.yaml', '.yml',
   '.md', '.markdown',
@@ -31,9 +60,39 @@ const exts = new Set([
   '.ps1'
 ]);
 
-/** Recursively collect file paths under dir */
+// Shell scripts require LF line endings for Unix compatibility
+const lfExts = new Set(['.sh', '.bash', '.zsh', '.ksh', '.fish']);
+
+// Git hooks directory - files here need LF regardless of extension
+const hooksDir = path.join('scripts', 'hooks');
+
+// All text file extensions we validate
+const exts = new Set([...crlfExts, ...lfExts]);
+
+/**
+ * Check if a file is a git hook (no extension, in hooks directory)
+ * @param {string} filePath - Absolute path to the file.
+ * @returns {boolean} True if the file is a git hook.
+ */
+function isGitHook(filePath) {
+  const rel = path.relative(repoRoot, filePath);
+  return rel.startsWith(hooksDir + path.sep) && path.extname(filePath) === '';
+}
+
+/**
+ * Recursively collect file paths under dir, excluding paths matching excludeRegexes.
+ * @param {string} dir - Absolute path to the directory to walk.
+ * @param {string[]} files - Accumulator array for collected file paths.
+ * @returns {string[]} Array of absolute file paths.
+ */
 function walk(dir, files = []) {
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    console.warn(`Warning: cannot read directory, skipping: ${dir} (${err.code || err.message})`);
+    return files;
+  }
   for (const ent of entries) {
     const full = path.join(dir, ent.name);
     if (excludeRegexes.some((re) => re.test(full))) {
@@ -48,10 +107,148 @@ function walk(dir, files = []) {
   return files;
 }
 
+/**
+ * Resolve target paths (files or directories) to an array of absolute file paths.
+ * Paths are resolved relative to the git repository root.
+ * @param {string[]} targets - Array of relative or absolute paths (files or directories).
+ * @returns {string[]} Array of absolute file paths, deduplicated and filtered by exclusions.
+ */
+function resolveTargets(targets) {
+  if (!targets || targets.length === 0) {
+    return [];
+  }
+
+  const seen = new Set();
+  const resolved = [];
+
+  for (const rawTarget of targets) {
+    // Paths are resolved relative to git repo root (not cwd), matching git's behavior
+    const targetPath = path.resolve(repoRoot, rawTarget);
+    if (!fs.existsSync(targetPath)) {
+      console.warn(`Warning: path does not exist, skipping: ${rawTarget} (resolved to: ${targetPath})`);
+      continue;
+    }
+
+    const isExcluded = excludeRegexes.some((re) => re.test(targetPath));
+    if (isExcluded) {
+      continue;
+    }
+
+    const stats = fs.statSync(targetPath);
+    if (stats.isDirectory()) {
+      for (const file of walk(targetPath)) {
+        if (!seen.has(file)) {
+          resolved.push(file);
+          seen.add(file);
+        }
+      }
+    } else if (stats.isFile()) {
+      if (!seen.has(targetPath)) {
+        resolved.push(targetPath);
+        seen.add(targetPath);
+      }
+    }
+  }
+
+  return resolved;
+}
+
+/**
+ * Get list of staged files from git (Added, Copied, Modified, Renamed).
+ * Returns paths relative to repoRoot, suitable for passing to resolveTargets().
+ * @returns {string[]} Array of staged file paths relative to repo root.
+ */
+function getStagedFiles() {
+  const result = spawnSync('git', ['diff', '--cached', '--name-only', '--diff-filter=ACMR'], {
+    cwd: repoRoot,
+    encoding: 'utf8'
+  });
+
+  if (result.status !== 0) {
+    return [];
+  }
+
+  return result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Check for non-normalized line endings in the git index for tracked text files.
+ * The repository should store LF even when working tree uses CRLF.
+ * @param {string[]} files - Absolute file paths to check.
+ * @returns {Array<{path: string, indexEol: string}>} Array of index EOL issues.
+ */
+function getIndexEolIssues(files) {
+  if (!files || files.length === 0) {
+    return [];
+  }
+
+  const relPaths = files.map((file) => path.relative(repoRoot, file));
+  const result = spawnSync('git', ['ls-files', '--eol', '--', ...relPaths], {
+    cwd: repoRoot,
+    encoding: 'utf8'
+  });
+
+  if (result.status !== 0 || !result.stdout) {
+    return [];
+  }
+
+  const issues = [];
+  const lines = result.stdout.split(/\r?\n/);
+  for (const line of lines) {
+    if (!line) {
+      continue;
+    }
+    const tabIndex = line.indexOf('\t');
+    if (tabIndex < 0) {
+      continue;
+    }
+    const meta = line.slice(0, tabIndex).trim();
+    const filePath = line.slice(tabIndex + 1).trim();
+    const ext = path.extname(filePath).toLowerCase();
+    const fullPath = path.resolve(repoRoot, filePath);
+    const isHook = isGitHook(fullPath);
+    
+    // Skip if not a known text file extension and not a git hook
+    if (!exts.has(ext) && !isHook) {
+      continue;
+    }
+
+    // git ls-files --eol output format: i/[eol] w/[eol] attr/[attrs] [path]
+    const parts = meta.split(/\s+/);
+    const indexToken = parts.find((part) => part.startsWith('i/'));
+    const attrToken = parts.find((part) => part.startsWith('attr/'));
+    if (!indexToken) {
+      continue;
+    }
+    if (attrToken === 'attr/-text') {
+      continue;
+    }
+
+    if (indexToken !== 'i/lf' && indexToken !== 'i/none') {
+      issues.push({ path: filePath, indexEol: indexToken });
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Check if a buffer starts with UTF-8 BOM (byte order mark).
+ * @param {Buffer} buf - File content buffer.
+ * @returns {boolean} True if BOM is present.
+ */
 function hasBom(buf) {
   return buf.length >= 3 && buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf;
 }
 
+/**
+ * Check if buffer contains non-CRLF line endings (bare LF or CR).
+ * @param {Buffer} buf - File content buffer.
+ * @returns {boolean} True if non-CRLF line endings are found.
+ */
 function hasNonCrlfEol(buf) {
   const txt = buf.toString('utf8');
   // Strip all valid CRLF pairs; any remaining bare \n or \r is invalid
@@ -59,36 +256,110 @@ function hasNonCrlfEol(buf) {
   return stripped.includes('\n') || stripped.includes('\r');
 }
 
-const allFiles = walk(repoRoot);
+/**
+ * Check if buffer contains non-LF line endings (CRLF or bare CR).
+ * Used for shell scripts that must use LF only.
+ * @param {Buffer} buf - File content buffer.
+ * @returns {boolean} True if non-LF line endings are found.
+ */
+function hasNonLfEol(buf) {
+  const txt = buf.toString('utf8');
+  // CRLF or bare CR are invalid for LF-only files
+  return txt.includes('\r');
+}
+
+const candidateFiles = checkEntireRepo
+  ? walk(repoRoot)
+  : resolveTargets(targetArgs.length > 0 ? targetArgs : getStagedFiles());
+
+const textFiles = [];
+const seenFiles = new Set();
+
+for (const file of candidateFiles) {
+  const ext = path.extname(file).toLowerCase();
+  const isHook = isGitHook(file);
+  
+  // Process if it has a known extension OR if it's a git hook
+  if (!exts.has(ext) && !isHook) {
+    continue;
+  }
+
+  // candidateFiles already contains absolute paths from walk() or resolveTargets()
+  if (seenFiles.has(file)) {
+    continue;
+  }
+
+  seenFiles.add(file);
+  textFiles.push(file);
+}
+
+if (textFiles.length === 0) {
+  console.log('EOL check skipped: no matching files to verify.');
+  process.exit(0);
+}
+
 const bomFiles = [];
 const badEolFiles = [];
+const indexEolIssues = getIndexEolIssues(textFiles);
 
-for (const file of allFiles) {
-  const ext = path.extname(file).toLowerCase();
-  if (!exts.has(ext)) continue;
+for (const file of textFiles) {
   let buf;
   try {
     buf = fs.readFileSync(file);
-  } catch {
+  } catch (err) {
+    console.warn(`Warning: cannot read file, skipping: ${file} (${err.code || err.message})`);
     continue;
   }
   if (hasBom(buf)) bomFiles.push(path.relative(repoRoot, file));
-  if (hasNonCrlfEol(buf)) badEolFiles.push(path.relative(repoRoot, file));
+  
+  const ext = path.extname(file).toLowerCase();
+  const isHook = isGitHook(file);
+  
+  // Shell scripts and git hooks must use LF only
+  const needsLf = lfExts.has(ext) || isHook;
+  if (needsLf) {
+    if (hasNonLfEol(buf)) badEolFiles.push(path.relative(repoRoot, file));
+  } else {
+    // All other text files must use CRLF
+    if (hasNonCrlfEol(buf)) badEolFiles.push(path.relative(repoRoot, file));
+  }
 }
 
-if (bomFiles.length === 0 && badEolFiles.length === 0) {
-  console.log('EOL check passed: CRLF only and no BOMs detected.');
+if (bomFiles.length === 0 && badEolFiles.length === 0 && indexEolIssues.length === 0) {
+  console.log(`EOL check passed: ${textFiles.length} file(s) verified (CRLF for text files, LF for shell scripts), no BOMs detected.`);
   process.exit(0);
 }
 
 if (bomFiles.length) {
-  console.log('Files contain a UTF-8 BOM (should be no BOM):');
-  for (const f of bomFiles) console.log(`  ${f}`);
+  console.error('Files contain a UTF-8 BOM (should be no BOM):');
+  for (const f of bomFiles) console.error(`  ${f}`);
 }
 if (badEolFiles.length) {
-  console.log('Files contain non-CRLF line endings (found LF or bare CR):');
-  for (const f of badEolFiles) console.log(`  ${f}`);
+  // Separate CRLF-required files from LF-required files (shell scripts + git hooks)
+  const crlfViolations = badEolFiles.filter((f) => {
+    const fullPath = path.resolve(repoRoot, f);
+    return !lfExts.has(path.extname(f).toLowerCase()) && !isGitHook(fullPath);
+  });
+  const lfViolations = badEolFiles.filter((f) => {
+    const fullPath = path.resolve(repoRoot, f);
+    return lfExts.has(path.extname(f).toLowerCase()) || isGitHook(fullPath);
+  });
+  
+  if (crlfViolations.length) {
+    console.error('Files require CRLF line endings but contain LF or bare CR:');
+    for (const f of crlfViolations) console.error(`  ${f}`);
+  }
+  if (lfViolations.length) {
+    console.error('Shell scripts and git hooks require LF line endings but contain CRLF or bare CR:');
+    for (const f of lfViolations) console.error(`  ${f}`);
+  }
+}
+if (indexEolIssues.length) {
+  console.error('Git index contains non-normalized line endings (expected LF in repo for text files):');
+  for (const issue of indexEolIssues) {
+    console.error(`  ${issue.path} (${issue.indexEol})`);
+  }
+  console.error('Fix: Run "node scripts/fix-eol.js" then re-stage affected files.');
 }
 console.error('EOL/BOM policy violations detected.');
 process.exit(1);
-

package/scripts/check-eol.ps1

@@ -10,6 +10,54 @@ function Write-VerboseLine {
     if ($VerboseOutput) { Write-Host $Message }
 }
 
+function Get-GitIndexEolIssues {
+    param([string[]]$Extensions)
+
+    $issues = New-Object System.Collections.Generic.List[string]
+    try {
+        $gitRoot = git rev-parse --show-toplevel 2>$null
+    }
+    catch {
+        return $issues
+    }
+
+    if (-not $gitRoot) {
+        return $issues
+    }
+
+    $gitRoot = $gitRoot.Trim()
+    try {
+        $lines = git -C $gitRoot ls-files --eol 2>$null
+    }
+    catch {
+        return $issues
+    }
+
+    foreach ($line in $lines) {
+        if ([string]::IsNullOrWhiteSpace($line)) { continue }
+        $parts = $line -split "`t", 2
+        if ($parts.Count -lt 2) { continue }
+
+        $meta = $parts[0].Trim()
+        $relPath = $parts[1].Trim()
+        $ext = [System.IO.Path]::GetExtension($relPath).ToLowerInvariant()
+        if ($Extensions -notcontains $ext) { continue }
+
+        # git ls-files --eol output format: i/[eol] w/[eol] attr/[attrs] [path]
+        $tokens = $meta -split '\s+'
+        $attrToken = $tokens | Where-Object { $_ -like 'attr/*' } | Select-Object -First 1
+        if ($attrToken -eq 'attr/-text') { continue }
+        
+        $indexToken = $tokens | Where-Object { $_ -like 'i/*' } | Select-Object -First 1
+        if (-not $indexToken) { continue }
+        if ($indexToken -ne 'i/lf' -and $indexToken -ne 'i/none') {
+            $issues.Add("$relPath ($indexToken)")
+        }
+    }
+
+    return $issues
+}
+
 # Directories to exclude from scanning
 $excludePatterns = @(
     "[\\/]\.git[\\/]",
@@ -18,12 +66,16 @@ $excludePatterns = @(
     "[\\/]Obj[\\/]|[\\/]obj[\\/]",
     "[\\/]Temp[\\/]",
     "[\\/]Samples~[\\/]",
-    "[\\/]\.vs[\\/]"
+    "[\\/]\.vs[\\/]",
+    "[\\/]\.venv[\\/]",
+    "[\\/]\.artifacts[\\/]",
+    "[\\/]site[\\/]"
 )
 
-# File extensions we treat as text and validate
+# File extensions we treat as text and validate (CRLF expected)
 $extensions = @(
     '.cs', '.csproj', '.sln',
+    '.js', '.cjs', '.mjs',
     '.json', '.jsonc', '.toml',
     '.yaml', '.yml',
     '.md', '.markdown',
@@ -33,11 +85,25 @@ $extensions = @(
     '.ps1'
 )
 
+# Shell scripts must use LF for Unix compatibility
+$lfExtensions = @(
+    '.sh',
+    '.bash',
+    '.zsh',
+    '.ksh',
+    '.fish'
+)
+
+# All extensions to scan (CRLF + LF types)
+$allExtensions = $extensions + $lfExtensions
+
 $rootPath = Resolve-Path -LiteralPath $Root
 Write-VerboseLine "Scanning for EOL/BOM issues under: $rootPath"
 
 $bomFiles = New-Object System.Collections.Generic.List[string]
-$badEolFiles = New-Object System.Collections.Generic.List[string]
+$crlfViolations = New-Object System.Collections.Generic.List[string]
+$lfViolations = New-Object System.Collections.Generic.List[string]
+$indexIssues = Get-GitIndexEolIssues -Extensions $allExtensions
 
 Get-ChildItem -LiteralPath $rootPath -Recurse -File -Force |
     ForEach-Object {
@@ -46,7 +112,7 @@ Get-ChildItem -LiteralPath $rootPath -Recurse -File -Force |
         foreach ($pat in $excludePatterns) { if ($path -match $pat) { return } }
 
         $ext = [System.IO.Path]::GetExtension($path).ToLowerInvariant()
-        if ($extensions -notcontains $ext) { return }
+        if ($allExtensions -notcontains $ext) { return }
 
         try {
             $bytes = [System.IO.File]::ReadAllBytes($path)
@@ -61,18 +127,29 @@ Get-ChildItem -LiteralPath $rootPath -Recurse -File -Force |
             $bomFiles.Add($path)
         }
 
-        # Check for line endings
+        # Check for line endings based on file type
         $text = [System.Text.Encoding]::UTF8.GetString($bytes)
-        $lfOnly = [regex]::Matches($text, '(?<!\r)\n').Count
-        $crOnly = [regex]::Matches($text, '\r(?!\n)').Count
-
-        if ($lfOnly -gt 0 -or $crOnly -gt 0) {
-            $badEolFiles.Add($path)
+        
+        if ($lfExtensions -contains $ext) {
+            # Shell scripts should have LF only (no CRLF or bare CR)
+            $crlfCount = [regex]::Matches($text, '\r\n').Count
+            $crOnly = [regex]::Matches($text, '\r(?!\n)').Count
+            if ($crlfCount -gt 0 -or $crOnly -gt 0) {
+                $lfViolations.Add($path)
+            }
+        }
+        else {
+            # All other text files should have CRLF (no bare LF or bare CR)
+            $lfOnly = [regex]::Matches($text, '(?<!\r)\n').Count
+            $crOnly = [regex]::Matches($text, '\r(?!\n)').Count
+            if ($lfOnly -gt 0 -or $crOnly -gt 0) {
+                $crlfViolations.Add($path)
+            }
         }
     }
 
-if ($bomFiles.Count -eq 0 -and $badEolFiles.Count -eq 0) {
-    Write-Host "EOL check passed: CRLF only and no BOMs detected."
+if ($bomFiles.Count -eq 0 -and $crlfViolations.Count -eq 0 -and $lfViolations.Count -eq 0 -and $indexIssues.Count -eq 0) {
+    Write-Host "EOL check passed: line endings correct and no BOMs detected."
     exit 0
 }
 
@@ -81,9 +158,20 @@ if ($bomFiles.Count -gt 0) {
     $bomFiles | ForEach-Object { Write-Host "  $_" }
 }
 
-if ($badEolFiles.Count -gt 0) {
-    Write-Host "Files contain non-CRLF line endings (found LF or bare CR):"
-    $badEolFiles | ForEach-Object { Write-Host "  $_" }
+if ($lfViolations.Count -gt 0) {
+    Write-Host "Shell scripts require LF line endings but contain CRLF or bare CR:"
+    $lfViolations | ForEach-Object { Write-Host "  $_" }
+}
+
+if ($crlfViolations.Count -gt 0) {
+    Write-Host "Files require CRLF line endings but contain LF or bare CR:"
+    $crlfViolations | ForEach-Object { Write-Host "  $_" }
+}
+
+if ($indexIssues.Count -gt 0) {
+    Write-Host "Git index contains non-normalized line endings (expected LF in repo for text files):"
+    $indexIssues | ForEach-Object { Write-Host "  $_" }
+    Write-Host "Fix: Run 'node scripts/fix-eol.js' then re-stage affected files."
 }
 
 Write-Error "EOL/BOM policy violations detected. See lists above."

package/scripts/fix-eol.js

@@ -7,7 +7,10 @@ const fs = require('fs');
 const path = require('path');
 
 const repoRoot = process.cwd();
-const verbose = process.argv.includes('-v') || process.argv.includes('--verbose');
+const argv = process.argv.slice(2);
+const verbose = argv.includes('-v') || argv.includes('--verbose');
+const flagArgs = new Set(['-v', '--verbose']);
+const targetArgs = argv.filter((arg) => !flagArgs.has(arg));
 
 // Exclude directory patterns (match anywhere in path)
 const excludeRegexes = [
@@ -17,12 +20,16 @@ const excludeRegexes = [
   /(^|[\/\\])(Obj|obj)([\/\\]|$)/,
   /(^|[\/\\])Temp([\/\\]|$)/,
   /(^|[\/\\])Samples~([\/\\]|$)/,
-  /(^|[\/\\])\.vs([\/\\]|$)/
+  /(^|[\/\\])\.vs([\/\\]|$)/,
+  /(^|[\/\\])\.venv([\/\\]|$)/,
+  /(^|[\/\\])\.artifacts([\/\\]|$)/,
+  /(^|[\/\\])site([\/\\]|$)/
 ];
 
-// Text file extensions to fix (must match check-eol.js)
-const exts = new Set([
+// Text file extensions that require CRLF line endings (must match check-eol.js)
+const crlfExts = new Set([
   '.cs', '.csproj', '.sln',
+  '.js', '.cjs', '.mjs',
   '.json', '.jsonc', '.toml',
   '.yaml', '.yml',
   '.md', '.markdown',
@@ -32,6 +39,21 @@ const exts = new Set([
   '.ps1'
 ]);
 
+// Shell scripts require LF line endings for Unix compatibility
+const lfExts = new Set(['.sh', '.bash', '.zsh', '.ksh', '.fish']);
+
+// Git hooks directory - files here need LF regardless of extension
+const hooksDir = path.join('scripts', 'hooks');
+
+// All text file extensions we fix
+const exts = new Set([...crlfExts, ...lfExts]);
+
+// Check if a file is a git hook (no extension, in hooks directory)
+function isGitHook(filePath) {
+  const rel = path.relative(repoRoot, filePath);
+  return rel.startsWith(hooksDir + path.sep) && path.extname(filePath) === '';
+}
+
 function walk(dir, files = []) {
   const entries = fs.readdirSync(dir, { withFileTypes: true });
   for (const ent of entries) {
@@ -63,13 +85,56 @@ function toCrlf(txt) {
   return normalized.replace(/\n/g, '\r\n');
 }
 
-const allFiles = walk(repoRoot);
+function toLf(txt) {
+  // Normalize all newlines to LF (for shell scripts)
+  let normalized = txt.replace(/\r\n/g, '\n');
+  normalized = normalized.replace(/\r/g, '\n');
+  return normalized;
+}
+
+function resolveTargets(targets) {
+  if (targets.length === 0) {
+    return walk(repoRoot);
+  }
+
+  const seen = new Set();
+  const resolvedFiles = [];
+
+  for (const rawTarget of targets) {
+    const targetPath = path.resolve(repoRoot, rawTarget);
+    if (!fs.existsSync(targetPath)) {
+      continue;
+    }
+
+    const stats = fs.statSync(targetPath);
+    if (stats.isDirectory()) {
+      for (const file of walk(targetPath)) {
+        if (!seen.has(file)) {
+          resolvedFiles.push(file);
+          seen.add(file);
+        }
+      }
+    } else if (stats.isFile()) {
+      if (!seen.has(targetPath)) {
+        resolvedFiles.push(targetPath);
+        seen.add(targetPath);
+      }
+    }
+  }
+
+  return resolvedFiles;
+}
+
+const allFiles = resolveTargets(targetArgs);
 let changed = 0;
 let scanned = 0;
 
 for (const file of allFiles) {
   const ext = path.extname(file).toLowerCase();
-  if (!exts.has(ext)) continue;
+  const isHook = isGitHook(file);
+  
+  // Process if it has a known extension OR if it's a git hook
+  if (!exts.has(ext) && !isHook) continue;
   let buf;
   try {
     buf = fs.readFileSync(file);
@@ -81,10 +146,13 @@ for (const file of allFiles) {
   buf = stripBom(buf);
   const origTxt = origBuf.toString('utf8');
   const noBomTxt = buf.toString('utf8');
-  const crlfTxt = toCrlf(noBomTxt);
+  
+  // Shell scripts and git hooks use LF, all other text files use CRLF
+  const needsLf = lfExts.has(ext) || isHook;
+  const fixedTxt = needsLf ? toLf(noBomTxt) : toCrlf(noBomTxt);
 
-  if (crlfTxt !== origTxt) {
-    fs.writeFileSync(file, crlfTxt, { encoding: 'utf8' });
+  if (fixedTxt !== origTxt) {
+    fs.writeFileSync(file, fixedTxt, { encoding: 'utf8' });
     changed++;
     if (verbose) console.log(`Fixed: ${path.relative(repoRoot, file)}`);
   }
@@ -92,6 +160,5 @@ for (const file of allFiles) {
 
 console.log(`Scanned ${scanned} text files. Updated ${changed}.`);
 if (changed > 0) {
-  console.log('All changes written with CRLF and no BOM.');
+  console.log('All changes written with correct line endings (CRLF for most files, LF for shell scripts) and no BOM.');
 }
-