hledger-lsp 0.1.5 → 0.1.7

package/out/features/validator.js

@@ -13,6 +13,8 @@ exports.validator = exports.Validator = void 0;
 const node_1 = require("vscode-languageserver/node");
 const uri_1 = require("../utils/uri");
 const settings_1 = require("../server/settings");
+const balanceCalculator_1 = require("../utils/balanceCalculator");
+const amountFormatter_1 = require("../utils/amountFormatter");
 class Validator {
     /**
      * Validate a parsed hledger document
@@ -30,11 +32,18 @@ class Validator {
             // Otherwise use defaults
             return settings_1.defaultSettings.validation?.[key] ?? true;
         };
+        // Normalize document URI for consistent comparison
+        const normalizedDocUri = (0, uri_1.toFileUri)((0, uri_1.toFilePath)(document.uri));
         // Validate each transaction
         for (const transaction of parsedDoc.transactions) {
+            // Only validate transactions in the current document
+            // (workspace parsing may include transactions from other files)
+            if (transaction.sourceUri !== normalizedDocUri) {
+                continue;
+            }
             // Check balance
             if (isEnabled('balance')) {
-                const balanceIssues = this.validateBalance(transaction, document);
+                const balanceIssues = this.validateBalance(transaction, document, parsedDoc);
                 diagnostics.push(...balanceIssues);
             }
             // Check missing amounts
@@ -87,36 +96,15 @@ class Validator {
      * Validate transaction balance
      * Transactions must balance (all amounts sum to zero per commodity)
      */
-    validateBalance(transaction, document) {
+    validateBalance(transaction, document, parsedDoc) {
         const diagnostics = [];
-        // Group postings by commodity
-        const balances = new Map();
+        // Calculate transaction balance by commodity
+        const balances = (0, balanceCalculator_1.calculateTransactionBalance)(transaction);
         // Count how many postings have amounts
         let postingsWithAmounts = 0;
         for (const posting of transaction.postings) {
             if (posting.amount) {
                 postingsWithAmounts++;
-                // If posting has a cost, use the cost commodity for balance calculation
-                if (posting.cost) {
-                    const costCommodity = posting.cost.amount.commodity || '';
-                    let costValue;
-                    if (posting.cost.type === 'unit') {
-                        // @ unitPrice: total cost = quantity * unitPrice
-                        costValue = posting.amount.quantity * posting.cost.amount.quantity;
-                    }
-                    else {
-                        // @@ totalPrice: use total price directly
-                        costValue = posting.cost.amount.quantity;
-                    }
-                    const current = balances.get(costCommodity) || 0;
-                    balances.set(costCommodity, current + costValue);
-                }
-                else {
-                    // No cost notation, use the posting's commodity
-                    const commodity = posting.amount.commodity || '';
-                    const current = balances.get(commodity) || 0;
-                    balances.set(commodity, current + posting.amount.quantity);
-                }
             }
         }
         // If all postings have amounts, check if they balance
@@ -124,11 +112,13 @@ class Validator {
             for (const [commodity, balance] of balances.entries()) {
                 // Allow for small floating point errors
                 if (Math.abs(balance) > 0.005) {
-                    const commodityStr = commodity ? ` ${commodity}` : '';
+                    const formattedBalance = commodity
+                        ? (0, amountFormatter_1.formatAmount)(balance, commodity, parsedDoc)
+                        : balance.toFixed(2);
                     diagnostics.push({
                         severity: node_1.DiagnosticSeverity.Error,
                         range: this.getTransactionRange(transaction, document),
-                        message: `Transaction does not balance: ${balance.toFixed(2)}${commodityStr} off`,
+                        message: `Transaction does not balance: ${formattedBalance} off`,
                         source: 'hledger'
                     });
                 }
@@ -159,6 +149,8 @@ class Validator {
      */
     validateUndeclaredItems(document, parsedDoc, settings, checkAccounts = true, checkPayees = true, checkCommodities = true, checkTags = true) {
         const diagnostics = [];
+        // Normalize document URI for consistent comparison
+        const normalizedDocUri = (0, uri_1.toFileUri)((0, uri_1.toFilePath)(document.uri));
         // Helper to convert severity string to DiagnosticSeverity
         const getSeverity = (severityStr) => {
             switch (severityStr) {
@@ -173,77 +165,281 @@ class Validator {
         const markAllInstances = settings?.validation?.markAllUndeclaredInstances ?? settings_1.defaultSettings.validation?.markAllUndeclaredInstances ?? true;
         // Check undeclared accounts (if enabled)
         if (checkAccounts) {
-            const undeclaredAccounts = Array.from(parsedDoc.accounts.values()).filter(a => !a.declared);
-            for (const account of undeclaredAccounts) {
-                const ranges = markAllInstances
-                    ? this.findAllOccurrences(document, account.name)
-                    : (() => { const r = this.findFirstOccurrence(document, account.name); return r ? [r] : []; })();
-                for (const range of ranges) {
-                    diagnostics.push({
-                        severity: getSeverity(settings?.severity?.undeclaredAccounts),
-                        range,
-                        message: `Account "${account.name}" is used but not declared with 'account' directive`,
-                        source: 'hledger',
-                        code: 'undeclared-account',
-                        data: { accountName: account.name }
-                    });
+            const undeclaredAccounts = new Set(Array.from(parsedDoc.accounts.values()).filter(a => !a.declared).map(a => a.name));
+            if (undeclaredAccounts.size > 0) {
+                const text = document.getText();
+                const lines = text.split('\n');
+                const processedAccounts = new Set();
+                // Iterate through transactions to find account usage locations
+                for (const transaction of parsedDoc.transactions) {
+                    // Only process transactions from the current document
+                    if (transaction.sourceUri && transaction.sourceUri !== normalizedDocUri) {
+                        continue;
+                    }
+                    if (transaction.line !== undefined) {
+                        let postingLineOffset = 1;
+                        for (const posting of transaction.postings) {
+                            const accountName = posting.account;
+                            if (undeclaredAccounts.has(accountName)) {
+                                if (!markAllInstances && processedAccounts.has(accountName)) {
+                                    postingLineOffset++;
+                                    continue;
+                                }
+                                // Find the posting line
+                                const postingLine = transaction.line + postingLineOffset;
+                                if (postingLine < lines.length) {
+                                    const line = lines[postingLine];
+                                    // Account name is after indentation, before amount/comment
+                                    const accountIndex = line.indexOf(accountName);
+                                    if (accountIndex !== -1) {
+                                        diagnostics.push({
+                                            severity: getSeverity(settings?.severity?.undeclaredAccounts),
+                                            range: {
+                                                start: { line: postingLine, character: accountIndex },
+                                                end: { line: postingLine, character: accountIndex + accountName.length }
+                                            },
+                                            message: `Account "${accountName}" is used but not declared with 'account' directive`,
+                                            source: 'hledger',
+                                            code: 'undeclared-account',
+                                            data: { accountName }
+                                        });
+                                        processedAccounts.add(accountName);
+                                    }
+                                }
+                            }
+                            postingLineOffset++;
+                        }
+                    }
                 }
             }
         }
         // Check undeclared payees (if enabled)
         if (checkPayees) {
-            const undeclaredPayees = Array.from(parsedDoc.payees.values()).filter(p => !p.declared);
-            for (const payee of undeclaredPayees) {
-                const ranges = markAllInstances
-                    ? this.findAllOccurrences(document, payee.name)
-                    : (() => { const r = this.findFirstOccurrence(document, payee.name); return r ? [r] : []; })();
-                for (const range of ranges) {
-                    diagnostics.push({
-                        severity: getSeverity(settings?.severity?.undeclaredPayees),
-                        range,
-                        message: `Payee "${payee.name}" is used but not declared with 'payee' directive`,
-                        source: 'hledger',
-                        code: 'undeclared-payee',
-                        data: { payeeName: payee.name }
-                    });
+            const undeclaredPayees = new Set(Array.from(parsedDoc.payees.values()).filter(p => !p.declared).map(p => p.name));
+            if (undeclaredPayees.size > 0) {
+                const text = document.getText();
+                const lines = text.split('\n');
+                const processedPayees = new Set();
+                // Iterate through transactions to find payee usage locations
+                for (const transaction of parsedDoc.transactions) {
+                    // Only process transactions from the current document
+                    if (transaction.sourceUri && transaction.sourceUri !== normalizedDocUri) {
+                        continue;
+                    }
+                    const payeeName = transaction.payee;
+                    if (undeclaredPayees.has(payeeName) && transaction.line !== undefined) {
+                        if (!markAllInstances && processedPayees.has(payeeName)) {
+                            continue;
+                        }
+                        const line = lines[transaction.line];
+                        // Payee is in the transaction header after date, status, and code
+                        const payeeIndex = line.indexOf(payeeName);
+                        if (payeeIndex !== -1) {
+                            diagnostics.push({
+                                severity: getSeverity(settings?.severity?.undeclaredPayees),
+                                range: {
+                                    start: { line: transaction.line, character: payeeIndex },
+                                    end: { line: transaction.line, character: payeeIndex + payeeName.length }
+                                },
+                                message: `Payee "${payeeName}" is used but not declared with 'payee' directive`,
+                                source: 'hledger',
+                                code: 'undeclared-payee',
+                                data: { payeeName }
+                            });
+                            processedPayees.add(payeeName);
+                        }
+                    }
                 }
             }
         }
         // Check undeclared commodities (if enabled)
         if (checkCommodities) {
-            const undeclaredCommodities = Array.from(parsedDoc.commodities.values()).filter(c => !c.declared);
-            for (const commodity of undeclaredCommodities) {
-                const ranges = markAllInstances
-                    ? this.findAllOccurrences(document, commodity.name)
-                    : (() => { const r = this.findFirstOccurrence(document, commodity.name); return r ? [r] : []; })();
-                for (const range of ranges) {
-                    diagnostics.push({
-                        severity: getSeverity(settings?.severity?.undeclaredCommodities),
-                        range,
-                        message: `Commodity "${commodity.name}" is used but not declared with 'commodity' directive`,
-                        source: 'hledger',
-                        code: 'undeclared-commodity',
-                        data: { commodityName: commodity.name }
-                    });
+            const undeclaredCommodities = new Set(Array.from(parsedDoc.commodities.values()).filter(c => !c.declared).map(c => c.name));
+            if (undeclaredCommodities.size > 0) {
+                const text = document.getText();
+                const lines = text.split('\n');
+                const processedCommodities = new Set();
+                // Iterate through transactions to find commodity usage locations
+                for (const transaction of parsedDoc.transactions) {
+                    // Only process transactions from the current document
+                    if (transaction.sourceUri && transaction.sourceUri !== normalizedDocUri) {
+                        continue;
+                    }
+                    if (transaction.line !== undefined) {
+                        let postingLineOffset = 1;
+                        for (const posting of transaction.postings) {
+                            const postingLine = transaction.line + postingLineOffset;
+                            if (postingLine < lines.length) {
+                                const line = lines[postingLine];
+                                // Check commodity in posting amount
+                                if (posting.amount?.commodity && undeclaredCommodities.has(posting.amount.commodity)) {
+                                    const commodityName = posting.amount.commodity;
+                                    if (!markAllInstances && processedCommodities.has(commodityName)) {
+                                        postingLineOffset++;
+                                        continue;
+                                    }
+                                    const commodityIndex = line.indexOf(commodityName);
+                                    if (commodityIndex !== -1) {
+                                        diagnostics.push({
+                                            severity: getSeverity(settings?.severity?.undeclaredCommodities),
+                                            range: {
+                                                start: { line: postingLine, character: commodityIndex },
+                                                end: { line: postingLine, character: commodityIndex + commodityName.length }
+                                            },
+                                            message: `Commodity "${commodityName}" is used but not declared with 'commodity' directive`,
+                                            source: 'hledger',
+                                            code: 'undeclared-commodity',
+                                            data: { commodityName }
+                                        });
+                                        processedCommodities.add(commodityName);
+                                    }
+                                }
+                                // Check commodity in cost notation
+                                if (posting.cost?.amount?.commodity && undeclaredCommodities.has(posting.cost.amount.commodity)) {
+                                    const commodityName = posting.cost.amount.commodity;
+                                    if (!markAllInstances && processedCommodities.has(commodityName)) {
+                                        postingLineOffset++;
+                                        continue;
+                                    }
+                                    // Cost appears after @ or @@
+                                    const atIndex = line.indexOf('@');
+                                    if (atIndex !== -1) {
+                                        const afterAt = line.substring(atIndex);
+                                        const commodityIndex = afterAt.indexOf(commodityName);
+                                        if (commodityIndex !== -1) {
+                                            const absoluteIndex = atIndex + commodityIndex;
+                                            diagnostics.push({
+                                                severity: getSeverity(settings?.severity?.undeclaredCommodities),
+                                                range: {
+                                                    start: { line: postingLine, character: absoluteIndex },
+                                                    end: { line: postingLine, character: absoluteIndex + commodityName.length }
+                                                },
+                                                message: `Commodity "${commodityName}" is used but not declared with 'commodity' directive`,
+                                                source: 'hledger',
+                                                code: 'undeclared-commodity',
+                                                data: { commodityName }
+                                            });
+                                            processedCommodities.add(commodityName);
+                                        }
+                                    }
+                                }
+                                // Check commodity in balance assertion
+                                if (posting.assertion?.commodity && undeclaredCommodities.has(posting.assertion.commodity)) {
+                                    const commodityName = posting.assertion.commodity;
+                                    if (!markAllInstances && processedCommodities.has(commodityName)) {
+                                        postingLineOffset++;
+                                        continue;
+                                    }
+                                    // Assertion appears after =
+                                    const equalsIndex = line.indexOf('=');
+                                    if (equalsIndex !== -1) {
+                                        const afterEquals = line.substring(equalsIndex);
+                                        const commodityIndex = afterEquals.indexOf(commodityName);
+                                        if (commodityIndex !== -1) {
+                                            const absoluteIndex = equalsIndex + commodityIndex;
+                                            diagnostics.push({
+                                                severity: getSeverity(settings?.severity?.undeclaredCommodities),
+                                                range: {
+                                                    start: { line: postingLine, character: absoluteIndex },
+                                                    end: { line: postingLine, character: absoluteIndex + commodityName.length }
+                                                },
+                                                message: `Commodity "${commodityName}" is used but not declared with 'commodity' directive`,
+                                                source: 'hledger',
+                                                code: 'undeclared-commodity',
+                                                data: { commodityName }
+                                            });
+                                            processedCommodities.add(commodityName);
+                                        }
+                                    }
+                                }
+                            }
+                            postingLineOffset++;
+                        }
+                    }
                 }
             }
         }
         // Check undeclared tags (if enabled)
         if (checkTags) {
-            const undeclaredTags = Array.from(parsedDoc.tags.values()).filter(t => !t.declared);
-            for (const tag of undeclaredTags) {
-                const ranges = markAllInstances
-                    ? this.findAllOccurrences(document, tag.name + ':')
-                    : (() => { const r = this.findFirstOccurrence(document, tag.name + ':'); return r ? [r] : []; })();
-                for (const range of ranges) {
-                    diagnostics.push({
-                        severity: getSeverity(settings?.severity?.undeclaredTags || 'information'),
-                        range,
-                        message: `Tag "${tag.name}" is used but not declared with 'tag' directive`,
-                        source: 'hledger',
-                        code: 'undeclared-tag',
-                        data: { tagName: tag.name }
-                    });
+            const undeclaredTags = new Set(Array.from(parsedDoc.tags.values()).filter(t => !t.declared).map(t => t.name));
+            if (undeclaredTags.size > 0) {
+                const text = document.getText();
+                const lines = text.split('\n');
+                const processedTags = new Set();
+                // Iterate through transactions to find tag usage locations
+                for (const transaction of parsedDoc.transactions) {
+                    // Only process transactions from the current document
+                    if (transaction.sourceUri && transaction.sourceUri !== normalizedDocUri) {
+                        continue;
+                    }
+                    // Check transaction-level tags
+                    if (transaction.tags) {
+                        for (const tagName of Object.keys(transaction.tags)) {
+                            if (undeclaredTags.has(tagName) && transaction.line !== undefined) {
+                                if (!markAllInstances && processedTags.has(tagName)) {
+                                    continue; // Skip if we already reported this tag
+                                }
+                                const line = lines[transaction.line];
+                                const commentIndex = line.indexOf(';');
+                                if (commentIndex !== -1) {
+                                    const tagIndex = line.indexOf(tagName + ':', commentIndex);
+                                    if (tagIndex !== -1) {
+                                        diagnostics.push({
+                                            severity: getSeverity(settings?.severity?.undeclaredTags || 'information'),
+                                            range: {
+                                                start: { line: transaction.line, character: tagIndex },
+                                                end: { line: transaction.line, character: tagIndex + tagName.length + 1 }
+                                            },
+                                            message: `Tag "${tagName}" is used but not declared with 'tag' directive`,
+                                            source: 'hledger',
+                                            code: 'undeclared-tag',
+                                            data: { tagName }
+                                        });
+                                        processedTags.add(tagName);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Check posting-level tags
+                    if (transaction.line !== undefined) {
+                        let postingLineOffset = 1;
+                        for (const posting of transaction.postings) {
+                            if (posting.tags) {
+                                for (const tagName of Object.keys(posting.tags)) {
+                                    if (undeclaredTags.has(tagName)) {
+                                        if (!markAllInstances && processedTags.has(tagName)) {
+                                            continue;
+                                        }
+                                        // Find the posting line
+                                        const postingLine = transaction.line + postingLineOffset;
+                                        if (postingLine < lines.length) {
+                                            const line = lines[postingLine];
+                                            const commentIndex = line.indexOf(';');
+                                            if (commentIndex !== -1) {
+                                                const tagIndex = line.indexOf(tagName + ':', commentIndex);
+                                                if (tagIndex !== -1) {
+                                                    diagnostics.push({
+                                                        severity: getSeverity(settings?.severity?.undeclaredTags || 'information'),
+                                                        range: {
+                                                            start: { line: postingLine, character: tagIndex },
+                                                            end: { line: postingLine, character: tagIndex + tagName.length + 1 }
+                                                        },
+                                                        message: `Tag "${tagName}" is used but not declared with 'tag' directive`,
+                                                        source: 'hledger',
+                                                        code: 'undeclared-tag',
+                                                        data: { tagName }
+                                                    });
+                                                    processedTags.add(tagName);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            postingLineOffset++;
+                        }
+                    }
                 }
             }
         }
@@ -289,74 +485,30 @@ class Validator {
         }
         return null;
     }
-    /**
-     * Find all occurrences of a string in the document
-     */
-    findAllOccurrences(document, searchStr) {
-        const text = document.getText();
-        const lines = text.split('\n');
-        const ranges = [];
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            let startIndex = 0;
-            let index;
-            // Find all occurrences in this line
-            while ((index = line.indexOf(searchStr, startIndex)) !== -1) {
-                ranges.push({
-                    start: { line: i, character: index },
-                    end: { line: i, character: index + searchStr.length }
-                });
-                startIndex = index + 1; // Move past this occurrence to find next
-            }
-        }
-        return ranges;
-    }
     /**
      * Validate date ordering
      * Warn if transactions are not in chronological order
      */
     validateDateOrdering(transactions, document) {
         const diagnostics = [];
-        for (let i = 1; i < transactions.length; i++) {
-            const prevDate = this.parseDate(transactions[i - 1].date);
-            const currDate = this.parseDate(transactions[i].date);
+        // Only validate transactions in the current document
+        const normalizedDocUri = (0, uri_1.toFileUri)((0, uri_1.toFilePath)(document.uri));
+        const documentTransactions = transactions.filter(t => t.sourceUri === normalizedDocUri);
+        for (let i = 1; i < documentTransactions.length; i++) {
+            const prevDate = this.parseDate(documentTransactions[i - 1].date);
+            const currDate = this.parseDate(documentTransactions[i].date);
             if (prevDate && currDate && currDate < prevDate) {
-                const range = this.getTransactionRange(transactions[i], document);
+                const range = this.getTransactionRange(documentTransactions[i], document);
                 diagnostics.push({
                     severity: node_1.DiagnosticSeverity.Warning,
                     range,
-                    message: `Transaction date ${transactions[i].date} is before previous transaction date ${transactions[i - 1].date}`,
+                    message: `Transaction date ${documentTransactions[i].date} is before previous transaction date ${documentTransactions[i - 1].date}`,
                     source: 'hledger'
                 });
             }
         }
         return diagnostics;
     }
-    /**
-     * Format an amount with commodity according to declared format
-     */
-    formatAmountWithCommodity(quantity, commodityName, parsedDoc) {
-        // Find commodity format
-        const commodity = parsedDoc.commodities.get(commodityName);
-        if (!commodity?.format) {
-            // No format declared, use default: amount then commodity with space
-            return commodityName ? `${quantity.toFixed(2)} ${commodityName}` : quantity.toFixed(2);
-        }
-        const format = commodity.format;
-        const symbol = format.symbol || commodityName;
-        const symbolOnLeft = format.symbolOnLeft ?? false;
-        const spaceBetween = format.spaceBetween ?? true;
-        const space = spaceBetween ? ' ' : '';
-        // Use precision from format, or default to 2
-        const precision = format.precision ?? 2;
-        const formattedNumber = quantity.toFixed(precision);
-        if (symbolOnLeft) {
-            return `${symbol}${space}${formattedNumber}`;
-        }
-        else {
-            return `${formattedNumber}${space}${symbol}`;
-        }
-    }
     /**
      * Validate balance assertions
      * Check if balance assertions match calculated balances
@@ -365,6 +517,8 @@ class Validator {
         const diagnostics = [];
         // Track running balances per account per commodity
         const balances = new Map();
+        // Process ALL transactions to calculate running balances correctly
+        // (workspace parsing includes transactions from all files)
         for (const transaction of transactions) {
             for (const posting of transaction.postings) {
                 // Update running balance
@@ -379,8 +533,9 @@ class Validator {
                     accountBalances.set(commodity, currentBalance + posting.amount.quantity);
                     balances.set(posting.account, accountBalances);
                 }
-                // Check assertion
-                if (posting.assertion) {
+                // Check assertion - but only create diagnostics for assertions in the current document
+                const normalizedDocUri = (0, uri_1.toFileUri)((0, uri_1.toFilePath)(document.uri));
+                if (posting.assertion && transaction.sourceUri === normalizedDocUri) {
                     const accountBalances = balances.get(posting.account);
                     const commodity = posting.assertion.commodity || '';
                     const expectedBalance = posting.assertion.quantity;
@@ -388,8 +543,8 @@ class Validator {
                     // Allow for small floating point errors
                     if (Math.abs(actualBalance - expectedBalance) > 0.005) {
                         const range = this.findPostingRange(transaction, posting, document);
-                        const expectedFormatted = this.formatAmountWithCommodity(expectedBalance, commodity, parsedDoc);
-                        const actualFormatted = this.formatAmountWithCommodity(actualBalance, commodity, parsedDoc);
+                        const expectedFormatted = (0, amountFormatter_1.formatAmount)(expectedBalance, commodity, parsedDoc);
+                        const actualFormatted = (0, amountFormatter_1.formatAmount)(actualBalance, commodity, parsedDoc);
                         diagnostics.push({
                             severity: node_1.DiagnosticSeverity.Error,
                             range,
@@ -580,50 +735,91 @@ class Validator {
         const includeDirectives = parsedDoc.directives.filter(d => d.type === 'include');
         for (const directive of includeDirectives) {
             const includePath = directive.value;
-            // Resolve the include path
-            const resolvedPath = (0, uri_1.resolveIncludePath)(includePath, baseUri);
-            // Check for duplicate includes in the same document
-            if (visited.has(resolvedPath)) {
-                const range = this.findFirstOccurrence(document, includePath);
-                if (range) {
-                    diagnostics.push({
-                        severity: node_1.DiagnosticSeverity.Warning,
-                        range,
-                        message: `Duplicate include: ${includePath}`,
-                        source: 'hledger'
-                    });
+            // Check if this is a glob pattern
+            const isGlob = /[*?\[\]{}]/.test(includePath);
+            if (isGlob) {
+                // For glob patterns, expand to all matching files
+                const resolvedPaths = (0, uri_1.resolveIncludePaths)(includePath, baseUri);
+                // Check if glob matched any files (if enabled)
+                if (resolvedPaths.length === 0 && checkMissingFiles) {
+                    const range = this.findFirstOccurrence(document, includePath);
+                    if (range) {
+                        diagnostics.push({
+                            severity: node_1.DiagnosticSeverity.Error,
+                            range,
+                            message: `Include glob pattern matches no files: ${includePath}`,
+                            source: 'hledger'
+                        });
+                    }
                 }
-                continue;
-            }
-            visited.add(resolvedPath);
-            // Check if file exists (if enabled)
-            const includeDoc = fileReader(resolvedPath);
-            if (!includeDoc && checkMissingFiles) {
-                // File doesn't exist
-                const range = this.findFirstOccurrence(document, includePath);
-                if (range) {
-                    diagnostics.push({
-                        severity: node_1.DiagnosticSeverity.Error,
-                        range,
-                        message: `Include file not found: ${includePath}`,
-                        source: 'hledger'
-                    });
+                // Check for circular includes for each matched file
+                if (checkCircularIncludes) {
+                    for (const resolvedPath of resolvedPaths) {
+                        const includeDoc = fileReader(resolvedPath);
+                        if (includeDoc) {
+                            const circularCheck = this.checkCircularInclude(document.uri, includeDoc, fileReader, new Set([baseUri, resolvedPath]));
+                            if (circularCheck) {
+                                const range = this.findFirstOccurrence(document, includePath);
+                                if (range) {
+                                    diagnostics.push({
+                                        severity: node_1.DiagnosticSeverity.Error,
+                                        range,
+                                        message: `Circular include detected in glob: ${includePath} (via ${resolvedPath})`,
+                                        source: 'hledger'
+                                    });
+                                    break; // Only report once per glob pattern
+                                }
+                            }
+                        }
+                    }
                 }
             }
-            // Check for circular includes (if enabled and file exists)
-            if (includeDoc && checkCircularIncludes) {
-                const circularCheck = this.checkCircularInclude(document.uri, includeDoc, fileReader, new Set([baseUri, resolvedPath]));
-                if (circularCheck) {
+            else {
+                // Single file include (existing logic)
+                const resolvedPath = (0, uri_1.resolveIncludePath)(includePath, baseUri);
+                // Check for duplicate includes in the same document
+                if (visited.has(resolvedPath)) {
+                    const range = this.findFirstOccurrence(document, includePath);
+                    if (range) {
+                        diagnostics.push({
+                            severity: node_1.DiagnosticSeverity.Warning,
+                            range,
+                            message: `Duplicate include: ${includePath}`,
+                            source: 'hledger'
+                        });
+                    }
+                    continue;
+                }
+                visited.add(resolvedPath);
+                // Check if file exists (if enabled)
+                const includeDoc = fileReader(resolvedPath);
+                if (!includeDoc && checkMissingFiles) {
+                    // File doesn't exist
                     const range = this.findFirstOccurrence(document, includePath);
                     if (range) {
                         diagnostics.push({
                             severity: node_1.DiagnosticSeverity.Error,
                             range,
-                            message: `Circular include detected: ${includePath}`,
+                            message: `Include file not found: ${includePath}`,
                             source: 'hledger'
                         });
                     }
                 }
+                // Check for circular includes (if enabled and file exists)
+                if (includeDoc && checkCircularIncludes) {
+                    const circularCheck = this.checkCircularInclude(document.uri, includeDoc, fileReader, new Set([baseUri, resolvedPath]));
+                    if (circularCheck) {
+                        const range = this.findFirstOccurrence(document, includePath);
+                        if (range) {
+                            diagnostics.push({
+                                severity: node_1.DiagnosticSeverity.Error,
+                                range,
+                                message: `Circular include detected: ${includePath}`,
+                                source: 'hledger'
+                            });
+                        }
+                    }
+                }
             }
         }
         return diagnostics;