fix: remove unnecessary TreeDataProvider import and fix formatting

- Remove unused TreeDataProvider import from extension.ts
- Fix type annotation to use vscode.TreeDataProvider directly
- Run Prettier to fix all formatting issues (23 files)
- Update TypeScript any types to unknown for better type safety
- Remove unused imports and variables
- All quality checks now pass: type-check, lint, format:check, test

Author: ketupia

docs/README.md

@@ -60,7 +60,8 @@ This folder contains comprehensive documentation for the Ash Studio VS Code Exte
 
 The Ash Studio extension uses a **hybrid parser architecture** with:
 
-- **Configuration-driven parser**: Flexible and maintainable parsing approach through module configuration
+- **Configuration-driven parser**: Flexible and maintainable parsing approach through module
+  configuration
 - **Services**: Centralized logging, configuration, performance monitoring, and error handling
 - **Testing**: Organized unit/integration test structure with 68 comprehensive tests
 

eslint.config.mjs

@@ -9,7 +9,7 @@ export default [
       ".vscode-test/**/*",
       "dist/**/*",
       "node_modules/**/*",
-      "**/*.min.js"
+      "**/*.min.js",
     ],
   },
   {

package.json

@@ -126,8 +126,7 @@
     "test:config": "mocha 'test/unit/parsers/configurationDriven/*.test.js'",
     "test:vscode": "node ./dist/test/runTest.js"
   },
