@simpleapps-com/augur-api 0.2.2 → 0.2.4

package/dist/cjs/client.d.ts

@@ -1,4 +1,5 @@
 import { AugurAPIConfig } from './core/config';
+import { DiscoveryEndpoint as BaseDiscoveryEndpoint } from './core/base-client';
 import { JoomlaClient } from './services/joomla';
 import { CommerceClient } from './services/commerce';
 import { PricingClient } from './services/pricing';
@@ -12,6 +13,36 @@ import { CustomersClient } from './services/customers';
 import { OrdersClient } from './services/orders';
 import { P21PimClient } from './services/p21-pim';
 import { PaymentsClient } from './services/payments';
+/**
+ * Interface for discovery endpoint information - re-export base discovery endpoint
+ */
+export type DiscoveryEndpoint = BaseDiscoveryEndpoint;
+/**
+ * Interface for service discovery results
+ */
+export interface ServiceMap {
+    /** Service name */
+    serviceName: string;
+    /** Service description */
+    description: string;
+    /** Base URL for the service */
+    baseUrl: string;
+    /** Number of discoverable endpoints */
+    endpointCount: number;
+    /** Array of discoverable endpoints */
+    endpoints: DiscoveryEndpoint[];
+}
+/**
+ * Interface for endpoint search results
+ */
+export interface EndpointSearchResult {
+    /** The matching endpoint */
+    endpoint: DiscoveryEndpoint;
+    /** Relevance score (0-1) */
+    score: number;
+    /** Reason why this endpoint matched */
+    matchReason: string;
+}
 /**
  * Main client factory for accessing Augur microservices
  *
@@ -172,5 +203,155 @@ export declare class AugurAPI {
      * @param siteId New site ID
      */
     setSiteId(siteId: string): void;
+    /**
+     * Discover all available services and their capabilities
+     *
+     * Returns a complete service map showing all discoverable endpoints across
+     * all microservices, enabling AI agents to understand the full API topology.
+     *
+     * @returns Promise<ServiceMap[]> Array of service maps with endpoint metadata
+     *
+     * @example
+     * ```typescript
+     * const api = new AugurAPI({ siteId: 'my-site', bearerToken: 'token' });
+     * const services = await api.discover();
+     *
+     * // Find all user-related endpoints
+     * const userEndpoints = services.flatMap(s => s.endpoints)
+     *   .filter(e => e.searchTerms.some(term => term.includes('user')));
+     *
+     * // Show service capabilities
+     * services.forEach(service => {
+     *   console.log(`${service.serviceName}: ${service.endpointCount} endpoints`);
+     *   service.endpoints.forEach(endpoint => {
+     *     console.log(`  ${endpoint.fullPath} - ${endpoint.description}`);
+     *   });
+     * });
+     * ```
+     */
+    discover(): Promise<ServiceMap[]>;
+    /**
+     * Find endpoints by search term or functionality description
+     *
+     * Searches across all services to find endpoints that match the given search term.
+     * Uses intelligent matching against endpoint descriptions, search terms, domains,
+     * and common usage patterns.
+     *
+     * @param searchTerm The functionality or term to search for
+     * @param options Search options for filtering and ranking
+     * @returns Promise<EndpointSearchResult[]> Array of matching endpoints with relevance scores
+     *
+     * @example
+     * ```typescript
+     * const api = new AugurAPI({ siteId: 'my-site', bearerToken: 'token' });
+     *
+     * // Find user-related endpoints
+     * const userEndpoints = await api.findEndpoint('users');
+     * console.log(`Found ${userEndpoints.length} user-related endpoints`);
+     *
+     * // Find authentication endpoints
+     * const authEndpoints = await api.findEndpoint('authentication');
+     *
+     * // Find inventory management
+     * const inventoryEndpoints = await api.findEndpoint('inventory management');
+     *
+     * // Show results with scores
+     * userEndpoints.forEach(result => {
+     *   console.log(`${result.endpoint.fullPath} (${result.score.toFixed(2)}) - ${result.matchReason}`);
+     * });
+     * ```
+     */
+    findEndpoint(searchTerm: string, options?: {
+        /** Minimum relevance score (0-1, default: 0.1) */
+        minScore?: number;
+        /** Maximum number of results (default: 10) */
+        maxResults?: number;
+        /** Filter by specific service */
+        service?: string;
+        /** Filter by business domain */
+        domain?: string;
+        /** Include only GET endpoints */
+        readOnly?: boolean;
+    }): Promise<EndpointSearchResult[]>;
+    /**
+     * Get endpoints filtered by service, domain, and method options
+     */
+    private getFilteredEndpoints;
+    /**
+     * Search and score endpoints against search term
+     */
+    private searchAndScoreEndpoints;
+    /**
+     * Check if endpoint has required fields
+     */
+    private isValidEndpoint;
+    /**
+     * Calculate final score with domain filter adjustments
+     */
+    private calculateFinalScore;
+    /**
+     * Calculate relevance score for an endpoint against a search term
+     */
+    private calculateEndpointRelevance;
+    /**
+     * Process exact matches with appropriate combining logic
+     */
+    private processExactMatches;
+    /**
+     * Check if match type should be exclusive (no combining)
+     */
+    private isExclusiveMatch;
+    /**
+     * Check if match type can be combined with partial matches
+     */
+    private isCombinableMatch;
+    /**
+     * Process fallback matches when no exact match found
+     */
+    private processFallbackMatches;
+    /**
+     * Calculate exact field matches with high scores
+     */
+    private calculateExactMatches;
+    /**
+     * Check for path substring matches
+     */
+    private checkPathSubstringMatch;
+    /**
+     * Check for description substring matches
+     */
+    private checkDescriptionSubstringMatch;
+    /**
+     * Check for other substring matches (domain, service)
+     */
+    private checkOtherSubstringMatches;
+    /**
+     * Check for exact field matches
+     */
+    private checkExactFieldMatches;
+    /**
+     * Check search terms and common patterns
+     */
+    private checkSearchTermsAndPatterns;
+    /**
+     * Calculate partial word matches with lower scores
+     */
+    private calculatePartialMatches;
+    /**
+     * Build searchable text from endpoint fields
+     */
+    private buildSearchableText;
+    /**
+     * Count matching words in text
+     */
+    private countWordMatches;
+    /**
+     * Build partial match result with score and reason
+     */
+    private buildPartialMatchResult;
+    /**
+     * Calculate multi-word matches by finding the best match for each word
+     */
+    private calculateMultiWordMatches;
 }
 //# sourceMappingURL=client.d.ts.map

