fix: address 10 bugs from second comprehensive audit

Production bugs fixed:
- B1: Re-exports (export { Foo } from './bar') no longer falsely prevent
  removal of unrelated local imports with the same name
- B2: Regex import group now parses /pattern/flags syntax correctly
- B3: Settings migration now iterates workspace folders to migrate
  folder-level settings in multi-root workspaces
- B4: Conflict detector checks all scopes including workspace folders
- B5: "Disable for Me" now finds and updates only the scope where
  source.organizeImports is actually set, avoiding merged value clobbering
- B6: Invalid order values (e.g., "DESC") are normalized to valid enum
- B7: hasWarnedKey only set after successful auto-fix, not when skipped
- B8: Unused namespace stripped from import Default, * as ns (converts
  to default-only import when only default is used)
- B9: Re-entrancy guard added to manual organize command
- B10: Remove double disposal of outputChannel in deactivate()

Also fixes wrong specifier order in blog post and README examples
(Component, OnInit, inject → Component, inject, OnInit).

Author: JohannesHoppe

README.md

@@ -45,7 +45,7 @@ import { BookList } from './components/book-list';
 **After** pressing `Ctrl+Alt+O` (or `Cmd+Alt+O` on macOS):
 
 ```typescript
-import { Component, OnInit, inject } from '@angular/core';
+import { Component, inject, OnInit } from '@angular/core';
 import { Router } from '@angular/router';
 import { map, switchMap } from 'rxjs/operators';
 

blog-post.md

@@ -28,7 +28,7 @@ import { BookList } from './components/book-list';
 **After** pressing `Ctrl+Alt+O` (or `Cmd+Alt+O` on macOS):
 
 ```typescript
-import { Component, OnInit, inject } from '@angular/core';
+import { Component, inject, OnInit } from '@angular/core';
 import { Router } from '@angular/router';
 import { map, switchMap } from 'rxjs/operators';
 

src/configuration/conflict-detector.ts

