@get-technology-inc/jamf-docs-mcp-server 1.4.1 → 1.5.1

package/dist/services/scraper.js

@@ -7,15 +7,17 @@
 import axios from 'axios';
 import * as cheerio from 'cheerio';
 import { sanitizeErrorMessage } from '../utils/sanitize.js';
-import { isAllowedHostname } from '../utils/url.js';
+import { isAllowedHostname, extractLocaleFromUrl } from '../utils/url.js';
 import TurndownService from 'turndown';
-import { DOCS_BASE_URL, DOCS_API_URL, JAMF_PRODUCTS, JAMF_TOPICS, DOC_TYPE_LABEL_MAP, REQUEST_CONFIG, SELECTORS, CONTENT_LIMITS, TOKEN_CONFIG, PAGINATION_CONFIG, DEFAULT_LOCALE } from '../constants.js';
+import { DOCS_BASE_URL, DOCS_API_URL, JAMF_PRODUCTS, JAMF_TOPICS, DOC_TYPE_LABEL_MAP, REQUEST_CONFIG, SELECTORS, CONTENT_LIMITS, TOKEN_CONFIG, PAGINATION_CONFIG, DEFAULT_LOCALE, SUPPORTED_LOCALES } from '../constants.js';
 import { JamfDocsError, JamfDocsErrorCode } from '../types.js';
-import { extractVersionFromBundleId, extractProductSlug } from '../utils/bundle.js';
+import { extractVersionFromBundleId, extractProductSlug, compareVersions } from '../utils/bundle.js';
 import { docTypeFromLabels } from '../utils/doc-type.js';
 import { cache } from './cache.js';
+import { createLogger } from './logging.js';
 import { estimateTokens, createTokenInfo, extractSections, extractSection, extractSummary, truncateToTokenLimit, calculatePagination } from './tokenizer.js';
 import { getBundleIdForVersion } from './metadata.js';
