feat(config): Auswahl des Magento‑Root, relative Pfade & Standard auf Workspace‑Root ✨

- Neuer Command "Magento Log Viewer: Select Root Folder" (package.json + helpers) 🔎
- Speichere magentoRoot als relativen Pfad und implementiere getEffectiveMagentoRoot() mit Workspace‑Root als Fallback 🗂️
- Erzwinge TreeView‑Refresh nach Provider‑Initialisierung, damit "Loading log files..." verschwindet 🔁
- CHANGELOG aktualisiert und Unit‑Tests für getEffectiveMagentoRoot hinzugefügt 🧪

Author: dermatz

.github/copilot-instructions.md

@@ -0,0 +1,117 @@
+# Copilot Instructions for Magento Log Viewer Extension
+
+## Architecture Overview
+
+This is a VS Code extension that provides intelligent viewing and management of Magento log files. The extension follows a modular architecture with clear separation of concerns:
+
+- **`src/extension.ts`** - Entry point with asynchronous initialization pattern to avoid blocking VS Code startup
+- **`src/logViewer.ts`** - Core TreeDataProvider implementations (`LogViewerProvider`, `ReportViewerProvider`)
+- **`src/helpers.ts`** - Utility functions, caching system, file operations, and command handlers
+- **`src/updateNotifier.ts`** - Version update notifications and changelog integration
+
+## Key Architectural Patterns
+
+### Workspace-Scoped Configuration
+The extension uses workspace-scoped settings via `vscode.workspace.getConfiguration('magentoLogViewer', workspaceUri)`. All configuration is stored per-workspace, allowing different Magento projects to have independent settings.
+
+### Asynchronous Initialization
+```typescript
+// Pattern: Delay heavy operations to let VS Code indexing settle
+await new Promise(resolve => setTimeout(resolve, 500));
+```
+
+### Intelligent File Caching System
+The extension implements a sophisticated caching mechanism in `helpers.ts`:
+- **Line count caching** - Avoids re-reading files for badge counts
+- **File content caching** - Smart memory management with size limits
+- **Cache invalidation** - File system watchers automatically invalidate stale cache entries
+- Use `getCacheStatistics()`, `clearFileContentCache()`, `invalidateFileCache()` for cache management
+
+### Context-Driven UI
+Commands are conditionally shown using VS Code's `when` clauses:
+- `magentoLogViewer.hasMagentoRoot` - Controls visibility of most features
+- `magentoLogViewer.hasActiveSearch` - Shows/hides search clear button
+- `magentoLogViewer.hasLogFiles` - Controls log file operations
+
+## Critical Development Workflows
+
+### Build & Development
+```bash
+npm run compile      # Webpack build for development
+npm run watch        # Watch mode during development
+npm run package      # Production build for publishing
+npm run test         # Run extension tests
+```
+
+### Testing Strategy
+Tests are located in `src/test/` with focused test files:
+- `extension.test.ts` - Basic extension lifecycle
+- `caching.test.ts` - Cache system validation
+- `search.test.ts` - Search functionality
+- Run tests with `npm run test` or F5 debug launch
+
+### Extension Configuration Flow
+1. Extension activates on `onStartupFinished`
+2. Checks `isMagentoProject` setting ("Please select" → prompt user)
+3. Validates `magentoRoot` path → auto-opens folder picker if invalid
+4. Creates providers and activates file system watchers on `var/log` and `var/report`
+
+## Project-Specific Conventions
+
+### File System Patterns
+- **Log files**: `{magentoRoot}/var/log/*.log`
+- **Report files**: `{magentoRoot}/var/report/` (recursive directory scanning)
+- **Icons**: Color-coded by log level (ERROR=red, WARN=orange, DEBUG=yellow, INFO=blue)
+
+### TreeItem Structure
+```typescript
+// Pattern: LogItem extends vscode.TreeItem with command integration
+new LogItem(label, collapsibleState, {
+  command: 'magento-log-viewer.openFile',
+  arguments: [filePath, lineNumber]
+})
+```
+
+### Search Implementation
+- Real-time filtering via `quickPick.onDidChangeValue`
+- Supports regex patterns when `searchUseRegex` is enabled
+- Case sensitivity controlled by `searchCaseSensitive` setting
+- Search state managed through context variables for UI updates
+
+### Error Handling Pattern
+```typescript
+// Pattern: User-friendly error messages with actionable buttons
+vscode.window.showErrorMessage('Error message', 'Action Button').then(selection => {
+  if (selection === 'Action Button') {
+    // Provide immediate solution
+  }
+});
+```
+
+### Memory Management
+- Dispose pattern: All providers implement `dispose()` with cleanup of disposables array
+- Cache optimization: `optimizeCacheSize()` runs automatically to prevent memory leaks
+- File watchers: Properly disposed in `deactivate()` function
+
+## Integration Points
+
+### VS Code APIs Used
+- **TreeDataProvider**: Custom tree views for log/report files
+- **FileSystemWatcher**: Real-time file change detection
+- **QuickPick**: Search interface and file selection
+- **Workspace Configuration**: Per-workspace settings
+- **Status Bar**: Badge counts and search indicators
+
+### External Dependencies
+- **Webpack**: Bundles TypeScript to single `dist/extension.js`
+- **Node.js fs**: Synchronous and async file operations
+- **VS Code Test Framework**: `@vscode/test-cli` for extension testing
+
+## Performance Considerations
+
+- **Lazy loading**: Heavy operations delayed until user interaction
+- **Throttled badge updates**: Maximum one badge update per second
+- **Smart caching**: File content cached with automatic memory limits
+- **Async file operations**: Uses `fs.promises` for non-blocking I/O where possible
+
+When modifying this extension, prioritize user experience with immediate feedback, maintain the caching system integrity, and ensure proper disposal of resources to prevent memory leaks.

