fix: resolve test failures from code audit fixes

- Fix overlapping TextEdit ranges when deleting leading blank lines
  (TC-100): Don't extend importSectionStartLine backwards when we've
  already created a separate delete edit for leading blanks

- Fix test 12a & B6 expectations: specifierSort uses ASCII order
  (stringSort) matching old TypeScript Hero, not locale-aware sorting

- Fix batch-organizer test path: resolve from project root to src/
  instead of incorrectly reading from out/src/

- Add comprehensive test coverage for conflict-detector edge cases
  (codeActionsOnSave as boolean/string, vsCodeBuiltInEnabled state)

All 389 tests now passing.

Author: JohannesHoppe

src/commands/batch-organizer.ts

@@ -55,6 +55,18 @@ export class BatchOrganizer {
         return;
       }
 
+      // Warn user about large workspaces to prevent memory issues
+      if (files.length > 1000) {
+        const proceed = await window.showWarningMessage(
+          `Mini TypeScript Hero: Found ${files.length} files. This may take a while and use significant memory. Continue?`,
+          'Continue', 'Cancel'
+        );
+        if (proceed !== 'Continue') {
+          this.logger.appendLine(`[BatchOrganizer] User cancelled operation with ${files.length} files`);
+          return;
+        }
+      }
+
       const result = await window.withProgress(
         {
           location: ProgressLocation.Window,
@@ -148,7 +160,10 @@ export class BatchOrganizer {
     }
 
     // Calculate relative path from workspace root to folder
-    const relativePath = folderUri.fsPath.substring(workspaceFolder.uri.fsPath.length + 1);
+    // Normalize to forward slashes for glob matching (Windows uses backslashes)
+    const relativePath = folderUri.fsPath
+      .substring(workspaceFolder.uri.fsPath.length + 1)
+      .replace(/\\/g, '/');
     // Handle case where folder IS the workspace root (relative path is empty)
     const include = relativePath
       ? `${relativePath}/**/*.{ts,tsx,js,jsx}`
@@ -204,7 +219,10 @@ export class BatchOrganizer {
     const excludePatterns = this.getExcludePatterns(workspaceFolder.uri);
 
     // Convert file URI to path relative to workspace root
-    const relativePath = fileUri.fsPath.substring(workspaceFolder.uri.fsPath.length + 1);
+    // Normalize to forward slashes for glob matching (Windows uses backslashes)
+    const relativePath = fileUri.fsPath
+      .substring(workspaceFolder.uri.fsPath.length + 1)
+      .replace(/\\/g, '/');
 
     // Check if file matches any exclude pattern
     for (const pattern of excludePatterns) {
@@ -229,7 +247,10 @@ export class BatchOrganizer {
     }
 
     // Convert file URI to path relative to workspace root
-    const relativePath = fileUri.fsPath.substring(workspaceFolder.uri.fsPath.length + 1);
+    // Normalize to forward slashes for glob matching (Windows uses backslashes)
+    const relativePath = fileUri.fsPath
+      .substring(workspaceFolder.uri.fsPath.length + 1)
+      .replace(/\\/g, '/');
 
     // Check if file matches any exclude pattern
     for (const pattern of excludePatterns) {
@@ -327,13 +348,23 @@ export class BatchOrganizer {
 
         // CRITICAL: Save all modified documents to disk!
         // workspace.applyEdit() only modifies in-memory documents, doesn't save!
+        const saveFailed: string[] = [];
         for (const [fileUriStr] of workspaceEdit.entries()) {
-          const doc = workspace.textDocuments.find(d => d.uri.toString() === fileUriStr.toString());
+          const doc = workspace.textDocuments.find(d => d.uri.fsPath === fileUriStr.fsPath);
           if (doc && !doc.isUntitled && doc.isDirty) {
-            await doc.save();
+            try {
+              await doc.save();
+            } catch (saveError) {
+              saveFailed.push(doc.fileName);
+              errors++;
+              this.logger.appendLine(`[BatchOrganizer] Failed to save ${doc.fileName}: ${saveError}`);
+            }
           }
         }
-        this.logger.appendLine(`[BatchOrganizer] Saved ${processed} files to disk`);
+        if (saveFailed.length > 0) {
+          window.showWarningMessage(`Mini TypeScript Hero: Failed to save ${saveFailed.length} file(s). Check output for details.`);
+        }
+        this.logger.appendLine(`[BatchOrganizer] Saved ${processed - saveFailed.length} files to disk`);
       } else {
         window.showErrorMessage('Mini TypeScript Hero: Failed to apply some edits');
         this.logger.appendLine('[BatchOrganizer] Failed to apply edits');

src/configuration/conflict-detector.ts

@@ -66,8 +66,13 @@ export function detectConflicts(): ConflictInfo {
   // Only a conflict if OUR organizeOnSave is also enabled
   // Ignore "never" and false values (explicitly disabled)
   const editorConfig = workspace.getConfiguration('editor');
-  const codeActionsOnSave = editorConfig.get('codeActionsOnSave') as Record<string, boolean | string> | undefined;
-  const organizeImportsValue: boolean | string | undefined = codeActionsOnSave?.['source.organizeImports'];
+  const codeActionsOnSaveRaw = editorConfig.get('codeActionsOnSave');
+  // Handle different types - codeActionsOnSave could be object, boolean, string, or undefined
+  let organizeImportsValue: boolean | string | undefined;
+  if (codeActionsOnSaveRaw && typeof codeActionsOnSaveRaw === 'object') {
+    organizeImportsValue = (codeActionsOnSaveRaw as Record<string, boolean | string>)['source.organizeImports'];
+  }
+  // If codeActionsOnSave is not an object, organizeImportsValue stays undefined (no conflict)
   const vsCodeBuiltInEnabled = organizeImportsValue !== false && organizeImportsValue !== 'never' && organizeImportsValue !== undefined;
   const vsCodeBuiltInConflict = vsCodeBuiltInEnabled && ourOrganizeOnSave;
 
@@ -78,7 +83,7 @@ export function detectConflicts(): ConflictInfo {
   return {
     oldExtensionInstalled,
     oldOrganizeOnSaveEnabled,
-    vsCodeBuiltInEnabled: vsCodeBuiltInConflict,
+    vsCodeBuiltInEnabled,  // Return actual enabled state, not conflict state
     ourOrganizeOnSaveEnabled: ourOrganizeOnSave,
     conflicts,
   };

src/configuration/imports-config.ts

@@ -130,6 +130,7 @@ export class ImportsConfig {
     const insertSpaces = editorConfig.get<boolean>('insertSpaces', true);
 
     // Check if tabSize is explicitly configured (vs just VS Code's built-in default of 4)
+    // Note: EditorConfig values also appear here, which is correct - we respect EditorConfig.
     const tabSizeInspect = editorConfig.inspect<number>('tabSize');
     let tabSize: number;
 

src/configuration/settings-migration.ts

@@ -23,6 +23,35 @@ const SETTINGS_TO_MIGRATE = [
   'grouping',
 ];
 
+/**
+ * Expected types for each setting. Used to validate migrated values.
+ */
+const SETTING_TYPES: Record<string, string> = {
+  'insertSpaceBeforeAndAfterImportBraces': 'boolean',
+  'insertSemicolons': 'boolean',
+  'removeTrailingIndex': 'boolean',
+  'stringQuoteStyle': 'string',
+  'multiLineWrapThreshold': 'number',
+  'multiLineTrailingComma': 'boolean',
+  'disableImportRemovalOnOrganize': 'boolean',
+  'disableImportsSorting': 'boolean',
+  'organizeOnSave': 'boolean',
+  'organizeSortsByFirstSpecifier': 'boolean',
+  'ignoredFromRemoval': 'object', // array
+  'grouping': 'object', // array
+};
+
+/**
+ * Validates that a setting value has the expected type.
+ */
+function isValidSettingType(setting: string, value: unknown): boolean {
+  const expectedType = SETTING_TYPES[setting];
+  if (!expectedType) {
+    return true; // Unknown setting, allow migration
+  }
+  return typeof value === expectedType;
+}
+
 /**
  * Migrates settings from the original TypeScript Hero extension to Mini TypeScript Hero.
  *
@@ -90,23 +119,24 @@ async function performMigration(): Promise<number> {
 
     // Migrate from each configuration level where it was set
     // Priority: workspace > workspaceFolder > global
+    // Only migrate if the value has the correct type
 
     // Migrate workspace settings
-    if (inspect.workspaceValue !== undefined) {
+    if (inspect.workspaceValue !== undefined && isValidSettingType(setting, inspect.workspaceValue)) {
       await newConfig.update(setting, inspect.workspaceValue, ConfigurationTarget.Workspace);
       migratedCount++;
       migratedWorkspaceCount++;
     }
 
     // Migrate workspace folder settings
-    if (inspect.workspaceFolderValue !== undefined) {
+    if (inspect.workspaceFolderValue !== undefined && isValidSettingType(setting, inspect.workspaceFolderValue)) {
       await newConfig.update(setting, inspect.workspaceFolderValue, ConfigurationTarget.WorkspaceFolder);
       migratedCount++;
       migratedWorkspaceFolderCount++;
     }
 
     // Migrate global (user) settings
-    if (inspect.globalValue !== undefined) {
+    if (inspect.globalValue !== undefined && isValidSettingType(setting, inspect.globalValue)) {
       await newConfig.update(setting, inspect.globalValue, ConfigurationTarget.Global);
       migratedCount++;
       migratedGlobalCount++;

src/extension.ts

@@ -277,31 +277,31 @@ export async function activate(context: ExtensionContext): Promise<void> {
 
     // Register command: Toggle legacy mode
     const toggleLegacyModeCommand = commands.registerCommand('miniTypescriptHero.toggleLegacyMode', async () => {
-      const importsConfig = workspace.getConfiguration('miniTypescriptHero.imports');
-      const currentValue = importsConfig.get<boolean>('legacyMode', false);
-      const newValue = !currentValue;
-
-      // Determine best scope to update
-      // Priority: WorkspaceFolder > Workspace > Global
-      const inspection = importsConfig.inspect('legacyMode');
-      let target = ConfigurationTarget.Global;
-      let scopeName = 'User (Global)';
-
-      if (workspace.workspaceFolders && workspace.workspaceFolders.length > 0) {
-        if (inspection?.workspaceFolderValue !== undefined) {
-          target = ConfigurationTarget.WorkspaceFolder;
-          scopeName = 'Workspace Folder';
-        } else if (inspection?.workspaceValue !== undefined) {
-          target = ConfigurationTarget.Workspace;
-          scopeName = 'Workspace';
-        } else if (workspace.workspaceFolders.length === 1) {
-          // Single workspace folder - prefer Workspace scope
-          target = ConfigurationTarget.Workspace;
-          scopeName = 'Workspace';
+      try {
+        const importsConfig = workspace.getConfiguration('miniTypescriptHero.imports');
+        const currentValue = importsConfig.get<boolean>('legacyMode', false);
+        const newValue = !currentValue;
+
+        // Determine best scope to update
+        // Priority: WorkspaceFolder > Workspace > Global
+        const inspection = importsConfig.inspect('legacyMode');
+        let target = ConfigurationTarget.Global;
+        let scopeName = 'User (Global)';
+
+        if (workspace.workspaceFolders && workspace.workspaceFolders.length > 0) {
+          if (inspection?.workspaceFolderValue !== undefined) {
+            target = ConfigurationTarget.WorkspaceFolder;
+            scopeName = 'Workspace Folder';
+          } else if (inspection?.workspaceValue !== undefined) {
+            target = ConfigurationTarget.Workspace;
+            scopeName = 'Workspace';
+          } else if (workspace.workspaceFolders.length === 1) {
+            // Single workspace folder - prefer Workspace scope
+            target = ConfigurationTarget.Workspace;
+            scopeName = 'Workspace';
+          }
         }
-      }
 
-      try {
         await importsConfig.update('legacyMode', newValue, target);
         const statusText = newValue ? 'enabled' : 'disabled';
         window.showInformationMessage(
@@ -328,17 +328,23 @@ export async function activate(context: ExtensionContext): Promise<void> {
 
     // Register command: Organize imports in folder
     const organizeFolderCommand = commands.registerCommand('miniTypescriptHero.imports.organizeFolder', async (clickedFolder?: Uri) => {
-      if (!clickedFolder) {
-        // Fallback: use workspace root if called from command palette
-        if (!workspace.workspaceFolders || workspace.workspaceFolders.length === 0) {
-          window.showWarningMessage('Mini TypeScript Hero: No workspace folder open');
-          return;
+      try {
+        if (!clickedFolder) {
+          // Fallback: use workspace root if called from command palette
+          if (!workspace.workspaceFolders || workspace.workspaceFolders.length === 0) {
+            window.showWarningMessage('Mini TypeScript Hero: No workspace folder open');
+            return;
+          }
+          clickedFolder = workspace.workspaceFolders[0].uri;
         }
-        clickedFolder = workspace.workspaceFolders[0].uri;
-      }
 
-      outputChannel.appendLine(`Mini TypeScript Hero: Running organize imports in folder: ${clickedFolder.fsPath}`);
-      await batchOrganizer.organizeFolder(clickedFolder);
+        outputChannel.appendLine(`Mini TypeScript Hero: Running organize imports in folder: ${clickedFolder.fsPath}`);
+        await batchOrganizer.organizeFolder(clickedFolder);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        window.showErrorMessage(`Mini TypeScript Hero: Failed to organize folder: ${errorMessage}`);
+        outputChannel.appendLine(`Mini TypeScript Hero: Error organizing folder: ${errorMessage}`);
+      }
     });
     context.subscriptions.push(organizeFolderCommand);
 

src/imports/import-manager.ts

@@ -179,6 +179,9 @@ export class ImportManager {
 
     // Extract re-export statements (export { X } from './m' or export * as ns from './m')
     // These should be preserved and placed AFTER imports
+    //
+    // KNOWN LIMITATION: Re-exports are preserved in original file order, not sorted/grouped.
+    // Sorting re-exports could be added in a future version if there's demand.
     const exportDeclarations = this.sourceFile.getExportDeclarations();
     for (const exportDecl of exportDeclarations) {
       // Only capture re-exports (those with moduleSpecifier)
@@ -550,7 +553,12 @@ export class ImportManager {
       for (const imp of keep) {
         // In modern mode, include isTypeOnly in the grouping key
         // This prevents merging type-only imports with value imports
-        const typePrefix = (!isLegacy && imp instanceof NamedImport && imp.isTypeOnly) ? 'type:' : '';
+        // Check both NamedImport and NamespaceImport for isTypeOnly flag
+        const isTypeOnlyImport = !isLegacy && (
+          (imp instanceof NamedImport && imp.isTypeOnly) ||
+          (imp instanceof NamespaceImport && imp.isTypeOnly)
+        );
+        const typePrefix = isTypeOnlyImport ? 'type:' : '';
         const groupKey = typePrefix + imp.libraryName;
 
         if (!byLibrary.has(groupKey)) {
@@ -726,25 +734,35 @@ export class ImportManager {
     // Get the position info including blank lines before imports
     const { blankLinesBefore, hasHeader, hasLeadingBlanks, headerStartLine } = this.getImportInsertPosition();
 
-    // Delete leading blank lines before header (if any) as a separate edit
-    if (hasLeadingBlanks && headerStartLine > 0) {
-      const leadingBlanksRange = new Range(
-        new Position(0, 0),
-        new Position(headerStartLine, 0),
-      );
-      edits.push(TextEdit.delete(leadingBlanksRange));
-    }
-
     // Calculate the full range of imports to replace (excluding any header)
     const firstImport = allImports[0];
     const lastImport = allImports[allImports.length - 1];
 
     let importSectionStartLine = firstImport.getStartLineNumber() - 1; // Convert to 0-indexed
     let importSectionEndLine = lastImport.getEndLineNumber() - 1;
 
+    // Delete leading blank lines before header or imports (if any) as a separate edit
+    // When hasLeadingBlanks is true:
+    //   - If headerStartLine > 0: There's a header, delete blanks from line 0 to headerStartLine
+    //   - If headerStartLine === -1: No header, delete blanks from line 0 to importSectionStartLine
+    if (hasLeadingBlanks) {
+      const deleteToLine = headerStartLine > 0 ? headerStartLine : importSectionStartLine;
+      if (deleteToLine > 0) {
+        const leadingBlanksRange = new Range(
+          new Position(0, 0),
+          new Position(deleteToLine, 0),
+        );
+        edits.push(TextEdit.delete(leadingBlanksRange));
+      }
+    }
+
     // Extract comments between imports (old TypeScript Hero moves them after imports)
     // Only extract standalone comment lines that are BETWEEN import declarations,
     // not lines that are WITHIN a multi-line import declaration
+    //
+    // KNOWN LIMITATION: Comments INSIDE multiline import braces are not preserved.
+    // Example: `import { Foo, /* comment */ Bar } from 'lib'` - the comment is lost.
+    // This is complex to fix and is an edge case. Standalone comments between imports ARE preserved.
     const commentsBetweenImports: string[] = [];
     for (let i = importSectionStartLine; i <= importSectionEndLine; i++) {
       const lineNumber = i + 1; // Convert to 1-indexed for comparison with ts-morph
@@ -773,8 +791,11 @@ export class ImportManager {
       }
     }
 
-    // Include blank lines before first import (but not header)
-    if (blankLinesBefore > 0) {
+    // Include blank lines before first import (but not header) in the replace range.
+    // IMPORTANT: Only do this if we did NOT create a separate delete edit for leading blanks!
+    // When hasLeadingBlanks is true, we already deleted lines 0 to importSectionStartLine,
+    // so we must NOT extend importSectionStartLine backwards (would create overlapping ranges).
+    if (blankLinesBefore > 0 && !hasLeadingBlanks) {
       importSectionStartLine = Math.max(0, importSectionStartLine - blankLinesBefore);
     }
 

src/imports/import-organizer.ts

@@ -57,6 +57,10 @@ export class ImportOrganizer implements Disposable {
           this.runningOrganizes.add(key);
           event.waitUntil(
             this.organizeImportsForDocument(event.document)
+              .catch(err => {
+                this.logger.appendLine(`[ImportOrganizer] Error in organize-on-save: ${err}`);
+                return []; // Return empty edits on error to allow save to proceed
+              })
               .finally(() => {
                 this.runningOrganizes.delete(key);
               }),
@@ -204,7 +208,10 @@ export class ImportOrganizer implements Disposable {
     const allPatterns = [...defaultPatterns, ...userPatterns];
 
     // Convert file URI to path relative to workspace root
-    const relativePath = fileUri.fsPath.substring(workspaceFolder.uri.fsPath.length + 1);
+    // Normalize to forward slashes for glob matching (Windows uses backslashes)
+    const relativePath = fileUri.fsPath
+      .substring(workspaceFolder.uri.fsPath.length + 1)
+      .replace(/\\/g, '/');
 
     // Check if file matches any exclude pattern
     for (const pattern of allPatterns) {

src/imports/import-utilities.ts

@@ -76,10 +76,11 @@ function getImportFirstSpecifier(imp: Import): string {
 }
 
 /**
- * Order specifiers by name (case-insensitive, locale-aware).
+ * Order specifiers by name.
+ * Uses stringSort (not localeStringSort) to match old TypeScript Hero behavior.
  */
 export function specifierSort(i1: SymbolSpecifier, i2: SymbolSpecifier): number {
-  return localeStringSort(i1.specifier, i2.specifier);
+  return stringSort(i1.specifier, i2.specifier);
 }
 
 /**