package/dist/cjs/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,OAAO,CAAC,CAAe;IAC/B,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,QAAQ,CAAC,CAAgB;IACjC,OAAO,CAAC,IAAI,CAAC,CAAY;IACzB,OAAO,CAAC,WAAW,CAAC,CAAmB;IACvC,OAAO,CAAC,MAAM,CAAC,CAAc;IAC7B,OAAO,CAAC,OAAO,CAAC,CAAe;IAC/B,OAAO,CAAC,MAAM,CAAC,CAAc;IAC7B,OAAO,CAAC,QAAQ,CAAC,CAAgB;IACjC,OAAO,CAAC,UAAU,CAAC,CAAkB;IACrC,OAAO,CAAC,OAAO,CAAC,CAAe;IAC/B,OAAO,CAAC,OAAO,CAAC,CAAe;IAC/B,OAAO,CAAC,SAAS,CAAC,CAAiB;gBAEvB,MAAM,EAAE,cAAc;IAIlC;;OAEG;IACH,IAAI,MAAM,IAAI,YAAY,CAMzB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,cAAc,CAM7B;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,aAAa,CAM3B;IAED;;OAEG;IACH,IAAI,GAAG,IAAI,SAAS,CAMnB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,gBAAgB,CAMjC;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,WAAW,CAMvB;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,YAAY,CAMzB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,WAAW,CAMvB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,aAAa,CAM3B;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,eAAe,CAM/B;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,YAAY,CAMzB;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,YAAY,CAMzB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,cAAc,CAM7B;IAED;;;OAGG;IACH,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAkBvC;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAiBhC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"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"}

package/dist/cjs/client.js

@@ -273,6 +273,455 @@ class AugurAPI {
         this._p21Pim = undefined;
         this._payments = undefined;
     }
