hledger-lsp 0.1.2 → 0.1.6

package/out/server.js

@@ -1,5 +1,38 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_1 = require("vscode-languageserver/node");
 const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
@@ -11,6 +44,7 @@ const codeActions_1 = require("./features/codeActions");
 const formatter_1 = require("./features/formatter");
 const semanticTokens_1 = require("./features/semanticTokens");
 const inlayHints_1 = require("./features/inlayHints");
+const codeLens_1 = require("./features/codeLens");
 const findReferences_1 = require("./features/findReferences");
 const validator_1 = require("./features/validator");
 const foldingRanges_1 = require("./features/foldingRanges");
@@ -19,30 +53,61 @@ const selectionRange_1 = require("./features/selectionRange");
 const index_1 = require("./parser/index");
 const settings_1 = require("./server/settings");
 const uri_1 = require("./utils/uri");
+const workspace_1 = require("./server/workspace");
+const path = __importStar(require("path"));
+// Check for version flag
+if (process.argv.includes('--version') || process.argv.includes('-v')) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const packageJson = require('../package.json');
+        console.log(`hledger-lsp v${packageJson.version}`);
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('Failed to read version information');
+        process.exit(1);
+    }
+}
 // Create a connection for the server using Node's IPC as a transport
 const connection = (0, node_1.createConnection)(node_1.ProposedFeatures.all);
+connection.console.log('========== HLEDGER LSP SERVER STARTING ==========');
 // Create a simple text document manager
 const documents = new node_1.TextDocuments(vscode_languageserver_textdocument_1.TextDocument);
 let hasConfigurationCapability = false;
-let hasWorkspaceFolderCapability = false;
-let hasDiagnosticRelatedInformationCapability = false;
 let hasDidChangeConfigurationDynamicRegistration = false;
