fix: preserve re-exports when all imports removed, scope findFiles to workspace folder

- Re-exports adjacent to imports are now preserved when all imports are
  removed as unused (else branch in generateTextEdits now outputs re-exports)
- findTargetFilesInFolder uses RelativePattern to scope search to the
  correct workspace folder in multi-root workspaces
- README: fix default grouping (was missing "Plains")
- CLAUDE.md: fix test file listing and blankLinesAfterImports description

Author: JohannesHoppe

CLAUDE.md

@@ -170,11 +170,19 @@ mini-typescript-hero/                     ← Project root
 │
 ├── tests/                                ← All test-related folders
 │   ├── unit/                             ← Main extension tests (run with npm test)
-│   │   ├── import-manager.test.ts        ← Core import manager tests
-│   │   ├── import-manager.*.test.ts      ← Additional import manager tests
+│   │   ├── import-manager.test.ts        ← Core import manager tests (~100 tests)
+│   │   ├── import-manager.*.test.ts      ← Additional: blank-lines, edge-cases, indentation, etc.
 │   │   ├── import-grouping.test.ts       ← Grouping logic tests
-│   │   ├── settings-migration.test.ts    ← Migration tests
-│   │   └── test-helpers.ts               ← Shared test utilities
+│   │   ├── import-organizer.test.ts      ← Orchestrator/command tests
+│   │   ├── import-utilities.test.ts      ← Sorting utility tests
+│   │   ├── configuration/                ← Config-related tests
+│   │   │   ├── settings-migration.test.ts  ← Migration tests
+│   │   │   └── conflict-detector.test.ts   ← Conflict detection tests
+│   │   ├── commands/
+│   │   │   └── batch-organizer.integration.test.ts  ← Batch operation tests
+│   │   ├── test-helpers.ts               ← Shared test utilities
+│   │   ├── test-types.ts                 ← Test type definitions
+│   │   └── *.test.ts                     ← Additional: manifest, perf, vscode defaults, etc.
 │   ├── comparison/                       ← Old vs new comparison tests
 │   │   ├── old-extension/adapter.ts      ← Adapter for old TypeScript Hero
 │   │   ├── new-extension/adapter.ts      ← Adapter for new Mini TypeScript Hero
@@ -388,7 +396,7 @@ All settings are under `miniTypescriptHero.imports.*`:
 16. `excludePatterns` (string[]) - Glob patterns for files to exclude from import organization
 
 ### Blank Lines
-17. `blankLinesAfterImports` (one/two/preserve) - How many blank lines after imports (Note: Partially overridden in legacyMode for files with headers or leading blanks; otherwise respected)
+17. `blankLinesAfterImports` (one/two/preserve) - How many blank lines after imports (Note: This setting has no effect when legacyMode is true — legacy mode always uses 'preserve' behavior with special handling for headers and leading blanks)
 
 ### Behavior & Compatibility
 18. `organizeOnSave` (boolean) - Automatically organize imports when saving files

README.md

@@ -115,7 +115,7 @@ VS Code has a built-in "Organize Imports" that removes unused imports and sorts
 
 ### Example: Automatic vs Manual Grouping
 
-**Mini TypeScript Hero** with default grouping (`["Modules", "Workspace"]`):
+**Mini TypeScript Hero** with default grouping (`["Plains", "Modules", "Workspace"]`):
 
 ```typescript
 import { Component, OnInit } from '@angular/core';

src/commands/batch-organizer.ts

@@ -3,6 +3,7 @@ import {
   OutputChannel,
   Progress,
   ProgressLocation,
+  RelativePattern,
   TextEdit,
   Uri,
   window,
@@ -165,15 +166,17 @@ export class BatchOrganizer {
       .substring(workspaceFolder.uri.fsPath.length + 1)
       .replace(/\\/g, '/');
     // Handle case where folder IS the workspace root (relative path is empty)
-    const include = relativePath
+    const includeGlob = relativePath
       ? `${relativePath}/**/*.{ts,tsx,js,jsx}`
       : '**/*.{ts,tsx,js,jsx}';
-    const excludePatterns = this.getExcludePatterns(folderUri);
+    const excludePatterns = this.getExcludePatterns(workspaceFolder.uri);
 
-    this.logger.appendLine(`[BatchOrganizer] Searching folder: ${include}`);
+    this.logger.appendLine(`[BatchOrganizer] Searching folder: ${includeGlob}`);
     this.logger.appendLine(`[BatchOrganizer] Excluding: ${excludePatterns.join(', ')}`);
 
-    // Find all files (VS Code respects files.exclude by default)
+    // Use RelativePattern to scope findFiles to the specific workspace folder
+    // (plain string patterns search across ALL workspace roots in multi-root workspaces)
+    const include = new RelativePattern(workspaceFolder, includeGlob);
     const allFiles = await workspace.findFiles(include, null);
 
     // Manually filter files using exclude patterns

src/imports/import-manager.ts

@@ -931,8 +931,27 @@ export class ImportManager {
         this.document.lineAt(importSectionEndLine).rangeIncludingLineBreak.end,
       );
       edits.push(TextEdit.replace(replaceRange, importText));
+    } else if (this.reExports.length > 0 || commentsBetweenImports.length > 0) {
+      // No imports, but re-exports and/or comments need to be preserved
+      let replacementText = '';
+      if (commentsBetweenImports.length > 0) {
+        replacementText += commentsBetweenImports.join(this.eol);
+        replacementText += this.eol;
+      }
+      if (this.reExports.length > 0) {
+        replacementText += this.reExports.join(this.eol);
+        replacementText += this.eol;
+      }
+      if (finalBlankLinesAfter > 0) {
+        replacementText += this.eol.repeat(finalBlankLinesAfter);
+      }
+      const replaceRange = new Range(
+        this.document.lineAt(importSectionStartLine).range.start,
+        this.document.lineAt(importSectionEndLine).rangeIncludingLineBreak.end,
+      );
+      edits.push(TextEdit.replace(replaceRange, replacementText));
     } else {
-      // No imports to insert, just delete the old import section
+      // Truly nothing to keep — delete the old import section
       const deleteRange = new Range(
         this.document.lineAt(importSectionStartLine).range.start,
         this.document.lineAt(importSectionEndLine).rangeIncludingLineBreak.end,

tests/unit/import-manager.test.ts

@@ -3280,7 +3280,34 @@ export { Helper } from './helpers';
     }
   });
 
-  test('101. ignoredFromRemoval libraries have sorted specifiers', async () => {
+  test('101. Adjacent re-exports preserved when all imports are removed as unused', async () => {
+    // Bug: When all imports are unused but adjacent re-exports exist,
+    // the else branch in generateTextEdits() deletes the entire range
+    // without preserving re-exports.
+    const content = `import { A } from './a';
+export { X } from './x';
+
+const y = 1;
+`;
+
+    const expected = `export { X } from './x';
+
+const y = 1;
+`;
+
+    const doc = await createTempDocument(content);
+    try {
+      const manager = new ImportManager(doc, config);
+      const edits = await manager.organizeImports();
+      const result = await applyEditsToDocument(doc, edits);
+
+      assert.strictEqual(result, expected, 'Adjacent re-exports must be preserved when all imports are removed');
+    } finally {
+      await deleteTempDocument(doc);
+    }
+  });
+
+  test('102. ignoredFromRemoval libraries have sorted specifiers', async () => {
     // Verify that libraries in ignoredFromRemoval list still get their specifiers sorted
     // This ensures consistent formatting even when imports are protected from removal