+    /**
+     * Discover all available services and their capabilities
+     *
+     * Returns a complete service map showing all discoverable endpoints across
+     * all microservices, enabling AI agents to understand the full API topology.
+     *
+     * @returns Promise<ServiceMap[]> Array of service maps with endpoint metadata
+     *
+     * @example
+     * ```typescript
+     * const api = new AugurAPI({ siteId: 'my-site', bearerToken: 'token' });
+     * const services = await api.discover();
+     *
+     * // Find all user-related endpoints
+     * const userEndpoints = services.flatMap(s => s.endpoints)
+     *   .filter(e => e.searchTerms.some(term => term.includes('user')));
+     *
+     * // Show service capabilities
+     * services.forEach(service => {
+     *   console.log(`${service.serviceName}: ${service.endpointCount} endpoints`);
+     *   service.endpoints.forEach(endpoint => {
+     *     console.log(`  ${endpoint.fullPath} - ${endpoint.description}`);
+     *   });
+     * });
+     * ```
+     */
+    async discover() {
+        const services = [];
+        // Get all available service clients
+        const serviceClients = [
+            { name: 'joomla', client: this.joomla },
+            { name: 'commerce', client: this.commerce },
+            { name: 'pricing', client: this.pricing },
+            { name: 'vmi', client: this.vmi },
+            { name: 'opensearch', client: this.opensearch },
+            { name: 'items', client: this.items },
+            { name: 'legacy', client: this.legacy },
+            { name: 'nexus', client: this.nexus },
+            { name: 'agrSite', client: this.agrSite },
+            { name: 'customers', client: this.customers },
+            { name: 'orders', client: this.orders },
+            { name: 'p21Pim', client: this.p21Pim },
+            { name: 'payments', client: this.payments },
+        ];
+        for (const { client } of serviceClients) {
+            try {
+                // Get discovery metadata from each service client
+                const metadata = client.getDiscoveryMetadata();
+                services.push({
+                    serviceName: metadata.serviceName,
+                    description: metadata.description,
+                    baseUrl: metadata.baseUrl,
+                    endpointCount: metadata.endpoints.length,
+                    endpoints: metadata.endpoints,
+                });
+            }
+            catch {
+                // Silently skip services that don't support discovery
+                continue;
+            }
+        }
+        return services;
+    }
+    /**
+     * Find endpoints by search term or functionality description
+     *
+     * Searches across all services to find endpoints that match the given search term.
+     * Uses intelligent matching against endpoint descriptions, search terms, domains,
+     * and common usage patterns.
+     *
+     * @param searchTerm The functionality or term to search for
+     * @param options Search options for filtering and ranking
+     * @returns Promise<EndpointSearchResult[]> Array of matching endpoints with relevance scores
+     *
+     * @example
+     * ```typescript
+     * const api = new AugurAPI({ siteId: 'my-site', bearerToken: 'token' });
+     *
+     * // Find user-related endpoints
+     * const userEndpoints = await api.findEndpoint('users');
+     * console.log(`Found ${userEndpoints.length} user-related endpoints`);
+     *
+     * // Find authentication endpoints
+     * const authEndpoints = await api.findEndpoint('authentication');
+     *
+     * // Find inventory management
+     * const inventoryEndpoints = await api.findEndpoint('inventory management');
+     *
+     * // Show results with scores
+     * userEndpoints.forEach(result => {
+     *   console.log(`${result.endpoint.fullPath} (${result.score.toFixed(2)}) - ${result.matchReason}`);
+     * });
+     * ```
+     */
+    async findEndpoint(searchTerm, options = {}) {
+        const { minScore = 0.1, maxResults = 10, service, domain, readOnly = false } = options;
+        // Handle empty search term
+        if (!searchTerm.trim()) {
+            return [];
+        }
+        // Get filtered endpoints
+        const filteredEndpoints = await this.getFilteredEndpoints({ service, domain, readOnly });
+        // Search and score endpoints
+        const results = this.searchAndScoreEndpoints(filteredEndpoints, searchTerm, {
+            domain,
+            minScore,
+        });
+        // Sort by relevance score (highest first) and limit results
+        return results.sort((a, b) => b.score - a.score).slice(0, maxResults);
+    }
+    /**
+     * Get endpoints filtered by service, domain, and method options
+     */
+    async getFilteredEndpoints(filters) {
+        const { service, domain, readOnly } = filters;
+        const services = await this.discover();
+        let filteredEndpoints = services.flatMap(s => s.endpoints);
+        if (service) {
+            filteredEndpoints = filteredEndpoints.filter(e => e.service === service);
+        }
+        if (domain) {
+            filteredEndpoints = filteredEndpoints.filter(e => e.domain === domain);
+        }
+        if (readOnly) {
+            filteredEndpoints = filteredEndpoints.filter(e => e.method === 'GET');
+        }
+        return filteredEndpoints;
+    }
+    /**
+     * Search and score endpoints against search term
+     */
+    searchAndScoreEndpoints(endpoints, searchTerm, options) {
+        const { domain, minScore } = options;
+        const results = [];
+        const searchTermLower = searchTerm.toLowerCase();
+        for (const endpoint of endpoints) {
+            // Skip malformed endpoints
+            if (!this.isValidEndpoint(endpoint)) {
+                continue;
+            }
+            const { finalScore, finalMatchReason } = this.calculateFinalScore(endpoint, searchTermLower, domain);
+            if (finalScore >= minScore) {
+                results.push({
+                    endpoint,
+                    score: finalScore,
+                    matchReason: finalMatchReason,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Check if endpoint has required fields
+     */
+    isValidEndpoint(endpoint) {
+        return !!(endpoint.domain && endpoint.description && endpoint.method);
+    }
+    /**
+     * Calculate final score with domain filter adjustments
+     */
+    calculateFinalScore(endpoint, searchTermLower, domain) {
+        const { score, matchReason } = this.calculateEndpointRelevance(endpoint, searchTermLower);
+        // If domain filter is applied and search score is 0, give minimal score
+        if (domain && score === 0) {
+            return {
+                finalScore: 0.1,
+                finalMatchReason: 'Domain filter match',
+            };
+        }
+        return {
+            finalScore: score,
+            finalMatchReason: matchReason,
+        };
+    }
+    /**
+     * Calculate relevance score for an endpoint against a search term
+     */
+    calculateEndpointRelevance(endpoint, searchTermLower) {
+        const exactMatches = this.calculateExactMatches(endpoint, searchTermLower);
+        const partialMatches = this.calculatePartialMatches(endpoint, searchTermLower);
+        // Process exact matches if found
+        if (exactMatches.score > 0) {
+            return this.processExactMatches(exactMatches, partialMatches);
+        }
+        // Fallback to multi-word or partial matches
+        return this.processFallbackMatches(endpoint, searchTermLower, partialMatches);
+    }
+    /**
+     * Process exact matches with appropriate combining logic
+     */
+    processExactMatches(exactMatches, partialMatches) {
+        // Service and search term matches are exclusive
+        if (this.isExclusiveMatch(exactMatches.reason)) {
+            return {
+                score: exactMatches.score,
+                matchReason: exactMatches.reason,
+            };
+        }
+        // Combinable matches get partial score boost
+        if (this.isCombinableMatch(exactMatches.reason)) {
+            const totalScore = Math.min(exactMatches.score + partialMatches.score, 1.0);
+            return {
+                score: totalScore,
+                matchReason: exactMatches.reason,
+            };
+        }
+        // Default to exact match
+        return {
+            score: exactMatches.score,
+            matchReason: exactMatches.reason,
+        };
+    }
+    /**
+     * Check if match type should be exclusive (no combining)
+     */
+    isExclusiveMatch(reason) {
+        return reason === 'Service match' || reason.startsWith('Search term match');
+    }
+    /**
+     * Check if match type can be combined with partial matches
+     */
+    isCombinableMatch(reason) {
+        const combinableReasons = [
+            'Description match',
+            'Full path match',
+            'Path substring match',
+            'Domain match',
+            'Usage pattern match',
+        ];
+        return combinableReasons.includes(reason);
+    }
+    /**
+     * Process fallback matches when no exact match found
+     */
+    processFallbackMatches(endpoint, searchTermLower, partialMatches) {
+        const multiWordMatches = this.calculateMultiWordMatches(endpoint, searchTermLower);
+        if (multiWordMatches.score > partialMatches.score) {
+            return {
+                score: multiWordMatches.score,
+                matchReason: multiWordMatches.reason,
+            };
+        }
+        return {
+            score: partialMatches.score,
+            matchReason: partialMatches.reason || 'Low relevance match',
+        };
+    }
+    /**
+     * Calculate exact field matches with high scores
+     */
+    calculateExactMatches(endpoint, searchTermLower) {
+        // Check matches in priority order (not just highest score)
+        // Priority 1: Exact field matches (domain, service, exact path, exact description)
+        const exactMatch = this.checkExactFieldMatches(endpoint, searchTermLower);
+        if (exactMatch.score > 0) {
+            return exactMatch;
+        }
+        // Priority 2: Path and description substring matches (higher business value)
+        const pathMatch = this.checkPathSubstringMatch(endpoint, searchTermLower);
+        if (pathMatch.score > 0) {
+            return pathMatch;
+        }
+        const descSubstringMatch = this.checkDescriptionSubstringMatch(endpoint, searchTermLower);
+        if (descSubstringMatch.score > 0) {
+            return descSubstringMatch;
+        }
+        // Priority 3: Search terms and patterns
+        const termMatch = this.checkSearchTermsAndPatterns(endpoint, searchTermLower);
+        if (termMatch.score > 0) {
+            return termMatch;
+        }
+        // Priority 4: Other substring matches (domain, service)
+        const otherSubstringMatch = this.checkOtherSubstringMatches(endpoint, searchTermLower);
+        if (otherSubstringMatch.score > 0) {
+            return otherSubstringMatch;
+        }
+        return { score: 0, reason: '' };
+    }
+    /**
+     * Check for path substring matches
+     */
+    checkPathSubstringMatch(endpoint, searchTermLower) {
+        if (endpoint.fullPath &&
+            (endpoint.fullPath.toLowerCase().includes(searchTermLower) ||
+                searchTermLower.includes(endpoint.fullPath.toLowerCase()))) {
+            return { score: 0.9, reason: 'Path substring match' };
+        }
+        return { score: 0, reason: '' };
+    }
+    /**
+     * Check for description substring matches
+     */
+    checkDescriptionSubstringMatch(endpoint, searchTermLower) {
+        if (endpoint.description && endpoint.description.toLowerCase().includes(searchTermLower)) {
+            return { score: 0.65, reason: 'Description substring match' };
+        }
+        return { score: 0, reason: '' };
+    }
+    /**
+     * Check for other substring matches (domain, service)
+     */
+    checkOtherSubstringMatches(endpoint, searchTermLower) {
+        if (endpoint.domain && endpoint.domain.toLowerCase().includes(searchTermLower)) {
+            return { score: 0.5, reason: 'Domain match' };
+        }
+        if (endpoint.service && endpoint.service.toLowerCase().includes(searchTermLower)) {
+            return { score: 0.3, reason: 'Service match' };
+        }
+        return { score: 0, reason: '' };
+    }
+    /**
+     * Check for exact field matches
+     */
+    checkExactFieldMatches(endpoint, searchTermLower) {
+        if (endpoint.domain && endpoint.domain.toLowerCase() === searchTermLower) {
+            return { score: 0.6, reason: 'Domain match' };
+        }
+        if (endpoint.service && endpoint.service.toLowerCase() === searchTermLower) {
+            return { score: 0.3, reason: 'Service match' };
+        }
+        if (endpoint.fullPath && endpoint.fullPath.toLowerCase() === searchTermLower) {
+            return { score: 1.0, reason: 'Full path match' };
+        }
+        if (endpoint.description && endpoint.description.toLowerCase() === searchTermLower) {
+            return { score: 0.8, reason: 'Description match' };
+        }
+        return { score: 0, reason: '' };
+    }
+    /**
+     * Check search terms and common patterns
+     */
+    checkSearchTermsAndPatterns(endpoint, searchTermLower) {
+        if (Array.isArray(endpoint.searchTerms)) {
+            const searchTermMatches = endpoint.searchTerms.filter(term => term && typeof term === 'string' && term.toLowerCase().includes(searchTermLower));
+            if (searchTermMatches.length > 0) {
+                return { score: 0.7, reason: `Search term match: ${searchTermMatches[0]}` };
+            }
+        }
+        if (Array.isArray(endpoint.commonPatterns)) {
+            const patternMatches = endpoint.commonPatterns.filter(pattern => {
+                if (!pattern || typeof pattern !== 'string')
+                    return false;
+                const patternLower = pattern.toLowerCase();
+                return patternLower.includes(searchTermLower);
+            });
+            if (patternMatches.length > 0) {
+                return { score: 0.5, reason: 'Usage pattern match' };
+            }
+        }
+        return { score: 0, reason: '' };
+    }
+    /**
+     * Calculate partial word matches with lower scores
+     */
+    calculatePartialMatches(endpoint, searchTermLower) {
+        const allText = this.buildSearchableText(endpoint);
+        const wordMatches = this.countWordMatches(searchTermLower, allText);
+        return this.buildPartialMatchResult(wordMatches, searchTermLower);
+    }
+    /**
+     * Build searchable text from endpoint fields
+     */
+    buildSearchableText(endpoint) {
+        const searchTerms = Array.isArray(endpoint.searchTerms) ? endpoint.searchTerms : [];
+        const commonPatterns = Array.isArray(endpoint.commonPatterns) ? endpoint.commonPatterns : [];
+        return [
+            endpoint.fullPath || '',
+            endpoint.description || '',
+            endpoint.domain || '',
+            endpoint.service || '',
+            ...searchTerms,
+            ...commonPatterns,
+        ]
+            .filter(text => typeof text === 'string')
+            .join(' ')
+            .toLowerCase();
+    }
+    /**
+     * Count matching words in text
+     */
+    countWordMatches(searchTermLower, allText) {
+        const searchWords = searchTermLower.split(/\s+/).filter(word => word.length > 0);
+        let wordMatches = 0;
+        for (const word of searchWords) {
+            if (word.length > 2 && allText.includes(word)) {
+                wordMatches++;
+            }
+        }
+        return wordMatches;
+    }
+    /**
+     * Build partial match result with score and reason
+     */
+    buildPartialMatchResult(wordMatches, searchTermLower) {
+        if (wordMatches > 0) {
+            const searchWords = searchTermLower.split(/\s+/).filter(word => word.length > 0);
+            const partialScore = (wordMatches / searchWords.length) * 0.2;
+            const reasonText = `Partial word match (${wordMatches}/${searchWords.length})`;
+            return {
+                score: partialScore,
+                reason: reasonText,
+                matchReason: reasonText,
+            };
+        }
+        return { score: 0, reason: '', matchReason: '' };
+    }
+    /**
+     * Calculate multi-word matches by finding the best match for each word
+     */
+    calculateMultiWordMatches(endpoint, searchTermLower) {
+        const searchWords = searchTermLower.split(/\s+/).filter(word => word.length > 0);
+        // If only one word, fall back to exact matching
+        if (searchWords.length <= 1) {
+            return { score: 0, reason: '' };
+        }
+        let bestScore = 0;
+        let bestReason = '';
+        const matchedWords = [];
+        // Check each word against the endpoint fields
+        for (const word of searchWords) {
+            const wordMatch = this.calculateExactMatches(endpoint, word);
+            if (wordMatch.score > 0) {
+                // Keep track of the highest scoring match
+                if (wordMatch.score > bestScore) {
+                    bestScore = wordMatch.score;
+                    bestReason = wordMatch.reason;
+                }
+                matchedWords.push(word);
+            }
+        }
+        // If we matched multiple words, boost the score
+        if (matchedWords.length > 1) {
+            // Base score is the best individual match, with bonus for additional matches
+            const bonusScore = Math.min((matchedWords.length - 1) * 0.1, 0.3);
+            const finalScore = Math.min(bestScore + bonusScore, 1.0);
+            return {
+                score: finalScore,
+                reason: `Multi-word match (${matchedWords.length}/${searchWords.length} words): ${bestReason}`,
+            };
+        }
+        // Single word match - return as-is
+        if (bestScore > 0) {
+            return {
+                score: bestScore,
+                reason: bestReason,
+            };
+        }
+        return { score: 0, reason: '' };
+    }
 }
 exports.AugurAPI = AugurAPI;
 //# sourceMappingURL=client.js.map