CHANGELOG.md

@@ -5,8 +5,9 @@ All notable changes to the "magento-log-viewer" extension will be documented in
 
 ## Next release
 
-- ux: Automatic folder picker dialog when Magento root path is not set or invalid
-- ux: Improved error handling with direct path selection option
+- config: Default Magento root is now the workspace root if unset; paths are stored relative to workspace
+- ux: Added "Select Root Folder" command for easy Magento root configuration and automatic folder picker when path is missing or invalid
+- fix: Log and report files now load automatically without manual refresh; improved error handling with direct path selection
 
 ---
 

package.json

@@ -91,6 +91,11 @@
         "command": "magento-log-viewer.showCacheStatistics",
         "title": "Show Cache Statistics",
         "icon": "$(info)"
+      },
+      {
+        "command": "magento-log-viewer.selectMagentoRootFromSettings",
+        "title": "Magento Log Viewer: Select Root Folder",
+        "category": "Magento Log Viewer"
       }
     ],
     "configuration": {
@@ -111,7 +116,7 @@
         "magentoLogViewer.magentoRoot": {
           "type": "string",
           "default": "",
-          "description": "Path to the Magento root folder",
+          "markdownDescription": "Path to the Magento root folder. Use Command Palette: `Magento Log Viewer: Select Root Folder` to browse and select a folder.",
           "scope": "resource"
         },
         "magentoLogViewer.groupByMessage": {

src/extension.ts

@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import { promptMagentoProjectSelection, showErrorMessage, activateExtension, isValidPath, deleteReportFile, clearFileContentCache, selectMagentoRootFolder, selectMagentoRootFolderDirect } from './helpers';
+import { promptMagentoProjectSelection, showErrorMessage, activateExtension, isValidPath, deleteReportFile, clearFileContentCache, selectMagentoRootFolder, selectMagentoRootFolderDirect, getEffectiveMagentoRoot, selectMagentoRootFromSettings } from './helpers';
 import { LogItem, ReportViewerProvider } from './logViewer';
 import { showUpdateNotification } from './updateNotifier';
 
@@ -10,6 +10,13 @@ export function activate(context: vscode.ExtensionContext): void {
   // Show Update-Popup first (lightweight operation)
   showUpdateNotification(context);
 
+  // Register the settings button command
+  const selectMagentoRootCommand = vscode.commands.registerCommand('magento-log-viewer.selectMagentoRootFromSettings', () => {
+    selectMagentoRootFromSettings();
+  });
+  disposables.push(selectMagentoRootCommand);
+  context.subscriptions.push(selectMagentoRootCommand);
+
   // Initialize extension in a more intelligent way
   const initializeExtension = async () => {
     try {
@@ -29,7 +36,7 @@ export function activate(context: vscode.ExtensionContext): void {
       if (isMagentoProject === 'Please select') {
         promptMagentoProjectSelection(config, context);
       } else if (isMagentoProject === 'Yes') {
-        const magentoRoot = config.get<string>('magentoRoot', '');
+        const magentoRoot = getEffectiveMagentoRoot(workspaceUri);
         if (!magentoRoot || !isValidPath(magentoRoot)) {
           // Show error message and automatically open folder picker
           vscode.window.showErrorMessage(

src/helpers.ts

@@ -25,8 +25,10 @@ export function selectMagentoRootFolder(config: vscode.WorkspaceConfiguration, c
       const defaultUri = workspaceFolders && workspaceFolders.length > 0 ? workspaceFolders[0].uri : undefined;
       vscode.window.showOpenDialog({ defaultUri, canSelectFolders: true, canSelectMany: false, openLabel: 'Select Magento Root Folder' }).then(folderUri => {
         if (folderUri?.[0]) {
-          const newConfig = vscode.workspace.getConfiguration('magentoLogViewer', folderUri[0]);
-          updateConfig(newConfig, 'magentoRoot', folderUri[0].fsPath).then(() => {
+          const workspaceUri = vscode.workspace.workspaceFolders?.[0]?.uri || null;
+          const newConfig = vscode.workspace.getConfiguration('magentoLogViewer', workspaceUri);
+          const relativePath = vscode.workspace.asRelativePath(folderUri[0].fsPath);
+          updateConfig(newConfig, 'magentoRoot', relativePath).then(() => {
             showInformationMessage('Magento root folder successfully saved!');
             updateConfig(newConfig, 'isMagentoProject', 'Yes');
             activateExtension(context, folderUri[0].fsPath, new ReportViewerProvider(folderUri[0].fsPath));
@@ -49,8 +51,10 @@ export function selectMagentoRootFolderDirect(config: vscode.WorkspaceConfigurat
     title: 'Select Magento Root Folder'
   }).then(folderUri => {
     if (folderUri?.[0]) {
-      const newConfig = vscode.workspace.getConfiguration('magentoLogViewer', folderUri[0]);
-      updateConfig(newConfig, 'magentoRoot', folderUri[0].fsPath).then(() => {
+      const workspaceUri = vscode.workspace.workspaceFolders?.[0]?.uri || null;
+      const newConfig = vscode.workspace.getConfiguration('magentoLogViewer', workspaceUri);
+      const relativePath = vscode.workspace.asRelativePath(folderUri[0].fsPath);
+      updateConfig(newConfig, 'magentoRoot', relativePath).then(() => {
         showInformationMessage('Magento root folder successfully saved!');
         updateConfig(newConfig, 'isMagentoProject', 'Yes');
         activateExtension(context, folderUri[0].fsPath, new ReportViewerProvider(folderUri[0].fsPath));
@@ -59,6 +63,66 @@ export function selectMagentoRootFolderDirect(config: vscode.WorkspaceConfigurat
   });
 }
 
+// Opens folder selection dialog from Command Palette and updates the magentoRoot configuration.
+export async function selectMagentoRootFromSettings(): Promise<void> {
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  const workspaceUri = workspaceFolders?.[0]?.uri || null;
+
+  // Get current configuration for display
+  const config = vscode.workspace.getConfiguration('magentoLogViewer', workspaceUri);
+  const currentPath = config.get<string>('magentoRoot', '');
+  const currentPathDisplay = currentPath || 'Not set (using workspace root)';
+
+  // Show info about current setting
+  const proceed = await vscode.window.showInformationMessage(
+    `Current Magento root: ${currentPathDisplay}\n\nDo you want to select a new Magento root folder?`,
+    'Select New Folder',
+    'Cancel'
+  );
+
+  if (proceed === 'Select New Folder') {
+    const defaultUri = workspaceFolders && workspaceFolders.length > 0 ? workspaceFolders[0].uri : undefined;
+
+    const folderUri = await vscode.window.showOpenDialog({
+      defaultUri,
+      canSelectFolders: true,
+      canSelectMany: false,
+      openLabel: 'Select Magento Root Folder',
+      title: 'Select Magento Root Folder'
+    });
+
+    if (folderUri?.[0]) {
+      try {
+        // Store the relative path instead of absolute path
+        const relativePath = vscode.workspace.asRelativePath(folderUri[0].fsPath);
+        await updateConfig(config, 'magentoRoot', relativePath);
+
+        // Also set the project as Magento project if not already set
+        const isMagentoProject = config.get<string>('isMagentoProject', 'Please select');
+        if (isMagentoProject !== 'Yes') {
+          await updateConfig(config, 'isMagentoProject', 'Yes');
+        }
+
+        // Show success message with the new path
+        showInformationMessage(`✅ Magento root updated to: ${relativePath}`);
+
+        // Suggest reloading the window for changes to take effect
+        const reload = await vscode.window.showInformationMessage(
+          'Reload the window for all changes to take effect.',
+          'Reload Window',
+          'Later'
+        );
+
+        if (reload === 'Reload Window') {
+          vscode.commands.executeCommand('workbench.action.reloadWindow');
+        }
+      } catch (error) {
+        showErrorMessage(`Failed to update Magento root path: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+}
+
 // Updates the specified configuration key with the given value.
 export function updateConfig(config: vscode.WorkspaceConfiguration, key: string, value: unknown): Thenable<void> {
   return config.update(key, value, vscode.ConfigurationTarget.Workspace);
@@ -368,6 +432,42 @@ export function pathExists(p: string): boolean {
   return true;
 }
 
+/**
+ * Gets the effective Magento root path. If the configured path is empty,
+ * returns the workspace root as the default.
+ * @param workspaceUri The workspace URI to get configuration from
+ * @returns string - The effective Magento root path
+ */
+export function getEffectiveMagentoRoot(workspaceUri?: vscode.Uri | null): string {
+  const config = vscode.workspace.getConfiguration('magentoLogViewer', workspaceUri);
+  const configuredRoot = config.get<string>('magentoRoot', '');
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+
+  // If configured root is not empty, resolve it
+  if (configuredRoot && configuredRoot.trim()) {
+    // If it's already an absolute path, use it as is
+    if (path.isAbsolute(configuredRoot)) {
+      return configuredRoot;
+    }
+
+    // If it's a relative path, resolve it against the workspace root
+    if (workspaceFolders && workspaceFolders.length > 0) {
+      return path.resolve(workspaceFolders[0].uri.fsPath, configuredRoot);
+    }
+
+    // Fallback: return the configured path as is
+    return configuredRoot;
+  }
+
+  // Otherwise, use workspace root as default
+  if (workspaceFolders && workspaceFolders.length > 0) {
+    return workspaceFolders[0].uri.fsPath;
+  }
+
+  // Fallback: return empty string if no workspace
+  return '';
+}
+
 // Cache for file line counts
 const lineCountCache = new Map<string, { count: number, timestamp: number }>();
 

src/logViewer.ts

@@ -39,9 +39,15 @@ export class LogViewerProvider implements vscode.TreeDataProvider<LogItem>, vsco
       await new Promise(resolve => setTimeout(resolve, 300));
       this.updateBadge();
       this.isInitialized = true;
+
+      // Trigger refresh to show the actual log files instead of "Loading log files..."
+      this._onDidChangeTreeData.fire();
     } catch (error) {
       console.error('Error during LogViewerProvider initialization:', error);
       this.isInitialized = true; // Set to true anyway to prevent blocking
+
+      // Still trigger refresh even on error to show the UI
+      this._onDidChangeTreeData.fire();
     }
   }
 
@@ -532,9 +538,15 @@ export class ReportViewerProvider implements vscode.TreeDataProvider<LogItem>, v
       // Wait a bit for VS Code indexing to settle
       await new Promise(resolve => setTimeout(resolve, 300));
       this.isInitialized = true;
+
+      // Trigger refresh to show the actual report files instead of "Loading report files..."
+      this._onDidChangeTreeData.fire();
     } catch (error) {
       console.error('Error during ReportViewerProvider initialization:', error);
       this.isInitialized = true; // Set to true anyway to prevent blocking
+
+      // Still trigger refresh even on error to show the UI
+      this._onDidChangeTreeData.fire();
     }
   }