-let hasWorkspaceFoldersDynamicRegistration = false;
+let hasInlayHintRefreshSupport = false;
+let hasCodeLensRefreshSupport = false;
+// Workspace state
+let workspaceFolders = [];
+let workspaceManager = null;
 connection.onInitialize((params) => {
+    connection.console.log('========== ON INITIALIZE CALLED ==========');
+    connection.console.log(`rootUri: ${params.rootUri}`);
+    connection.console.log(`rootPath: ${params.rootPath}`);
+    connection.console.log(`workspaceFolders: ${JSON.stringify(params.workspaceFolders)}`);
     const capabilities = params.capabilities;
     // Does the client support the `workspace/configuration` request?
     hasConfigurationCapability = !!(capabilities.workspace && !!capabilities.workspace.configuration);
-    hasWorkspaceFolderCapability = !!(capabilities.workspace && !!capabilities.workspace.workspaceFolders);
-    hasDiagnosticRelatedInformationCapability = !!(capabilities.textDocument &&
-        capabilities.textDocument.publishDiagnostics &&
-        capabilities.textDocument.publishDiagnostics.relatedInformation);
     // Check if client supports dynamic registration for didChangeConfiguration
     hasDidChangeConfigurationDynamicRegistration = !!(capabilities.workspace &&
         capabilities.workspace.didChangeConfiguration &&
         capabilities.workspace.didChangeConfiguration.dynamicRegistration);
-    // Check if client supports dynamic registration for workspace folders
-    // (Not currently used, kept for future reference)
-    hasWorkspaceFoldersDynamicRegistration = false;
+    // Check if client supports inlay hint refresh
+    hasInlayHintRefreshSupport = !!(capabilities.workspace &&
+        capabilities.workspace.inlayHint &&
+        capabilities.workspace.inlayHint.refreshSupport);
+    hasCodeLensRefreshSupport = !!(capabilities.workspace &&
+        capabilities.workspace.codeLens &&
+        capabilities.workspace.codeLens.refreshSupport);
+    connection.console.log(`Inlay hint refresh support: ${hasInlayHintRefreshSupport}`);
+    connection.console.log(`Code lens refresh support: ${hasCodeLensRefreshSupport}`);
+    // Store workspace folders
+    if (params.workspaceFolders && params.workspaceFolders.length > 0) {
+        workspaceFolders = params.workspaceFolders.map(folder => folder.uri);
+    }
+    else if (params.rootUri) {
+        workspaceFolders = [params.rootUri];
+    }
     const result = {
         capabilities: {
             textDocumentSync: node_1.TextDocumentSyncKind.Incremental,
@@ -70,6 +135,9 @@ connection.onInitialize((params) => {
                 full: true
             },
             inlayHintProvider: true,
+            codeLensProvider: {
+                resolveProvider: false
+            },
             renameProvider: {
                 prepareProvider: true
             },
@@ -77,21 +145,89 @@ connection.onInitialize((params) => {
             documentLinkProvider: {
                 resolveProvider: false
             },
-            selectionRangeProvider: true
+            selectionRangeProvider: true,
+            executeCommandProvider: {
+                commands: [
+                    'hledger.addBalanceAssertion',
+                    'hledger.insertBalanceAssertion',
+                    'hledger.insertInferredAmount',
+                    'hledger.convertToTotalCost',
+                    'hledger.refreshInlayHints',
+                    'hledger.showWorkspaceGraph',
+                    'hledger.showWorkspaceGraphStructured'
+                ]
+            }
         }
     };
     // Note: Workspace folders support removed to avoid warnings with clients
     // that don't support dynamic registration (like Neovim)
+    connection.console.log('========== ON INITIALIZE COMPLETE ==========');
+    connection.console.log(`workspaceFolders array: ${JSON.stringify(workspaceFolders)}`);
     return result;
 });
-connection.onInitialized(() => {
+connection.onInitialized(async () => {
+    connection.console.log('========== ON INITIALIZED CALLED ==========');
     // Only use dynamic registration if the client supports it
     if (hasConfigurationCapability && hasDidChangeConfigurationDynamicRegistration) {
         // Register for all configuration changes dynamically
         connection.client.register(node_1.DidChangeConfigurationNotification.type, undefined);
     }
-    connection.console.log('hledger Language Server initialized');
+    // Initialize WorkspaceManager if we have workspace folders
+    if (workspaceFolders.length > 0) {
+        await initializeWorkspaceManager(workspaceFolders);
+        // Watch for config file changes
+        // Note: Many clients (including Neovim LSP) don't support dynamic file watchers,
+        // so we rely on onDidChangeWatchedFiles being called for any file changes
+        // If the client supports it, the workspace/configuration already watches files
+    }
+    else {
+        connection.console.log('hledger Language Server initialized (no workspace folders provided)');
+        connection.console.log('WorkspaceManager will be initialized when first document is opened');
+    }
 });
+// Helper function to initialize workspace manager
+async function initializeWorkspaceManager(folders, forceReinit = false) {
+    if (workspaceManager && !forceReinit) {
+        connection.console.log('WorkspaceManager already initialized');
+        return;
+    }
+    // Get workspace settings to pass as runtime config
+    const settings = await getDocumentSettings(folders[0]);
+    const runtimeConfig = settings?.workspace ? {
+        workspace: settings.workspace
+    } : undefined;
+    workspaceManager = new workspace_1.WorkspaceManager();
+    try {
+        connection.console.log(`Initializing WorkspaceManager with folders: ${folders.join(', ')}`);
+        await workspaceManager.initialize(folders, sharedParser, fileReader, connection, runtimeConfig);
+        // Log the root file being used
+        const diagnostics = workspaceManager.getDiagnosticInfo();
+        if (diagnostics.rootFile) {
+            connection.console.info(`✓ Workspace root file: ${diagnostics.rootFile}`);
+        }
+        else {
+            connection.console.warn(`⚠ No workspace root file detected - workspace features disabled`);
+        }
+        connection.console.log('hledger Language Server initialized with workspace awareness');
+        // Refresh all open documents now that workspace context is available
+        // This ensures features like inlay hints and diagnostics reflect the full workspace tree
+        connection.console.log('Refreshing open documents with workspace context...');
+        const openDocuments = documents.all();
+        for (const doc of openDocuments) {
+            // Re-validate with full workspace context
+            await validateTextDocument(doc);
+        }
+        // Refresh inlay hints for all open documents
+        if (hasInlayHintRefreshSupport) {
+            connection.languages.inlayHint.refresh();
+        }
+        connection.console.log(`Refreshed ${openDocuments.length} open document(s) with workspace context`);
+    }
+    catch (error) {
+        connection.console.error(`Failed to initialize WorkspaceManager: ${error}`);
+        workspaceManager = null;
+    }
+}
 // Global settings used when client does not support workspace/configuration
 let globalSettings = settings_1.defaultSettings;
 // include dependency functions are centralized in src/server/deps.ts
@@ -99,7 +235,23 @@ const deps_1 = require("./server/deps");
 // Create a shared parser instance with caching
 const sharedParser = new index_1.HledgerParser();
 // Small helper to centralize parsing options and reduce duplication across handlers
-function parseDocument(document) {
+function parseDocument(document, options) {
+    const mode = options?.parseMode || 'document';
+    // Workspace mode: parse from root file for global state
+    if (mode === 'workspace' && workspaceManager) {
+        const root = workspaceManager.getRootForFile(document.uri);
+        if (root) {
+            connection.console.info(`[parseDocument] Workspace mode: using root ${root}`);
+            const parsed = workspaceManager.parseWorkspace();
+            if (parsed) {
+                return parsed;
+            }
+        }
+        // Fallback to document mode if no root found (normal during initialization)
+        connection.console.info(`[parseDocument] No root found yet for ${document.uri}, using document mode`);
+    }
+    // Document mode: standard include-based parsing
+    connection.console.info(`[parseDocument] Document mode for ${document.uri}`);
     return sharedParser.parse(document, {
         baseUri: document.uri,
         fileReader
@@ -122,6 +274,23 @@ connection.onDidChangeConfiguration(change => {
 function getDocumentSettings(resource) {
     return (0, settings_1.getDocumentSettings)(connection, resource, hasConfigurationCapability);
 }
+// Lazy initialize workspace manager when first document is opened
+documents.onDidOpen(async (e) => {
+    connection.console.log('========== DOCUMENT OPENED ==========');
+    connection.console.log(`Document URI: ${e.document.uri}`);
+    connection.console.log(`workspaceManager exists: ${!!workspaceManager}`);
+    connection.console.log(`workspaceFolders.length: ${workspaceFolders.length}`);
+    // If workspace manager not initialized and we don't have workspace folders,
+    // use the directory of the opened document as the workspace
+    if (!workspaceManager && workspaceFolders.length === 0) {
+        const uri = e.document.uri;
+        const filePath = (0, uri_1.toFilePath)(uri);
+        const dirPath = path.dirname(filePath);
+        const workspaceUri = (0, uri_1.toFileUri)(dirPath);
+        connection.console.log(`Lazy-initializing WorkspaceManager with directory: ${workspaceUri}`);
+        await initializeWorkspaceManager([workspaceUri]);
+    }
+});
 // Only keep settings for open documents
 documents.onDidClose(e => {
     (0, settings_1.clearDocumentSettings)(e.document.uri);
@@ -132,6 +301,10 @@ documents.onDidChangeContent(change => {
     // Clear parser cache since a file changed
     // This ensures we re-parse files with fresh data
     sharedParser.clearCache();
+    // Invalidate workspace cache for affected roots
+    if (workspaceManager) {
+        workspaceManager.invalidateFile(change.document.uri);
+    }
     validateTextDocument(change.document);
     // Re-validate all files that depend on this one
     const dependents = (0, deps_1.getDependents)(change.document.uri);
@@ -143,15 +316,70 @@ documents.onDidChangeContent(change => {
             }
         }
     }
+    // In workspace mode, changes to one file affect all files in the workspace
+    // (e.g., running balances, transaction counts, completions)
+    // Refresh workspace-wide features for all open documents
+    if (workspaceManager) {
+        const changedRoot = workspaceManager.getRootForFile(change.document.uri);
+        if (changedRoot) {
+            // Find all open documents that share the same root
+            const allDocs = documents.all();
+            const affectedDocs = allDocs.filter(doc => {
+                const docRoot = workspaceManager.getRootForFile(doc.uri);
+                const isSameRoot = docRoot === changedRoot;
+                const isDifferentFile = doc.uri !== change.document.uri;
+                return isSameRoot && isDifferentFile;
+            });
+            // Re-validate affected documents (updates diagnostics)
+            for (const doc of affectedDocs) {
+                validateTextDocument(doc);
+            }
+            // Refresh inlay hints for all affected documents
+            // This updates running balances, inferred amounts, etc.
+            if (hasInlayHintRefreshSupport && affectedDocs.length > 0) {
+                connection.console.log(`[Cascade Refresh] Refreshing inlay hints for ${affectedDocs.length} affected document(s)`);
+                connection.languages.inlayHint.refresh();
+            }
+            else if (affectedDocs.length > 0) {
+                connection.console.warn(`[Cascade Refresh] Cannot refresh inlay hints - client does not support refresh (${affectedDocs.length} affected docs)`);
+            }
+            // Note: Code lenses will refresh when the client next requests them
+            // We've already invalidated the workspace cache above, which is sufficient
+        }
+    }
+});
+// Watch for config file changes (.hledger-lsp.json)
+connection.onDidChangeWatchedFiles(async (params) => {
+    for (const change of params.changes) {
+        if (change.uri.endsWith('.hledger-lsp.json')) {
+            connection.console.log(`Config file changed: ${change.uri}, reinitializing workspace`);
+            // Reinitialize workspace manager with new config
+            if (workspaceFolders.length > 0) {
+                await initializeWorkspaceManager(workspaceFolders, true);
+                // Revalidate all open documents with new configuration
+                documents.all().forEach(validateTextDocument);
+            }
+            break; // Only reinitialize once even if multiple config files changed
+        }
+    }
 });
 // dependency tracking moved to src/server/deps.ts
-// Use centralized file reader implementation
-const fileReader = uri_1.defaultFileReader;
+// Create a file reader that uses in-memory documents when available
+// This ensures we see unsaved changes in the editor
+const fileReader = (uri) => {
+    // First, check if we have this document open in memory
+    const openDoc = documents.get(uri);
+    if (openDoc) {
+        return openDoc;
+    }
+    // Fall back to reading from disk
+    return (0, uri_1.defaultFileReader)(uri);
+};
 async function validateTextDocument(textDocument) {
     // Get document settings
     const settings = (await getDocumentSettings(textDocument.uri)) ?? settings_1.defaultSettings;
-    // Parse the document with includes enabled (uses shared parser with caching)
-    const parsedDoc = parseDocument(textDocument);
+    // Validation needs workspace state for balance assertions and full transaction history
+    const parsedDoc = parseDocument(textDocument, { parseMode: 'workspace' });
     // Track which files this document includes
     const includedFiles = new Set();
     for (const directive of parsedDoc.directives) {
@@ -161,11 +389,11 @@ async function validateTextDocument(textDocument) {
         }
     }
     (0, deps_1.updateDependencies)(textDocument.uri, includedFiles);
-    // Update completion data from the parsed document (includes all included files)
-    completion_1.completionProvider.updateAccounts(parsedDoc.accounts.map(a => ({ name: a.name, declared: a.declared })));
-    completion_1.completionProvider.updatePayees(parsedDoc.payees.map(p => ({ name: p.name, declared: p.declared })));
-    completion_1.completionProvider.updateCommodities(parsedDoc.commodities.map(c => ({ name: c.name, declared: c.declared })));
-    completion_1.completionProvider.updateTags(parsedDoc.tags.map(t => ({ name: t.name, declared: t.declared })));
+    // Update completion data from the parsed document (includes all workspace files)
+    completion_1.completionProvider.updateAccounts(parsedDoc.accounts);
+    completion_1.completionProvider.updatePayees(parsedDoc.payees);
+    completion_1.completionProvider.updateCommodities(parsedDoc.commodities);
+    completion_1.completionProvider.updateTags(parsedDoc.tags);
     // Validate the document with settings
     const validationResult = validator_1.validator.validate(textDocument, parsedDoc, {
         baseUri: textDocument.uri,
@@ -189,8 +417,8 @@ connection.onCompletion(async (textDocumentPosition) => {
         if (!document) {
             return [];
         }
-        // Parse document for smart completions
-        const parsed = parseDocument(document);
+        // Completion needs workspace-wide accounts/payees/commodities for accurate suggestions
+        const parsed = parseDocument(document, { parseMode: 'workspace' });
         // Get settings for completion filtering
         const settings = await (0, settings_1.getDocumentSettings)(connection, textDocumentPosition.textDocument.uri, hasConfigurationCapability);
         return completion_1.completionProvider.getCompletionItems(document, textDocumentPosition.position, parsed, settings?.completion);
@@ -337,11 +565,13 @@ connection.languages.inlayHint.on(async (params) => {
         const document = documents.get(params.textDocument.uri);
         if (!document)
             return [];
-        // Parse document
-        const parsed = parseDocument(document);
         // Get settings for inlay hints
         const settings = await getDocumentSettings(params.textDocument.uri);
         const inlayHintsSettings = settings?.inlayHints || undefined;
+        // Use workspace mode for running balances (needs all transactions chronologically)
+        // Use document mode for inferred amounts (single-file context sufficient)
+        const parseMode = inlayHintsSettings?.showRunningBalances ? 'workspace' : 'document';
+        const parsed = parseDocument(document, { parseMode });
         return inlayHints_1.inlayHintsProvider.provideInlayHints(document, params.range, parsed, inlayHintsSettings);
     }
     catch (error) {
@@ -349,6 +579,24 @@ connection.languages.inlayHint.on(async (params) => {
         return [];
     }
 });
+// Provide code lenses
+connection.onCodeLens(async (params) => {
+    try {
+        const document = documents.get(params.textDocument.uri);
+        if (!document)
+            return [];
+        // CodeLens always needs workspace state for accurate transaction counts and balances
+        const parsed = parseDocument(document, { parseMode: 'workspace' });
+        // Get settings for code lens
+        const settings = await getDocumentSettings(params.textDocument.uri);
+        const codeLensSettings = settings?.codeLens || undefined;
+        return codeLens_1.codeLensProvider.provideCodeLenses(document, parsed, codeLensSettings);
+    }
+    catch (error) {
+        connection.console.error(`Error providing code lenses: ${error}`);
+        return [];
+    }
+});
 // Prepare rename - validate that position is on a renameable item
 connection.onPrepareRename((params) => {
     const document = documents.get(params.textDocument.uri);
@@ -413,8 +661,168 @@ connection.onSelectionRanges((params) => {
     const parsed = parseDocument(document);
     return selectionRange_1.selectionRangeProvider.provideSelectionRanges(document, params.positions, parsed) || [];
 });
+// Handle command execution
+connection.onExecuteCommand(async (params) => {
+    connection.console.log(`[ExecuteCommand] ${params.command}`);
+    if (params.command === 'hledger.addBalanceAssertion' || params.command === 'hledger.insertBalanceAssertion') {
+        const [uri, line, account, amounts] = params.arguments;
+        const document = documents.get(uri);
+        if (!document) {
+            return;
+        }
+        // Get the line text
+        const lineText = document.getText({
+            start: { line, character: 0 },
+            end: { line, character: Number.MAX_SAFE_INTEGER }
+        });
+        // Find where to insert the assertion
+        // Look for the end of the amount, or end of the account if no amount
+        // Skip leading whitespace and account name
+        let insertPos = lineText.length;
+        // Find the end of non-comment, non-whitespace content
+        const commentMatch = lineText.match(/\s*[;#]/);
+        if (commentMatch && commentMatch.index !== undefined) {
+            insertPos = commentMatch.index;
+        }
+        else {
+            // Trim trailing whitespace
+            insertPos = lineText.trimEnd().length;
+        }
+        // Build the assertion text
+        const assertionText = `  = ${amounts.join(', ')}`;
+        // Create and apply the edit
+        await connection.workspace.applyEdit({
+            changes: {
+                [uri]: [{
+                        range: {
+                            start: { line, character: insertPos },
+                            end: { line, character: insertPos }
+                        },
+                        newText: assertionText
+                    }]
+            }
+        });
+    }
+    else if (params.command === 'hledger.insertInferredAmount') {
+        const [uri, line, account, amountText] = params.arguments;
+        const document = documents.get(uri);
+        if (!document) {
+            return;
+        }
+        // Get the line text
+        const lineText = document.getText({
+            start: { line, character: 0 },
+            end: { line, character: Number.MAX_SAFE_INTEGER }
+        });
+        // Find where to insert the amount - after the account name
+        // Skip leading whitespace and find account name
+        const accountPos = lineText.indexOf(account);
+        if (accountPos === -1) {
+            return;
+        }
+        const insertPos = accountPos + account.length;
+        // Build the amount text with proper spacing
+        const insertText = `  ${amountText}`;
+        // Create and apply the edit
+        await connection.workspace.applyEdit({
+            changes: {
+                [uri]: [{
+                        range: {
+                            start: { line, character: insertPos },
+                            end: { line, character: insertPos }
+                        },
+                        newText: insertText
+                    }]
+            }
+        });
+    }
+    else if (params.command === 'hledger.convertToTotalCost') {
+        const [uri, line, account, totalCostText] = params.arguments;
+        const document = documents.get(uri);
+        if (!document) {
+            return;
+        }
+        // Get the line text
+        const lineText = document.getText({
+            start: { line, character: 0 },
+            end: { line, character: Number.MAX_SAFE_INTEGER }
+        });
+        // Find the unit cost notation (@ but not @@)
+        // Match @ followed by non-@ character
+        const unitCostMatch = lineText.match(/@(?!@)\s*[^;#\s]+/);
+        if (!unitCostMatch || unitCostMatch.index === undefined) {
+            return;
+        }
+        const startPos = unitCostMatch.index;
+        const endPos = startPos + unitCostMatch[0].length;
+        // Replace with total cost notation
+        const newText = `@@ ${totalCostText}`;
+        // Create and apply the edit
+        await connection.workspace.applyEdit({
+            changes: {
+                [uri]: [{
+                        range: {
+                            start: { line, character: startPos },
+                            end: { line, character: endPos }
+                        },
+                        newText: newText
+                    }]
+            }
+        });
+    }
+    else if (params.command === 'hledger.refreshInlayHints') {
+        // Manually refresh inlay hints
+        if (hasInlayHintRefreshSupport) {
+            await connection.languages.inlayHint.refresh().catch((err) => {
+                connection.console.error(`Failed to refresh inlay hints: ${err}`);
+            });
+        }
+        else {
+            connection.window.showInformationMessage('Inlay hint refresh not supported by your editor');
+        }
+    }
+    else if (params.command === 'hledger.showWorkspaceGraph') {
+        connection.console.log(`[ExecuteCommand] showWorkspaceGraph called. workspaceManager exists: ${!!workspaceManager}`);
+        if (workspaceManager) {
+            try {
+                const graph = workspaceManager.getWorkspaceTree();
+                connection.console.log(`[ExecuteCommand] Tree generated, length: ${graph.length}`);
+                return graph;
+            }
+            catch (error) {
+                connection.console.error(`[ExecuteCommand] Error generating tree: ${error}`);
+                return `Error generating tree: ${error}`;
+            }
+        }
+        else {
+            connection.console.warn('[ExecuteCommand] Workspace manager not initialized');
+            connection.window.showErrorMessage('Workspace manager not initialized');
+            return 'Error: Workspace manager not initialized. Check LSP logs.';
+        }
+    }
+    else if (params.command === 'hledger.showWorkspaceGraphStructured') {
+        connection.console.log(`[ExecuteCommand] showWorkspaceGraphStructured called. workspaceManager exists: ${!!workspaceManager}`);
+        if (workspaceManager) {
+            try {
+                const entries = workspaceManager.getWorkspaceTreeStructured();
+                connection.console.log(`[ExecuteCommand] Structured tree generated, ${entries.length} entries`);
+                return entries;
+            }
+            catch (error) {
+                connection.console.error(`[ExecuteCommand] Error generating structured tree: ${error}`);
+                return [];
+            }
+        }
+        else {
+            connection.console.warn('[ExecuteCommand] Workspace manager not initialized');
+            connection.window.showErrorMessage('Workspace manager not initialized');
+            return [];
+        }
+    }
+});
 // Make the text document manager listen on the connection
 documents.listen(connection);
 // Listen on the connection
 connection.listen();
+connection.console.log('========== HLEDGER LSP SERVER LISTENING ==========');
 //# sourceMappingURL=server.js.map