-  "dependencies": {
-  },
+  "dependencies": {},
   "devDependencies": {
     "@types/glob": "^8.1.0",
     "@types/mocha": "^10.0.10",

src/ashParserService.ts

@@ -15,9 +15,7 @@ export class AshParserService {
   private _onDidParse = new vscode.EventEmitter<ParseResult>();
 
   // Parser implementation
-  private parsers: Parser[] = [
-    ConfigurationDrivenParser.getInstance(),
-  ];
+  private parsers: Parser[] = [ConfigurationDrivenParser.getInstance()];
 
   public readonly onDidParse = this._onDidParse.event;
 

src/extension.ts

@@ -48,7 +48,7 @@ export function activate(context: vscode.ExtensionContext) {
     logger.info("Extension", "Using configuration-driven parser only");
 
     // Initialize the parser service with error handling
-    let parserService: AshParserService;
+    let parserService: AshParserService | null = null;
     try {
       console.log("🔧 Attempting to initialize parser service...");
       logger.info("Extension", "Attempting to initialize parser service...");
@@ -72,7 +72,7 @@ export function activate(context: vscode.ExtensionContext) {
         `Ash Studio parser initialization failed: ${parserError instanceof Error ? parserError.message : String(parserError)}`
       );
       // Continue without parser functionality
-      parserService = null as any;
+      parserService = null;
     }
 
     // Initialize sidebar with error handling
@@ -162,11 +162,12 @@ export function activate(context: vscode.ExtensionContext) {
 
         // Fallback minimal sidebar if parser failed
         const fallbackSidebar = {
-          getTreeItem: (element: any) =>
-            new vscode.TreeItem(
+          getTreeItem: () => {
+            return new vscode.TreeItem(
               "Parser Error",
               vscode.TreeItemCollapsibleState.None
-            ),
+            );
+          },
           getChildren: () => {
             console.log("🔄 Fallback sidebar getChildren called");
             return [{ label: "Parser service unavailable" }];
@@ -179,7 +180,7 @@ export function activate(context: vscode.ExtensionContext) {
 
         console.log("🎛️ Creating fallback tree view...");
         const fallbackTreeView = vscode.window.createTreeView("ashSidebar", {
-          treeDataProvider: fallbackSidebar as any,
+          treeDataProvider: fallbackSidebar as vscode.TreeDataProvider<unknown>,
           showCollapseAll: false,
         });
 
@@ -201,7 +202,10 @@ export function activate(context: vscode.ExtensionContext) {
         registerAshQuickPick(context, parserService);
         registerAshSectionNavigation(context, parserService);
         registerAshCodeLensProvider(context, parserService);
-        logger.info("Extension", "Navigation features and code lens provider registered successfully");
+        logger.info(
+          "Extension",
+          "Navigation features and code lens provider registered successfully"
+        );
       }
     } catch (navigationError) {
       logger.error(

src/features/ashCodeLensProvider.ts

@@ -12,25 +12,25 @@ import { ConfigurationManager } from "../utils/config";
 export class AshCodeLensProvider implements vscode.CodeLensProvider {
   // Track disposables for cleanup
   private disposables: vscode.Disposable[] = [];
-  
+
   constructor(private readonly parserService: AshParserService) {
     // Listen for parse events to refresh code lenses when content changes
     this.disposables.push(
       this.parserService.onDidParse(() => {
         this.triggerCodeLensRefresh();
       })
     );
-    
+
     // Also listen for configuration changes that might affect code lens display
     this.disposables.push(
-      vscode.workspace.onDidChangeConfiguration((event) => {
+      vscode.workspace.onDidChangeConfiguration(event => {
         if (event.affectsConfiguration("ashStudio.enableCodeLens")) {
           this.triggerCodeLensRefresh();
         }
       })
     );
   }
-  
+
   /**
    * Provides CodeLens for the given document
    */
@@ -53,58 +53,69 @@ export class AshCodeLensProvider implements vscode.CodeLensProvider {
 
       // Convert our CodeLensEntry objects to VS Code CodeLens objects
       const codeLenses: vscode.CodeLens[] = [];
-      
+
       for (const entry of parseResult.codeLenses) {
         // Create a range for the CodeLens
         const line = Math.max(0, entry.line - 1); // Convert to 0-based line number
         const range = new vscode.Range(
-          new vscode.Position(line, entry.character), 
+          new vscode.Position(line, entry.character),
           new vscode.Position(line, entry.character + 1)
         );
-        
+
         // Create the CodeLens with a command that opens the documentation URL
         const lens = new vscode.CodeLens(range);
-        
+
         // Debug logging
-        Logger.getInstance().debug("AshCodeLensProvider", `Creating code lens: ${entry.title} -> ${entry.target}`);
-        
+        Logger.getInstance().debug(
+          "AshCodeLensProvider",
+          `Creating code lens: ${entry.title} -> ${entry.target}`
+        );
+
         try {
           const uri = vscode.Uri.parse(entry.target);
-          Logger.getInstance().debug("AshCodeLensProvider", `Parsed URI: ${uri.toString()}`);
-          
+          Logger.getInstance().debug(
+            "AshCodeLensProvider",
+            `Parsed URI: ${uri.toString()}`
+          );
+
           // Use our custom command for better control and logging
           lens.command = {
             title: entry.title,
             command: "ash-studio.openDocumentation",
             arguments: [entry.target],
-            tooltip: `View documentation for ${entry.source}`
+            tooltip: `View documentation for ${entry.source}`,
           };
-          
+
           // Alternative: use the built-in vscode.open command if needed
           // lens.command = {
           //   title: entry.title,
           //   command: "vscode.open",
           //   arguments: [uri],
           //   tooltip: `View documentation for ${entry.source}`
           // };
-          
-
         } catch (error) {
-          Logger.getInstance().error("AshCodeLensProvider", `Failed to parse URI: ${entry.target}`, error);
+          Logger.getInstance().error(
+            "AshCodeLensProvider",
+            `Failed to parse URI: ${entry.target}`,
+            error
+          );
           // Fallback: create a command that shows an error message
           lens.command = {
             title: entry.title,
             command: "vscode.window.showErrorMessage",
-            arguments: [`Failed to open documentation: ${entry.target}`]
+            arguments: [`Failed to open documentation: ${entry.target}`],
           };
         }
-        
+
         codeLenses.push(lens);
       }
-      
+
       return codeLenses;
     } catch (error) {
-      Logger.getInstance().error("AshCodeLensProvider", `Error providing code lenses: ${error}`);
+      Logger.getInstance().error(
+        "AshCodeLensProvider",
+        `Error providing code lenses: ${error}`
+      );
       return null;
     }
   }
@@ -121,7 +132,7 @@ export class AshCodeLensProvider implements vscode.CodeLensProvider {
    * Dispose of resources
    */
   dispose(): void {
-    this.disposables.forEach((d) => d.dispose());
+    this.disposables.forEach(d => d.dispose());
     this.disposables = [];
   }
 }
@@ -134,7 +145,7 @@ export function registerAshCodeLensProvider(
   parserService: AshParserService
 ): vscode.Disposable {
   const provider = new AshCodeLensProvider(parserService);
-  
+
   // Register a test command to verify command execution works
   const testCommand = vscode.commands.registerCommand(
     "ash-studio.testCodeLens",
@@ -143,58 +154,82 @@ export function registerAshCodeLensProvider(
       vscode.window.showInformationMessage(`Code lens clicked! URL: ${url}`);
     }
   );
-  
+
   // Add the test command to context subscriptions
   context.subscriptions.push(testCommand);
-  
+
   // Register a custom command for opening documentation URLs
   const openDocsCommand = vscode.commands.registerCommand(
     "ash-studio.openDocumentation",
     async (url: string) => {
-      console.log(`[CodeLens Command] ash-studio.openDocumentation called with URL: ${url}`);
-      Logger.getInstance().info("AshCodeLensProvider", `Command called: opening documentation URL: ${url}`);
-      
+      console.log(
+        `[CodeLens Command] ash-studio.openDocumentation called with URL: ${url}`
+      );
+      Logger.getInstance().info(
+        "AshCodeLensProvider",
+        `Command called: opening documentation URL: ${url}`
+      );
+
       try {
         console.log(`[CodeLens Command] Attempting to open URL: ${url}`);
         const uri = vscode.Uri.parse(url);
         console.log(`[CodeLens Command] Parsed URI:`, uri.toString());
-        
+
         // Try multiple methods to handle different environments (like Windsurf)
         try {
           // Method 1: Use the VS Code built-in API (primary method)
           await vscode.env.openExternal(uri);
-          console.log(`[CodeLens Command] Successfully opened URL with openExternal: ${url}`);
+          console.log(
+            `[CodeLens Command] Successfully opened URL with openExternal: ${url}`
+          );
         } catch (primaryError) {
-          console.warn(`[CodeLens Command] openExternal failed, trying alternative: ${primaryError}`);
-          
+          console.warn(
+            `[CodeLens Command] openExternal failed, trying alternative: ${primaryError}`
+          );
+
           // Method 2: Try to use the built-in open command as fallback
-          await vscode.commands.executeCommand('vscode.open', uri);
-          console.log(`[CodeLens Command] Successfully opened URL with vscode.open command: ${url}`);
+          await vscode.commands.executeCommand("vscode.open", uri);
+          console.log(
+            `[CodeLens Command] Successfully opened URL with vscode.open command: ${url}`
+          );
         }
-        
+
         // Show a user notification that we attempted to open the URL
         // This is useful in Windsurf where the browser might not open visibly
         vscode.window.showInformationMessage(
           `Documentation URL: ${url} (URL should open in your default browser)`
         );
-        
-        Logger.getInstance().info("AshCodeLensProvider", `Successfully processed URL open request: ${url}`);
+
+        Logger.getInstance().info(
+          "AshCodeLensProvider",
+          `Successfully processed URL open request: ${url}`
+        );
       } catch (error) {
         console.error(`[CodeLens Command] Failed to open URL: ${url}`, error);
-        Logger.getInstance().error("AshCodeLensProvider", `Failed to open URL: ${url}`, error);
-        vscode.window.showErrorMessage(`Failed to open documentation: ${url}. Error: ${error instanceof Error ? error.message : String(error)}`);
+        Logger.getInstance().error(
+          "AshCodeLensProvider",
+          `Failed to open URL: ${url}`,
+          error
+        );
+        vscode.window.showErrorMessage(
+          `Failed to open documentation: ${url}. Error: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
     }
   );
-  
+
   // Register the provider for Elixir files
   const providerDisposable = vscode.languages.registerCodeLensProvider(
     { language: "elixir", scheme: "file" },
     provider
   );
-  
+
   context.subscriptions.push(openDocsCommand);
   context.subscriptions.push(providerDisposable);
-  
-  return vscode.Disposable.from(testCommand, openDocsCommand, providerDisposable);
+
+  return vscode.Disposable.from(
+    testCommand,
+    openDocsCommand,
+    providerDisposable
+  );
 }

src/features/ashQuickPick.ts

@@ -1,6 +1,5 @@
 import * as vscode from "vscode";
 import { AshParserService } from "../ashParserService";
-import { ParsedSection } from "../parsers/parser";
 
 export function registerAshQuickPick(
   context: vscode.ExtensionContext,

src/features/ashSectionNavigation.ts

@@ -1,6 +1,5 @@
 import * as vscode from "vscode";
 import { AshParserService } from "../ashParserService";
-import { ParsedSection } from "../parsers/parser";
 
 export function registerAshSectionNavigation(
   context: vscode.ExtensionContext,
@@ -14,7 +13,7 @@ export function registerAshSectionNavigation(
   ];
 
   const provider: vscode.DocumentSymbolProvider = {
-    provideDocumentSymbols(document, token) {
+    provideDocumentSymbols(document) {
       // Use cached result if available, otherwise parse
       let parseResult = parser.getCachedResult(document);
       if (!parseResult) {

src/features/ashSidebarProvider.ts

@@ -69,31 +69,35 @@ export class AshSidebarProvider
       if (!section || !section.details || section.details.length === 0)
         return [];
 
-      return section.details.map(
-        (detail: ParsedDetail) => this.createDetailTreeItem(detail)
+      return section.details.map((detail: ParsedDetail) =>
+        this.createDetailTreeItem(detail)
       );
-    } else if (element.detail && element.detail.childDetails && element.detail.childDetails.length > 0) {
+    } else if (
+      element.detail &&
+      element.detail.childDetails &&
+      element.detail.childDetails.length > 0
+    ) {
       // Level 2+: Show nested details (recursive handling)
-      return element.detail.childDetails.map(
-        (childDetail: ParsedDetail) => this.createDetailTreeItem(childDetail)
+      return element.detail.childDetails.map((childDetail: ParsedDetail) =>
+        this.createDetailTreeItem(childDetail)
       );
     }
 
     return [];
   }
-  
+
   /**
    * Helper method to create a tree item for a detail, handling nested details recursively
    */
   private createDetailTreeItem(detail: ParsedDetail): AshSidebarItem {
     const hasChildren = detail.childDetails && detail.childDetails.length > 0;
-    
+
     // Create a label that shows both block type and name (if available)
     let label = detail.detail; // Default to just the block type
     if (detail.name && detail.name !== detail.detail) {
       label = `${detail.detail} ${detail.name}`; // Show both type and name
     }
-    
+
     return new AshSidebarItem(
       label,
       hasChildren