Rename: Skip warning for equivalent file extensions

- Adds `EQUIVALENT_EXTENSION_GROUPS` in `filename-validation.ts` so that switching between aliases of the same format no longer triggers the extension-change confirmation. Groups: jpg/jpeg/jpe/jfif, tif/tiff, htm/html, yml/yaml, mpg/mpeg, mid/midi, aif/aiff, qt/mov, md/markdown/txt.
- Renames `extensionsDifferIgnoringCase` -> `extensionsDifferMeaningfully` since the function now also ignores known aliases, not just letter case. Updates the two call sites and the relevant `CLAUDE.md` docs.
- Adds unit tests covering each group, case+alias combos, no-extension edges, dotfiles, multi-dot names, and cross-group changes that should still warn. Also adjusts three pre-existing tests that used `.txt` <-> `.md` as their "real change" example, since that pair is now intentionally equivalent.

Author: vdavid

apps/desktop/src/lib/file-explorer/rename/CLAUDE.md

@@ -29,10 +29,11 @@ Operates on cursor item only; selection is preserved and irrelevant.
 
 Implemented in `rename-operations.ts::executeRenameSave()`:
 
-1. **Extension check**: If `extensionPolicy === 'ask'` and the extensions differ in more than letter case
-   (`extensionsDifferIgnoringCase()` from `filename-validation.ts`), return `{ type: 'extension-ask' }`. Caller shows
+1. **Extension check**: If `extensionPolicy === 'ask'` and the extensions differ meaningfully
+   (`extensionsDifferMeaningfully()` from `filename-validation.ts`), return `{ type: 'extension-ask' }`. Caller shows
    ExtensionChangeDialog. If user clicks "Keep", retry with `skipExtensionCheck=true`. Case-only changes like
-   `photo.JPG` → `photo.jpg` skip the dialog entirely.
+   `photo.JPG` → `photo.jpg` and known-equivalent changes like `.jpeg` → `.jpg` or `.md` → `.txt` skip the dialog
+   entirely.
 
 2. **Backend validity check**: Call `checkRenameValidity(parentPath, originalName, trimmedName)`. Returns:
    - `{ valid: false, error }` → return `{ type: 'error' }`
@@ -117,7 +118,8 @@ trimmed value.
   discard rename. File watcher events during editing don't cancel (backend will catch issues on save).
 - **Extension validation gotcha**: If setting is "no", changing extension shows red border during editing. If setting is
   "ask", no red border (waits for save to show dialog). If setting is "yes", never validates extension. Case-only
-  extension changes (e.g. `.JPG` → `.jpg`) are treated as no change in all modes.
+  extension changes (e.g. `.JPG` → `.jpg`) and known-equivalent changes (e.g. `.jpeg` → `.jpg`, `.md` → `.txt`) are
+  treated as no change in all modes.
 - **Same-name edge case**: If `trimmedName === originalName`, treat as cancel (no-op). Don't emit file watcher event or
   refresh pane. Avoids spurious refresh on whitespace-only edits.
 - **Click-to-rename interference**: Double-click on name area must open file/folder (normal behavior), not activate

apps/desktop/src/lib/file-explorer/rename/rename-operations.ts

@@ -4,7 +4,7 @@
  * except for the actual backend calls which are awaited.
  */
 