+const log = createLogger('scraper');
 // Initialize Turndown for HTML to Markdown conversion
 const turndown = new TurndownService({
     headingStyle: 'atx',
@@ -47,15 +49,34 @@ async function throttle() {
 }
 // Re-export URL utilities for backward compatibility
 export { ALLOWED_HOSTNAMES, isAllowedHostname } from '../utils/url.js';
+/**
+ * Strip locale prefix (e.g. /en-US/, /ja-JP/) from URL path.
+ * Frontend URLs include locale in path but backend doesn't accept it.
+ */
+export function stripLocalePrefix(urlStr) {
+    try {
+        const url = new URL(urlStr);
+        const segments = url.pathname.split('/').filter(Boolean);
+        const firstSegment = segments[0];
+        if (firstSegment !== undefined && firstSegment in SUPPORTED_LOCALES) {
+            url.pathname = `/${segments.slice(1).join('/')}`;
+            return url.toString();
+        }
+    }
+    catch {
+        // Invalid URL, return as-is
+    }
+    return urlStr;
+}
 // URL transformation between frontend (learn.jamf.com) and backend (learn-be.jamf.com)
-function transformToBackendUrl(urlStr) {
+export function transformToBackendUrl(urlStr) {
     const url = new URL(urlStr);
     if (url.hostname === 'learn.jamf.com') {
         url.hostname = 'learn-be.jamf.com';
     }
     return url.toString();
 }
-function transformToFrontendUrl(urlStr) {
+export function transformToFrontendUrl(urlStr) {
     const url = new URL(urlStr);
     if (url.hostname === 'learn-be.jamf.com') {
         url.hostname = 'learn.jamf.com';
@@ -140,7 +161,7 @@ function handleAxiosError(error, url, resourceType) {
 /**
  * Build Accept-Language header value for a given locale
  */
-function buildAcceptLanguage(locale) {
+export function buildAcceptLanguage(locale) {
     if (locale === 'en-US') {
         return 'en-US,en;q=0.9';
     }
@@ -170,7 +191,7 @@ async function fetchUrl(url, accept, resourceType, locale) {
     }
 }
 const fetchJson = async (url, locale) => await fetchUrl(url, 'application/json', 'Resource', locale);
-const fetchHtml = async (url, locale) => await fetchUrl(url, 'text/html,application/xhtml+xml', 'Article', locale);
+export const fetchHtml = async (url, locale) => await fetchUrl(url, 'text/html,application/xhtml+xml', 'Article', locale);
 /**
  * Clean HTML content by removing unwanted elements
  */
@@ -296,108 +317,46 @@ function selectVersionedEntry(leading, followers, requestedVersion) {
     return { url: leading.url, bundleId: leading.bundle_id, version: leadingVersion, versionMatched: false };
 }
 /**
- * Search Jamf documentation using Zoomin Search API
+ * Transform a Zoomin leading result into a SearchResultWithMeta
  */
-export async function searchDocumentation(params) {
-    const page = params.page ?? PAGINATION_CONFIG.DEFAULT_PAGE;
-    const pageSize = params.limit ?? CONTENT_LIMITS.DEFAULT_SEARCH_RESULTS;
-    const maxTokens = params.maxTokens ?? TOKEN_CONFIG.DEFAULT_MAX_TOKENS;
-    const locale = params.language ?? DEFAULT_LOCALE;
-    const cacheKey = `${locale}:search:${JSON.stringify({
-        query: params.query, product: params.product, topic: params.topic,
-        docType: params.docType, version: params.version, limit: params.limit,
-        maxTokens: params.maxTokens, page: 1
-    })}`;
-    // Check cache for full results
-    let allResults = await cache.get(cacheKey);
-    if (allResults === null) {
-        // Over-fetch when client-side filters (docType/version) are active
-        const hasClientFilter = params.docType !== undefined || (params.version !== undefined && params.version !== 'current');
-        const fetchLimit = hasClientFilter
-            ? Math.min(CONTENT_LIMITS.MAX_SEARCH_RESULTS * CONTENT_LIMITS.FILTER_OVERFETCH_MULTIPLIER, CONTENT_LIMITS.FILTER_OVERFETCH_CAP)
-            : CONTENT_LIMITS.MAX_SEARCH_RESULTS;
-        // Build API URL with query params
-        const apiUrl = new URL(`${DOCS_API_URL}/api/search`);
-        apiUrl.searchParams.set('q', params.query);
-        apiUrl.searchParams.set('rpp', fetchLimit.toString());
-        if (locale !== DEFAULT_LOCALE) {
-            apiUrl.searchParams.set('lang', locale);
-        }
-        console.error(`[SEARCH] Query: "${params.query}", Product: ${params.product ?? 'all'}, Topic: ${params.topic ?? 'all'}, Locale: ${locale}, URL: ${apiUrl.toString()}`);
-        try {
-            const response = await fetchJson(apiUrl.toString(), locale);
-            // Transform Zoomin results to SearchResult format with metadata
-            allResults = response.Results
-                .filter((wrapper) => wrapper.leading_result !== null && wrapper.leading_result !== undefined)
-                .filter(wrapper => {
-                // Validate URL hostname from external API
-                const resultUrl = wrapper.leading_result.url;
-                if (resultUrl !== '' && !isAllowedHostname(resultUrl)) {
-                    console.error(`[SEARCH] Skipping result with unexpected hostname: ${resultUrl}`);
-                    return false;
-                }
-                return true;
-            })
-                .map(wrapper => {
-                const leading = wrapper.leading_result;
-                // Select versioned entry (leading or matching follower)
-                const versioned = selectVersionedEntry(leading, wrapper.follower_result, params.version);
-                // Extract product from bundle_id (works for all bundle types: documentation, release-notes, etc.)
-                const { bundleId } = versioned;
-                const bundleSlug = extractProductSlug(bundleId);
-                const productEntry = bundleSlug !== null
-                    ? Object.entries(JAMF_PRODUCTS).find(([id]) => id === bundleSlug)
-                    : null;
-                const resultTitle = leading.title !== '' ? leading.title : 'Untitled';
-                const resultProduct = productEntry !== null && productEntry !== undefined ? productEntry[1].name : (leading.publication_title !== '' ? leading.publication_title : 'Jamf');
-                const rawSnippet = stripHtml(leading.snippet !== '' ? leading.snippet : '').slice(0, CONTENT_LIMITS.MAX_SNIPPET_LENGTH);
-                // Derive docType from labels instead of bundle_id regex
-                const { labels } = leading;
-                const labelKeys = (labels ?? []).map(l => l.key);
-                const searchResult = {
-                    title: resultTitle,
-                    url: transformToFrontendUrl(versioned.url !== '' ? versioned.url : ''),
-                    snippet: cleanSnippet(rawSnippet, resultTitle, resultProduct),
-                    product: resultProduct,
-                    version: versioned.version,
-                    docType: docTypeFromLabels(labels)
-                };
-                if (leading.score !== undefined) {
-                    searchResult.relevance = leading.score;
-                }
-                // Find matched topics (searchText lowercased once, keywords pre-computed)
-                const searchText = `${searchResult.title} ${searchResult.snippet}`.toLowerCase();
-                const matchedTopics = ALL_TOPIC_IDS
-                    .filter(topicId => TOPIC_KEYWORDS_LOWER[topicId].some(kw => searchText.includes(kw)));
-                return {
-                    result: searchResult, bundleSlug, bundleId, matchedTopics, labelKeys,
-                    versionMatched: versioned.versionMatched
-                };
-            });
-            // Cache full results
-            await cache.set(cacheKey, allResults);
-        }
-        catch (error) {
-            console.error('[SEARCH] Error:', error);
-            if (error instanceof JamfDocsError) {
-                throw error;
-            }
-            // Return empty results on error
-            return {
-                results: [],
-                pagination: {
-                    page: 1,
-                    pageSize,
-                    totalPages: 0,
-                    totalItems: 0,
-                    hasNext: false,
-                    hasPrev: false
-                },
-                tokenInfo: createTokenInfo('', maxTokens)
-            };
-        }
+function transformZoominResult(wrapper, requestedVersion) {
+    const leading = wrapper.leading_result;
+    const versioned = selectVersionedEntry(leading, wrapper.follower_result, requestedVersion);
+    const { bundleId } = versioned;
+    const bundleSlug = extractProductSlug(bundleId);
+    const productEntry = bundleSlug !== null
+        ? Object.entries(JAMF_PRODUCTS).find(([id]) => id === bundleSlug)
+        : null;
+    const resultTitle = leading.title !== '' ? leading.title : 'Untitled';
+    const resultProduct = productEntry !== null && productEntry !== undefined
+        ? productEntry[1].name
+        : (leading.publication_title !== '' ? leading.publication_title : 'Jamf');
+    const rawSnippet = stripHtml(leading.snippet !== '' ? leading.snippet : '').slice(0, CONTENT_LIMITS.MAX_SNIPPET_LENGTH);
+    const { labels } = leading;
+    const labelKeys = (labels ?? []).map(l => l.key);
+    const searchResult = {
+        title: resultTitle,
+        url: transformToFrontendUrl(versioned.url !== '' ? versioned.url : ''),
+        snippet: cleanSnippet(rawSnippet, resultTitle, resultProduct),
+        product: resultProduct,
+        version: versioned.version,
+        docType: docTypeFromLabels(labels)
+    };
+    if (leading.score !== undefined) {
+        searchResult.relevance = leading.score;
     }
-    // Build active filters
+    const searchText = `${searchResult.title} ${searchResult.snippet}`.toLowerCase();
+    const matchedTopics = ALL_TOPIC_IDS
+        .filter(topicId => TOPIC_KEYWORDS_LOWER[topicId].some(kw => searchText.includes(kw)));
+    return {
+        result: searchResult, bundleSlug, bundleId, matchedTopics, labelKeys,
+        versionMatched: versioned.versionMatched
+    };
+}
+/**
+ * Build active filters from search params for progressive relaxation
+ */
+function buildActiveFilters(params) {
     const activeFilters = [];
     if (params.product !== undefined) {
         activeFilters.push({
@@ -417,13 +376,11 @@ export async function searchDocumentation(params) {
     if (params.docType !== undefined) {
         const docTypeFilter = params.docType;
         const targetLabelKey = DOC_TYPE_LABEL_MAP[docTypeFilter];
-        // Only apply filter if the docType maps to a known label key
         if (targetLabelKey !== undefined) {
             activeFilters.push({
                 name: 'docType',
                 value: docTypeFilter,
                 apply: (results) => results.filter(r => {
-                    // If result has no labels, include it (don't filter out)
                     if (r.labelKeys.length === 0) {
                         return true;
                     }
@@ -432,56 +389,158 @@ export async function searchDocumentation(params) {
             });
         }
     }
-    // Apply filters with progressive relaxation
-    const { filtered: filteredResults, relaxation: filterRelaxation } = applyFiltersWithFallback(allResults, activeFilters);
-    // Calculate pagination
-    const paginationInfo = calculatePagination(filteredResults.length, page, pageSize);
-    // Get paginated results
-    const paginatedResults = filteredResults
-        .slice(paginationInfo.startIndex, paginationInfo.endIndex)
-        .map(r => r.result);
-    // Calculate token info
-    const resultText = paginatedResults.map(r => `${r.title}\n${r.snippet}\n${r.url}`).join('\n\n');
-    const tokenCount = estimateTokens(resultText);
-    // Check if we need to truncate
-    let finalResults = paginatedResults;
-    let truncated = false;
-    if (tokenCount > maxTokens) {
-        // Truncate results to fit token limit
-        let runningTokens = 0;
-        finalResults = [];
-        for (const result of paginatedResults) {
-            const resultTokens = estimateTokens(`${result.title}\n${result.snippet}\n${result.url}`);
-            if (runningTokens + resultTokens > maxTokens) {
-                truncated = true;
-                break;
+    return activeFilters;
+}
+/**
+ * Truncate search results to fit within token budget.
+ * Returns the truncated results and info about omitted items.
+ */
+function truncateSearchResults(paginatedResults, maxTokens) {
+    const tokenCount = estimateTokens(paginatedResults.map(r => `${r.title}\n${r.snippet}\n${r.url}`).join('\n\n'));
+    if (tokenCount <= maxTokens) {
+        return { finalResults: paginatedResults, truncated: false };
+    }
+    let runningTokens = 0;
+    const finalResults = [];
+    for (const result of paginatedResults) {
+        const resultTokens = estimateTokens(`${result.title}\n${result.snippet}\n${result.url}`);
+        if (runningTokens + resultTokens > maxTokens) {
+            break;
+        }
+        finalResults.push(result);
+        runningTokens += resultTokens;
+    }
+    const omittedResults = paginatedResults.slice(finalResults.length);
+    const truncatedContent = {
+        omittedCount: omittedResults.length,
+        omittedItems: omittedResults.map(r => ({
+            title: r.title,
+            estimatedTokens: estimateTokens(`${r.title}\n${r.snippet}\n${r.url}`)
+        }))
+    };
+    return { finalResults, truncated: true, truncatedContent };
+}
+/**
+ * Fetch search results from API or cache
+ */
+async function fetchSearchResults(params, locale, cacheKey) {
+    const cached = await cache.get(cacheKey);
+    if (cached !== null) {
+        return cached;
+    }
+    const hasClientFilter = params.docType !== undefined || (params.version !== undefined && params.version !== 'current');
+    const fetchLimit = hasClientFilter
+        ? Math.min(CONTENT_LIMITS.MAX_SEARCH_RESULTS * CONTENT_LIMITS.FILTER_OVERFETCH_MULTIPLIER, CONTENT_LIMITS.FILTER_OVERFETCH_CAP)
+        : CONTENT_LIMITS.MAX_SEARCH_RESULTS;
+    const apiUrl = new URL(`${DOCS_API_URL}/api/search`);
+    apiUrl.searchParams.set('q', params.query);
+    apiUrl.searchParams.set('rpp', fetchLimit.toString());
+    if (locale !== DEFAULT_LOCALE) {
+        apiUrl.searchParams.set('lang', locale);
+    }
+    log.debug(`Query: "${params.query}", Product: ${params.product ?? 'all'}, Topic: ${params.topic ?? 'all'}, Locale: ${locale}, URL: ${apiUrl.toString()}`);
+    const response = await fetchJson(apiUrl.toString(), locale);
+    const results = response.Results
+        .filter((wrapper) => wrapper.leading_result !== null && wrapper.leading_result !== undefined)
+        .filter(wrapper => {
+        const resultUrl = wrapper.leading_result.url;
+        if (resultUrl !== '' && !isAllowedHostname(resultUrl)) {
+            log.warning(`Skipping result with unexpected hostname: ${resultUrl}`);
+            return false;
+        }
+        return true;
+    })
+        .map(wrapper => transformZoominResult(wrapper, params.version));
+    await cache.set(cacheKey, results);
+    return results;
+}
+/**
+ * Deduplicate search results by product + page slug, keeping the latest version.
+ * Only applied when no version filter is specified.
+ */
+function deduplicateByLatestVersion(results) {
+    const seen = new Map();
+    for (const item of results) {
+        const pageMatch = /\/page\/([^?#]+)/.exec(item.result.url);
+        if (pageMatch === null) {
+            seen.set(`_no_page_${seen.size}`, item);
+            continue;
+        }
+        const pageSlug = pageMatch[1] ?? '';
+        const productSlug = item.bundleSlug ?? '_unknown';
+        const key = `${productSlug}:${pageSlug}`;
+        const existing = seen.get(key);
+        if (existing === undefined) {
+            seen.set(key, item);
+        }
+        else {
+            const existingVersion = existing.result.version ?? '';
+            const newVersion = item.result.version ?? '';
+            if (compareVersions(newVersion, existingVersion) > 0) {
+                seen.set(key, item);
             }
-            finalResults.push(result);
-            runningTokens += resultTokens;
         }
     }
-    // Reuse already-computed token count when no truncation occurred
-    const finalTokenCount = truncated
-        ? estimateTokens(finalResults.map(r => `${r.title}\n${r.snippet}\n${r.url}`).join('\n\n'))
-        : tokenCount;
-    // Build truncated content info
-    let truncatedContent;
-    if (truncated) {
-        const omittedResults = paginatedResults.slice(finalResults.length);
-        truncatedContent = {
-            omittedCount: omittedResults.length,
-            omittedItems: omittedResults.map(r => ({
-                title: r.title,
-                estimatedTokens: estimateTokens(`${r.title}\n${r.snippet}\n${r.url}`)
-            }))
+    const kept = new Set(seen.values());
+    return results.filter(r => kept.has(r));
+}
+/**
+ * Search Jamf documentation using Zoomin Search API
+ */
+export async function searchDocumentation(params) {
+    const page = params.page ?? PAGINATION_CONFIG.DEFAULT_PAGE;
+    const pageSize = params.limit ?? CONTENT_LIMITS.DEFAULT_SEARCH_RESULTS;
+    const maxTokens = params.maxTokens ?? TOKEN_CONFIG.DEFAULT_MAX_TOKENS;
+    const locale = params.language ?? DEFAULT_LOCALE;
+    const cacheKey = `${locale}:search:${JSON.stringify({
+        query: params.query, product: params.product, topic: params.topic,
+        docType: params.docType, version: params.version, limit: params.limit,
+        maxTokens: params.maxTokens, page: 1
+    })}`;
+    let allResults;
+    try {
+        allResults = await fetchSearchResults(params, locale, cacheKey);
+    }
+    catch (error) {
+        log.error(`Search error: ${String(error)}`);
+        if (error instanceof JamfDocsError) {
+            throw error;
+        }
+        return {
+            results: [],
+            pagination: {
+                page: 1,
+                pageSize,
+                totalPages: 0,
+                totalItems: 0,
+                hasNext: false,
+                hasPrev: false
+            },
+            tokenInfo: createTokenInfo('', maxTokens)
         };
     }
+    // Build and apply filters with progressive relaxation
+    const activeFilters = buildActiveFilters(params);
+    const { filtered: filteredResults, relaxation: filterRelaxation } = applyFiltersWithFallback(allResults, activeFilters);
+    // Deduplicate cross-version results when no version filter
+    const dedupedResults = params.version === undefined || params.version === ''
+        ? deduplicateByLatestVersion(filteredResults)
+        : filteredResults;
+    // Calculate pagination
+    const paginationInfo = calculatePagination(dedupedResults.length, page, pageSize);
+    // Get paginated results
+    const paginatedResults = dedupedResults
+        .slice(paginationInfo.startIndex, paginationInfo.endIndex)
+        .map(r => r.result);
+    // Truncate results to fit within token budget
+    const { finalResults, truncated, truncatedContent } = truncateSearchResults(paginatedResults, maxTokens);
+    const finalTokenCount = estimateTokens(finalResults.map(r => `${r.title}\n${r.snippet}\n${r.url}`).join('\n\n'));
     // Generate versionNote only when version was requested but not found in some results
     const requestedVersion = params.version;
     const hasVersionMismatch = requestedVersion !== undefined
         && requestedVersion !== 'current'
         && requestedVersion !== ''
-        && filteredResults.some(r => !r.versionMatched);
+        && dedupedResults.some(r => !r.versionMatched);
     const versionNote = hasVersionMismatch
         ? `Version "${requestedVersion}" was not available for some results. Showing the latest version instead.`
         : undefined;
@@ -491,8 +550,8 @@ export async function searchDocumentation(params) {
             page: paginationInfo.page,
             pageSize: paginationInfo.pageSize,
             totalPages: paginationInfo.totalPages,
-            totalItems: filteredResults.length,
-            hasNext: paginationInfo.hasNext || truncated,
+            totalItems: dedupedResults.length,
+            hasNext: paginationInfo.hasNext,
             hasPrev: paginationInfo.hasPrev
         },
         tokenInfo: {
@@ -511,10 +570,12 @@ export async function searchDocumentation(params) {
  */
 export async function fetchArticle(url, options = {}) {
     const maxTokens = options.maxTokens ?? TOKEN_CONFIG.DEFAULT_MAX_TOKENS;
-    const locale = options.locale ?? DEFAULT_LOCALE;
-    // Store original URL for display, use backend URL for fetching
-    const displayUrl = transformToFrontendUrl(url);
-    const articleFetchUrl = transformToBackendUrl(url);
+    // Infer locale from URL if not explicitly provided (e.g., /ja-JP/bundle/...)
+    const locale = options.locale ?? extractLocaleFromUrl(url);
+    // Strip locale prefix before transforming — backend doesn't accept /en-US/ etc. in path
+    const cleanUrl = stripLocalePrefix(url);
+    const displayUrl = transformToFrontendUrl(cleanUrl);
+    const articleFetchUrl = transformToBackendUrl(cleanUrl);
     const cacheKey = `${locale}:article:${displayUrl}`;
     // Check cache for raw article (without section/token processing)
     let rawArticle = await cache.get(cacheKey);
@@ -539,10 +600,25 @@ export async function fetchArticle(url, options = {}) {
             .filter(Boolean);
         // Extract related articles
         const relatedArticles = options.includeRelated === true
-            ? $(SELECTORS.RELATED).map((_, el) => ({
-                title: $(el).text().trim(),
-                url: $(el).attr('href') ?? ''
-            })).get().filter(r => r.title !== '' && r.url !== '')
+            ? $(SELECTORS.RELATED).map((_, el) => {
+                const rawHref = $(el).attr('href') ?? '';
+                // Skip empty or hash-only URLs (same-page anchors)
+                if (rawHref === '' || rawHref.startsWith('#')) {
+                    return { title: '', url: '' };
+                }
+                // Resolve relative URLs against the article's fetch URL
+                let resolvedUrl;
+                try {
+                    resolvedUrl = new URL(rawHref, articleFetchUrl).toString();
+                }
+                catch {
+                    resolvedUrl = rawHref;
+                }
+                return {
+                    title: $(el).text().trim(),
+                    url: transformToFrontendUrl(resolvedUrl)
+                };
+            }).get().filter(r => r.title !== '' && r.url !== '')
             : undefined;
         // Extract product info from URL
         const { product, version } = extractProductInfo(displayUrl);
@@ -629,7 +705,7 @@ async function discoverLatestBundleId(product) {
         }
     }
     catch (error) {
-        console.error(`[TOC] Error discovering bundle version for ${product}:`, error);
+        log.error(`Error discovering bundle version for ${product}: ${String(error)}`);
     }
     return null;
 }
@@ -722,12 +798,12 @@ async function buildTocFromSearch(product, locale) {
             entries.push({ title, url });
         }
         if (entries.length > 0) {
-            console.error(`[TOC] Built fallback TOC with ${entries.length} entries from search for ${product}`);
+            log.info(`Built fallback TOC with ${entries.length} entries from search for ${product}`);
         }
         return entries;
     }
     catch (error) {
-        console.error(`[TOC] Failed to build TOC from search for ${product}:`, error);
+        log.error(`Failed to build TOC from search for ${product}: ${String(error)}`);
         return [];
     }
 }
@@ -752,7 +828,7 @@ export async function fetchTableOfContents(product, version = 'current', options
         }
         // Fetch TOC from backend (may 404 for some products)
         const tocUrl = `${DOCS_API_URL}/bundle/${bundleId}/toc`;
-        console.error(`[TOC] Fetching TOC from: ${tocUrl}, Locale: ${locale}`);
+        log.debug(`Fetching TOC from: ${tocUrl}, Locale: ${locale}`);
         allToc = [];
         try {
             const tocJson = await fetchJson(tocUrl, locale);
@@ -766,11 +842,11 @@ export async function fetchTableOfContents(product, version = 'current', options
         }
         catch (error) {
             // TOC endpoint may 404 or fail for some products — fall through to search fallback
-            console.error(`[TOC] Backend TOC request failed for ${product}: ${error instanceof Error ? error.message : String(error)}`);
+            log.error(`Backend TOC request failed for ${product}: ${error instanceof Error ? error.message : String(error)}`);
         }
         // Fallback: build TOC from search results when backend returns empty or fails
         if (allToc.length === 0) {
-            console.error(`[TOC] No TOC entries for ${product}, falling back to search-based discovery`);
+            log.info(`No TOC entries for ${product}, falling back to search-based discovery`);
             allToc = await buildTocFromSearch(product, locale);
         }
         // Cache result
@@ -812,7 +888,7 @@ export async function fetchTableOfContents(product, version = 'current', options
             pageSize: paginationInfo.pageSize,
             totalPages: paginationInfo.totalPages,
             totalItems,
-            hasNext: paginationInfo.hasNext || truncated,
+            hasNext: paginationInfo.hasNext,
             hasPrev: paginationInfo.hasPrev
         },
         tokenInfo: {