@@ -38,9 +38,9 @@ export interface ConflictInfo {
 export function detectConflicts(): ConflictInfo {
   const conflicts: string[] = [];
 
-  // Read our own organizeOnSave setting to determine if on-save conflicts are real
-  const ourConfig = workspace.getConfiguration('miniTypescriptHero.imports');
-  const ourOrganizeOnSave = ourConfig.get<boolean>('organizeOnSave', false);
+  // Read our own organizeOnSave setting to determine if on-save conflicts are real.
+  // Check all scopes including workspace folders (unscoped read misses folder-level settings).
+  const ourOrganizeOnSave = isBooleanSettingEnabled('miniTypescriptHero.imports', 'organizeOnSave');
 
   // Check 1: Old TypeScript Hero extension installed
   const oldExtension = extensions.getExtension(OLD_EXTENSION_ID);
@@ -52,8 +52,7 @@ export function detectConflicts(): ConflictInfo {
 
   // Check 2: Old TypeScript Hero organize-on-save enabled
   // Only a conflict if OUR organizeOnSave is also enabled
-  const oldTsHeroConfig = workspace.getConfiguration('typescriptHero.imports');
-  const oldOrganizeOnSave = oldTsHeroConfig.get<boolean>('organizeOnSave', false);
+  const oldOrganizeOnSave = isBooleanSettingEnabled('typescriptHero.imports', 'organizeOnSave');
   const oldOrganizeOnSaveEnabled = oldOrganizeOnSave && ourOrganizeOnSave;
 
   if (oldOrganizeOnSaveEnabled) {
@@ -64,16 +63,7 @@ export function detectConflicts(): ConflictInfo {
 
   // Check 3: VS Code built-in organize imports enabled
   // Only a conflict if OUR organizeOnSave is also enabled
-  // Ignore "never" and false values (explicitly disabled)
-  const editorConfig = workspace.getConfiguration('editor');
-  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 vsCodeBuiltInEnabled = isOrganizeImportsCodeActionEnabled();
   const vsCodeBuiltInConflict = vsCodeBuiltInEnabled && ourOrganizeOnSave;
 
   if (vsCodeBuiltInConflict) {
@@ -88,3 +78,49 @@ export function detectConflicts(): ConflictInfo {
     conflicts,
   };
 }
+
+/**
+ * Check if a boolean setting is enabled in any scope (global, workspace, or any workspace folder).
+ * Unscoped getConfiguration().get() misses workspace-folder-level values in multi-root workspaces.
+ */
+function isBooleanSettingEnabled(section: string, key: string): boolean {
+  const config = workspace.getConfiguration(section);
+  const inspect = config.inspect<boolean>(key);
+  if (inspect?.globalValue || inspect?.workspaceValue) {
+    return true;
+  }
+  for (const folder of workspace.workspaceFolders ?? []) {
+    const fi = workspace.getConfiguration(section, folder.uri).inspect<boolean>(key);
+    if (fi?.workspaceFolderValue) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if editor.codeActionsOnSave has source.organizeImports enabled in any scope.
+ */
+function isOrganizeImportsCodeActionEnabled(): boolean {
+  const config = workspace.getConfiguration('editor');
+  const inspect = config.inspect('codeActionsOnSave');
+
+  const checkValue = (value: unknown): boolean => {
+    if (value && typeof value === 'object') {
+      const oi = (value as Record<string, boolean | string>)['source.organizeImports'];
+      return oi !== false && oi !== 'never' && oi !== undefined;
+    }
+    return false;
+  };
+
+  if (checkValue(inspect?.globalValue) || checkValue(inspect?.workspaceValue)) {
+    return true;
+  }
+  for (const folder of workspace.workspaceFolders ?? []) {
+    const fi = workspace.getConfiguration('editor', folder.uri).inspect('codeActionsOnSave');
+    if (checkValue(fi?.workspaceFolderValue)) {
+      return true;
+    }
+  }
+  return false;
+}

src/configuration/settings-migration.ts

@@ -109,32 +109,21 @@ async function performMigration(): Promise<number> {
   let migratedWorkspaceCount = 0;
   let migratedWorkspaceFolderCount = 0;
 
+  // Step 1: Migrate global and workspace-level settings
   for (const setting of SETTINGS_TO_MIGRATE) {
-    // Check if old setting exists (has been configured by user)
     const inspect = oldConfig.inspect(setting);
 
     if (!inspect) {
       continue;
     }
 
-    // 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 && isValidSettingType(setting, inspect.workspaceValue)) {
       await newConfig.update(setting, inspect.workspaceValue, ConfigurationTarget.Workspace);
       migratedCount++;
       migratedWorkspaceCount++;
     }
 
-    // Migrate workspace folder settings
-    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 && isValidSettingType(setting, inspect.globalValue)) {
       await newConfig.update(setting, inspect.globalValue, ConfigurationTarget.Global);
@@ -143,6 +132,27 @@ async function performMigration(): Promise<number> {
     }
   }
 
+  // Step 2: Migrate workspace-folder-level settings
+  // getConfiguration() without a URI cannot see workspaceFolderValue in multi-root,
+  // so we iterate over each workspace folder explicitly.
+  for (const folder of workspace.workspaceFolders ?? []) {
+    const oldFolderConfig = workspace.getConfiguration(OLD_SECTION, folder.uri);
+    const newFolderConfig = workspace.getConfiguration(NEW_SECTION, folder.uri);
+
+    for (const setting of SETTINGS_TO_MIGRATE) {
+      const inspect = oldFolderConfig.inspect(setting);
+      if (!inspect || inspect.workspaceFolderValue === undefined) {
+        continue;
+      }
+
+      if (isValidSettingType(setting, inspect.workspaceFolderValue)) {
+        await newFolderConfig.update(setting, inspect.workspaceFolderValue, ConfigurationTarget.WorkspaceFolder);
+        migratedCount++;
+        migratedWorkspaceFolderCount++;
+      }
+    }
+  }
+
   // For migrated users: Enable legacyMode for formatting backward compatibility
   // Write legacyMode to the SAME scope(s) where old settings were found
   if (migratedCount > 0) {

src/extension.ts

@@ -124,38 +124,50 @@ async function checkForConflicts(
         // Automatically disable VSCode's built-in organize imports
         try {
           const editorConfig = workspace.getConfiguration('editor');
-          const currentActions = editorConfig.get('codeActionsOnSave') as Record<string, boolean | string> | undefined;
-
-          if (currentActions) {
-            // Create new object with source.organizeImports set to false
-            const newActions = { ...currentActions };
-            newActions['source.organizeImports'] = false;
-
-            // Determine which scope to update (most specific scope wins)
-            const inspection = editorConfig.inspect('codeActionsOnSave');
-            let target = ConfigurationTarget.Global;
-
-            if (inspection?.workspaceFolderValue) {
-              target = ConfigurationTarget.WorkspaceFolder;
-            } else if (inspection?.workspaceValue) {
-              target = ConfigurationTarget.Workspace;
+          const inspection = editorConfig.inspect('codeActionsOnSave');
+          let updated = false;
+
+          // Check each scope individually and update only where source.organizeImports is set.
+          // This avoids clobbering other scopes by writing the merged effective value.
+          type ScopeValue = Record<string, boolean | string> | undefined;
+          const scopes: Array<{ value: ScopeValue; target: ConfigurationTarget }> = [
+            { value: inspection?.globalValue as ScopeValue, target: ConfigurationTarget.Global },
+            { value: inspection?.workspaceValue as ScopeValue, target: ConfigurationTarget.Workspace },
+          ];
+
+          // Also check workspace folders (unscoped inspect misses folder-level values)
+          for (const folder of workspace.workspaceFolders ?? []) {
+            const fi = workspace.getConfiguration('editor', folder.uri).inspect('codeActionsOnSave');
+            if (fi?.workspaceFolderValue && typeof fi.workspaceFolderValue === 'object') {
+              scopes.push({ value: fi.workspaceFolderValue as ScopeValue, target: ConfigurationTarget.WorkspaceFolder });
             }
+          }
 
-            await editorConfig.update('codeActionsOnSave', newActions, target);
+          for (const scope of scopes) {
+            if (scope.value && typeof scope.value === 'object' &&
+                'source.organizeImports' in scope.value &&
+                scope.value['source.organizeImports'] !== false &&
+                scope.value['source.organizeImports'] !== 'never') {
+              const newActions = { ...scope.value, 'source.organizeImports': false };
+              await editorConfig.update('codeActionsOnSave', newActions, scope.target);
+              updated = true;
+            }
+          }
 
+          if (updated) {
             window.showInformationMessage(
               'Mini TypeScript Hero: VSCode built-in organize imports has been disabled. ' +
               'You can re-enable it anytime in Settings.'
             );
             outputChannel.appendLine('Mini TypeScript Hero: Successfully disabled VSCode built-in organize imports');
+            // Mark as warned only after successful fix
+            await context.globalState.update(hasWarnedKey, true);
           }
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
           window.showErrorMessage(`Mini TypeScript Hero: Failed to disable VSCode built-in: ${errorMessage}`);
           outputChannel.appendLine(`Mini TypeScript Hero: Error disabling VSCode built-in: ${errorMessage}`);
         }
-        // Mark as warned - conflict resolved
-        await context.globalState.update(hasWarnedKey, true);
       } else if (selection === 'Open Extensions') {
         // Open Extensions sidebar so user can disable old TypeScript Hero manually
         // NOTE: Using 'workbench.view.extensions' instead of 'workbench.extensions.action.showInstalledExtensions'
@@ -367,8 +379,5 @@ export async function activate(context: ExtensionContext): Promise<void> {
  * Deactivate the extension.
  */
 export function deactivate(): void {
-  if (outputChannel) {
-    outputChannel.appendLine('Mini TypeScript Hero: Deactivating extension');
-    outputChannel.dispose();
-  }
+  // outputChannel is disposed automatically via context.subscriptions
 }

src/imports/import-grouping/import-group-setting-parser.ts

@@ -50,7 +50,9 @@ export class ImportGroupSettingParser {
       identifier = setting;
     } else {
       identifier = setting.identifier;
-      order = setting.order;
+      // Normalize order to valid enum value (case-insensitive)
+      const rawOrder = String(setting.order || '').toLowerCase();
+      order = rawOrder === ImportGroupOrder.Desc ? ImportGroupOrder.Desc : ImportGroupOrder.Asc;
     }
 
     if (REGEX_REGEX_GROUP.test(identifier)) {

src/imports/import-grouping/regex-import-group.ts

@@ -34,15 +34,13 @@ export class RegexImportGroup implements ImportGroup {
     public readonly order: ImportGroupOrder = ImportGroupOrder.Asc,
   ) {
     // Compile regex once in constructor for performance
-    // Strip surrounding slashes if present (e.g., '/^@angular/' -> '^@angular')
-    let regexString = this.regex;
-    regexString = regexString.startsWith('/')
-      ? regexString.substring(1)
-      : regexString;
-    regexString = regexString.endsWith('/')
-      ? regexString.substring(0, regexString.length - 1)
-      : regexString;
-    this.compiledRegex = new RegExp(regexString);
+    // Parse /pattern/flags syntax (e.g., '/^@angular/i' -> pattern='^@angular', flags='i')
+    const slashMatch = this.regex.match(/^\/(.+)\/([gimsuy]*)$/);
+    if (slashMatch) {
+      this.compiledRegex = new RegExp(slashMatch[1], slashMatch[2]);
+    } else {
+      this.compiledRegex = new RegExp(this.regex);
+    }
   }
 
   public reset(): void {

src/imports/import-manager.ts

@@ -257,9 +257,15 @@ export class ImportManager {
       }
     });
 
-    // Step 2: Handle re-exported symbols (export { Foo } or export default Foo)
-    // These must be kept even if not used in the file itself
+    // Step 2: Handle locally re-exported symbols (export { Foo } or export default Foo)
+    // These must be kept even if not used in the file itself.
+    // Only mark names from LOCAL exports (no moduleSpecifier). Re-exports like
+    // `export { Foo } from './bar'` reference symbols from the other module,
+    // not local identifiers — they must not prevent removal of unrelated local imports.
     this.sourceFile.getExportDeclarations().forEach(exportDecl => {
+      if (exportDecl.getModuleSpecifier()) {
+        return;
+      }
       const namedExports = exportDecl.getNamedExports();
       namedExports.forEach(named => {
         this.usedIdentifiers.add(named.getName());
@@ -292,6 +298,14 @@ export class ImportManager {
         continue;
       }
 
+      // Skip if this identifier is part of a re-export (export { ... } from '...')
+      // Re-exports reference symbols from the other module, not local identifiers.
+      // Local exports (export { Foo }) are handled by Step 2.
+      const ancestorExportDecl = identifier.getFirstAncestorByKind(SyntaxKind.ExportDeclaration);
+      if (ancestorExportDecl?.getModuleSpecifier()) {
+        continue;
+      }
+
       // Skip if this identifier IS the name being declared (not usages in the declaration)
       const parent = identifier.getParent();
       if (Node.isClassDeclaration(parent) && identifier === parent.getNameNode()) {
@@ -498,11 +512,16 @@ export class ImportManager {
           const nsUsed = this.usedIdentifiers.has(imp.alias);
           const defaultUsed = !!imp.defaultAlias && this.usedIdentifiers.has(imp.defaultAlias);
           if (nsUsed || defaultUsed) {
-            // Strip unused default if only namespace is used
             if (imp.defaultAlias && !defaultUsed) {
+              // Strip unused default, keep namespace
               keep.push(new NamespaceImport(
                 imp.libraryName, imp.alias, undefined, imp.isTypeOnly, imp.attributes,
               ));
+            } else if (!nsUsed && defaultUsed) {
+              // Strip unused namespace, convert to default-only import
+              keep.push(new NamedImport(
+                imp.libraryName, [], imp.defaultAlias, imp.isTypeOnly, imp.attributes,
+              ));
             } else {
               keep.push(imp);
             }

src/imports/import-organizer.ts

@@ -89,6 +89,12 @@ export class ImportOrganizer implements Disposable {
       return;
     }
 
+    // Re-entrancy guard (same as organize-on-save)
+    const key = editor.document.uri.toString();
+    if (this.runningOrganizes.has(key)) {
+      return;
+    }
+
     if (!this.isSupportedLanguage(editor.document.languageId)) {
       window.showWarningMessage(
         `Mini TypeScript Hero: Organize imports is not supported for ${editor.document.languageId} files`,
@@ -105,6 +111,7 @@ export class ImportOrganizer implements Disposable {
       return;
     }
 
+    this.runningOrganizes.add(key);
     try {
       this.logger.appendLine(`[ImportOrganizer] Organizing imports for ${editor.document.fileName}`);
 
@@ -141,6 +148,8 @@ export class ImportOrganizer implements Disposable {
       if (error instanceof Error && error.stack) {
         this.logger.appendLine(error.stack);
       }
+    } finally {
+      this.runningOrganizes.delete(key);
     }
   }