-import { extensionsDifferIgnoringCase, getExtension } from '$lib/utils/filename-validation'
+import { extensionsDifferMeaningfully, getExtension } from '$lib/utils/filename-validation'
 
 export interface ConflictFileInfo {
   name: string
@@ -49,11 +49,11 @@ export async function executeRenameSave(
     return { type: 'noop' }
   }
 
-  // Check extension change (case-only changes are silently allowed)
+  // Check extension change (case-only and known-equivalent changes are silently allowed)
   if (
     !skipExtensionCheck &&
     extensionPolicy === 'ask' &&
-    extensionsDifferIgnoringCase(target.originalName, trimmedName)
+    extensionsDifferMeaningfully(target.originalName, trimmedName)
   ) {
     return {
       type: 'extension-ask',

apps/desktop/src/lib/utils/CLAUDE.md

@@ -62,9 +62,11 @@ interface ValidationResult {
   (e.g. `.gitignore` → `''`). Implemented as `lastIndexOf('.') <= 0`.
 - Extension change behavior is controlled by the `allowExtensionChanges` user setting (`yes`/`no`/`ask`). `'ask'`
   returns `ok` at validation time — the save dialog handles it separately.
-- `extensionsDifferIgnoringCase(oldName, newName)` is the shared helper that decides whether an extension change is
-  meaningful. Case-only changes (e.g. `.JPG` → `.jpg`) are treated as no change so users aren't pestered to confirm a
-  metadata tweak. Used by both `validateExtensionChange` and the rename save flow's "ask" gate.
+- `extensionsDifferMeaningfully(oldName, newName)` is the shared helper that decides whether an extension change is
+  worth a confirmation. It returns false for case-only changes (e.g. `.JPG` → `.jpg`) and for changes between known
+  equivalents (e.g. `.jpeg` → `.jpg`, `.md` → `.txt`), so users aren't pestered to confirm a metadata tweak. The
+  equivalence groups live in `EQUIVALENT_EXTENSION_GROUPS` in the same file — extend that constant to add more aliases.
+  Used by both `validateExtensionChange` and the rename save flow's "ask" gate.
 
 ## confirm-dialog.ts
 

apps/desktop/src/lib/utils/filename-validation.test.ts

@@ -9,6 +9,7 @@ import {
   validateConflict,
   validateFilename,
   getExtension,
+  extensionsDifferMeaningfully,
 } from './filename-validation'
 
 describe('validateDisallowedChars', () => {
@@ -180,13 +181,99 @@ describe('getExtension', () => {
   })
 })
 
+describe('extensionsDifferMeaningfully', () => {
+  it('detects a real extension change', () => {
+    expect(extensionsDifferMeaningfully('file.txt', 'file.json')).toBe(true)
+  })
+
+  it('ignores case-only changes', () => {
+    expect(extensionsDifferMeaningfully('photo.JPG', 'photo.jpg')).toBe(false)
+    expect(extensionsDifferMeaningfully('archive.TAR.GZ', 'archive.TAR.gz')).toBe(false)
+  })
+
+  it('ignores no-op changes', () => {
+    expect(extensionsDifferMeaningfully('file.txt', 'renamed.txt')).toBe(false)
+  })
+
+  it('ignores changes within the JPEG group', () => {
+    expect(extensionsDifferMeaningfully('photo.jpeg', 'photo.jpg')).toBe(false)
+    expect(extensionsDifferMeaningfully('photo.jpg', 'photo.jpe')).toBe(false)
+    expect(extensionsDifferMeaningfully('photo.jfif', 'photo.JPEG')).toBe(false)
+  })
+
+  it('ignores changes within the TIFF group', () => {
+    expect(extensionsDifferMeaningfully('scan.tif', 'scan.tiff')).toBe(false)
+  })
+
+  it('ignores changes within the HTML group', () => {
+    expect(extensionsDifferMeaningfully('page.htm', 'page.html')).toBe(false)
+  })
+
+  it('ignores changes within the YAML group', () => {
+    expect(extensionsDifferMeaningfully('config.yml', 'config.yaml')).toBe(false)
+  })
+
+  it('ignores changes within the MPEG group', () => {
+    expect(extensionsDifferMeaningfully('clip.mpg', 'clip.mpeg')).toBe(false)
+  })
+
+  it('ignores changes within the MIDI group', () => {
+    expect(extensionsDifferMeaningfully('song.mid', 'song.midi')).toBe(false)
+  })
+
+  it('ignores changes within the AIFF group', () => {
+    expect(extensionsDifferMeaningfully('sound.aif', 'sound.aiff')).toBe(false)
+  })
+
+  it('ignores changes within the QuickTime group', () => {
+    expect(extensionsDifferMeaningfully('movie.qt', 'movie.mov')).toBe(false)
+  })
+
+  it('ignores changes within the markdown/text group', () => {
+    expect(extensionsDifferMeaningfully('notes.md', 'notes.txt')).toBe(false)
+    expect(extensionsDifferMeaningfully('notes.markdown', 'notes.md')).toBe(false)
+    expect(extensionsDifferMeaningfully('notes.TXT', 'notes.Markdown')).toBe(false)
+  })
+
+  it('flags changes that cross groups', () => {
+    expect(extensionsDifferMeaningfully('photo.jpg', 'photo.tif')).toBe(true)
+    expect(extensionsDifferMeaningfully('notes.md', 'notes.html')).toBe(true)
+  })
+
+  it('flags adding an extension to a name that had none', () => {
+    expect(extensionsDifferMeaningfully('Makefile', 'Makefile.txt')).toBe(true)
+  })
+
+  it('flags removing an extension', () => {
+    expect(extensionsDifferMeaningfully('readme.txt', 'readme')).toBe(true)
+  })
+
+  it('treats a no-extension to no-extension rename as no change', () => {
+    expect(extensionsDifferMeaningfully('Makefile', 'Dockerfile')).toBe(false)
+  })
+
+  it('trims the new name before comparing', () => {
+    expect(extensionsDifferMeaningfully('photo.jpg', '  photo.jpeg  ')).toBe(false)
+  })
+
+  it('treats a dotfile without extension as no extension', () => {
+    // getExtension('.gitignore') === '', so renaming to .gitkeep is also no extension
+    expect(extensionsDifferMeaningfully('.gitignore', '.gitkeep')).toBe(false)
+  })
+
+  it('uses only the last extension on multi-dot names', () => {
+    expect(extensionsDifferMeaningfully('archive.tar.gz', 'archive.tar.bz2')).toBe(true)
+    expect(extensionsDifferMeaningfully('photo.backup.jpeg', 'photo.backup.jpg')).toBe(false)
+  })
+})
+
 describe('validateExtensionChange', () => {
   it('allows when setting is yes', () => {
-    expect(validateExtensionChange('file.txt', 'file.md', 'yes').severity).toBe('ok')
+    expect(validateExtensionChange('file.txt', 'file.json', 'yes').severity).toBe('ok')
   })
 
   it('errors when setting is no and ext changed', () => {
-    const result = validateExtensionChange('file.txt', 'file.md', 'no')
+    const result = validateExtensionChange('file.txt', 'file.json', 'no')
     expect(result.severity).toBe('error')
   })
 
@@ -195,15 +282,20 @@ describe('validateExtensionChange', () => {
   })
 
   it('allows when setting is ask (dialog handles it)', () => {
-    expect(validateExtensionChange('file.txt', 'file.md', 'ask').severity).toBe('ok')
+    expect(validateExtensionChange('file.txt', 'file.json', 'ask').severity).toBe('ok')
   })
 
   it('allows case-only extension change when setting is no', () => {
     expect(validateExtensionChange('photo.JPG', 'photo.jpg', 'no').severity).toBe('ok')
   })
 
   it('still errors on real extension change when setting is no', () => {
-    expect(validateExtensionChange('file.txt', 'file.md', 'no').severity).toBe('error')
+    expect(validateExtensionChange('file.txt', 'file.json', 'no').severity).toBe('error')
+  })
+
+  it('allows equivalent-extension changes when setting is no', () => {
+    expect(validateExtensionChange('photo.jpeg', 'photo.jpg', 'no').severity).toBe('ok')
+    expect(validateExtensionChange('notes.md', 'notes.txt', 'no').severity).toBe('ok')
   })
 })
 
@@ -260,7 +352,7 @@ describe('validateFilename', () => {
   })
 
   it('validates extension change with no setting', () => {
-    const result = validateFilename('file.md', 'file.txt', parentPath, siblings, 'no')
+    const result = validateFilename('file.json', 'file.txt', parentPath, siblings, 'no')
     expect(result.severity).toBe('error')
   })
 })

apps/desktop/src/lib/utils/filename-validation.ts

@@ -77,12 +77,46 @@ export function getExtension(filename: string): string {
 }
 
 /**
- * True if the extensions differ in more than just letter case.
- * Case-only extension changes (e.g. `photo.JPG` → `photo.jpg`) are treated as no change,
- * so users aren't pestered to confirm something that's effectively a metadata tweak.
+ * Extensions treated as equivalent — switching between any two in a group skips the rename warning.
+ * Each group lists spellings of the same underlying format, lowercase, no leading dot.
+ *
+ * The `md`/`markdown`/`txt` group is included by deliberate choice: Markdown is plain text and
+ * the routing tradeoff (different "Open with" defaults) is accepted as a feature, not a bug.
  */
-export function extensionsDifferIgnoringCase(oldName: string, newName: string): boolean {
-  return getExtension(oldName).toLowerCase() !== getExtension(newName.trim()).toLowerCase()
+const EQUIVALENT_EXTENSION_GROUPS: readonly (readonly string[])[] = [
+  ['jpg', 'jpeg', 'jpe', 'jfif'],
+  ['tif', 'tiff'],
+  ['htm', 'html'],
+  ['yml', 'yaml'],
+  ['mpg', 'mpeg'],
+  ['mid', 'midi'],
+  ['aif', 'aiff'],
+  ['qt', 'mov'],
+  ['md', 'markdown', 'txt'],
+]
+
+/** Precomputed `ext -> groupIndex` map for O(1) equivalence lookup. */
+const EXTENSION_TO_GROUP: ReadonlyMap<string, number> = new Map(
+  EQUIVALENT_EXTENSION_GROUPS.flatMap((group, i) => group.map((ext) => [ext, i] as const)),
+)
+
+function normalizedExt(filename: string): string {
+  const ext = getExtension(filename).toLowerCase()
+  return ext.startsWith('.') ? ext.slice(1) : ext
+}
+
+/**
+ * True if the extension change is meaningful enough to warrant a confirmation.
+ * Returns false for case-only changes (`photo.JPG` → `photo.jpg`) and for changes
+ * between known equivalents (`photo.jpeg` → `photo.jpg`, `notes.md` → `notes.txt`),
+ * so users aren't pestered to confirm what's effectively a metadata tweak.
+ */
+export function extensionsDifferMeaningfully(oldName: string, newName: string): boolean {
+  const oldExt = normalizedExt(oldName)
+  const newExt = normalizedExt(newName.trim())
+  if (oldExt === newExt) return false
+  const oldGroup = EXTENSION_TO_GROUP.get(oldExt)
+  return oldGroup === undefined || oldGroup !== EXTENSION_TO_GROUP.get(newExt)
 }
 
 /** Validates extension change against the user's preference. */
@@ -93,7 +127,7 @@ export function validateExtensionChange(
 ): ValidationResult {
   if (allowExtensionChanges === 'yes') return OK_RESULT
 
-  if (!extensionsDifferIgnoringCase(oldName, newName)) return OK_RESULT
+  if (!extensionsDifferMeaningfully(oldName, newName)) return OK_RESULT
 
   if (allowExtensionChanges === 'no') {
     const oldExt = getExtension(oldName)