@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/modules/collector/CodeCollector.js

@@ -1,762 +0,0 @@
-import { existsSync } from 'fs';
-import { readFile } from 'fs/promises';
-import { homedir } from 'os';
-import { join } from 'path';
-import { connect, launch } from 'rebrowser-puppeteer-core';
-import { logger } from '../../utils/logger.js';
-import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
-import { CodeCache } from '../collector/CodeCache.js';
-import { SmartCodeCollector } from '../collector/SmartCodeCollector.js';
-import { CodeCompressor } from '../collector/CodeCompressor.js';
-import { calculatePriorityScore } from '../collector/PageScriptCollectors.js';
-import { findBrowserExecutable } from '../../utils/browserExecutable.js';
-import { collectInnerImpl } from '../collector/CodeCollectorCollectInternal.js';
-import { shouldCollectUrlImpl, navigateWithRetryImpl, getPerformanceMetricsImpl, collectPageMetadataImpl, } from '../collector/CodeCollectorUtilsInternal.js';
-export class CodeCollector {
-    config;
-    browser = null;
-    collectedUrls = new Set();
-    initPromise = null;
-    collectLock = null;
-    connectAttemptId = 0;
-    MAX_COLLECTED_URLS;
-    MAX_FILES_PER_COLLECT;
-    MAX_RESPONSE_SIZE;
-    MAX_SINGLE_FILE_SIZE;
-    CONNECT_TIMEOUT_MS;
-    viewport;
-    userAgent;
-    collectedFilesCache = new Map();
-    cache;
-    cacheEnabled = true;
-    smartCollector;
-    compressor;
-    cdpSession = null;
-    cdpListeners = {};
-    activePageIndex = null;
-    currentHeadless = null;
-    explicitlyClosed = false;
-    connectedToExistingBrowser = false;
-    chromePid = null;
-    static BROWSER_CLOSE_TIMEOUT_MS = 5000;
-    constructor(config) {
-        this.config = config;
-        this.MAX_COLLECTED_URLS = config.maxCollectedUrls ?? 10000;
-        this.MAX_FILES_PER_COLLECT = config.maxFilesPerCollect ?? 200;
-        this.MAX_RESPONSE_SIZE = config.maxTotalContentSize ?? 512 * 1024;
-        this.MAX_SINGLE_FILE_SIZE = config.maxSingleFileSize ?? 200 * 1024;
-        this.CONNECT_TIMEOUT_MS = Number(process.env.JSHOOK_CONNECT_TIMEOUT_MS) || 60000;
-        this.viewport = config.viewport ?? { width: 1920, height: 1080 };
-        this.userAgent =
-            config.userAgent ??
-                'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
-        this.cache = new CodeCache();
-        this.smartCollector = new SmartCodeCollector();
-        this.compressor = new CodeCompressor();
-        logger.info(` CodeCollector limits: maxCollect=${this.MAX_FILES_PER_COLLECT} files, maxResponse=${(this.MAX_RESPONSE_SIZE / 1024).toFixed(0)}KB, maxSingle=${(this.MAX_SINGLE_FILE_SIZE / 1024).toFixed(0)}KB`);
-        logger.info(` Strategy: Collect ALL files -> Cache -> Return summary/partial data to fit MCP limits`);
-    }
-    setCacheEnabled(enabled) {
-        this.cacheEnabled = enabled;
-        logger.info(`Code cache ${enabled ? 'enabled' : 'disabled'}`);
-    }
-    async clearFileCache() {
-        await this.cache.clear();
-    }
-    async getFileCacheStats() {
-        return await this.cache.getStats();
-    }
-    async clearAllData() {
-        logger.info('Clearing all collected data...');
-        await this.cache.clear();
-        this.compressor.clearCache();
-        this.compressor.resetStats();
-        this.collectedUrls.clear();
-        this.collectedFilesCache.clear();
-        logger.success('All data cleared');
-    }
-    async getAllStats() {
-        const cacheStats = await this.cache.getStats();
-        const compressionStats = this.compressor.getStats();
-        return {
-            cache: cacheStats,
-            compression: {
-                ...compressionStats,
-                cacheSize: this.compressor.getCacheSize(),
-            },
-            collector: {
-                collectedUrls: this.collectedUrls.size,
-                maxCollectedUrls: this.MAX_COLLECTED_URLS,
-            },
-        };
-    }
-    getCache() {
-        return this.cache;
-    }
-    getCompressor() {
-        return this.compressor;
-    }
-    cleanupCollectedUrls() {
-        if (this.collectedUrls.size > this.MAX_COLLECTED_URLS) {
-            logger.warn(`Collected URLs exceeded ${this.MAX_COLLECTED_URLS}, clearing...`);
-            const urls = Array.from(this.collectedUrls);
-            this.collectedUrls.clear();
-            urls
-                .slice(-Math.floor(this.MAX_COLLECTED_URLS / 2))
-                .forEach((url) => this.collectedUrls.add(url));
-        }
-    }
-    async init(headless) {
-        if (this.browser) {
-            return;
-        }
-        this.explicitlyClosed = false;
-        if (this.initPromise) {
-            return this.initPromise;
-        }
-        this.initPromise = this.initInner(headless);
-        try {
-            await this.initPromise;
-        }
-        finally {
-            this.initPromise = null;
-        }
-    }
-    async initInner(headless) {
-        const useHeadless = headless ?? this.config.headless;
-        const executablePath = this.resolveExecutablePath();
-        const launchOptions = {
-            headless: useHeadless,
-            args: [
-                ...(this.config.args || []),
-                '--no-sandbox',
-                '--disable-setuid-sandbox',
-                '--disable-dev-shm-usage',
-                '--disable-blink-features=AutomationControlled',
-                '--disable-extensions',
-                '--disable-component-extensions-with-background-pages',
-                '--disable-web-security',
-                '--disable-features=IsolateOrigins,site-per-process',
-                `--window-size=${this.viewport.width},${this.viewport.height}`,
-                '--ignore-certificate-errors',
-            ],
-            defaultViewport: this.viewport,
-            protocolTimeout: 60000,
-        };
-        if (executablePath) {
-            launchOptions.executablePath = executablePath;
-        }
-        logger.info('Initializing browser with anti-detection...');
-        this.browser = await launch(launchOptions);
-        this.connectedToExistingBrowser = false;
-        this.chromePid = this.browser.process()?.pid ?? null;
-        if (this.chromePid) {
-            logger.debug(`Chrome child process PID: ${this.chromePid}`);
-        }
-        this.currentHeadless = useHeadless === undefined ? true : useHeadless !== false;
-        this.browser.on('disconnected', () => {
-            logger.warn('Browser disconnected');
-            this.browser = null;
-            this.currentHeadless = null;
-            this.connectedToExistingBrowser = false;
-            this.chromePid = null;
-            if (this.cdpSession) {
-                this.cdpSession = null;
-                this.cdpListeners = {};
-            }
-        });
-        logger.success('Browser initialized with enhanced anti-detection');
-    }
-    resolveExecutablePath() {
-        const configuredPath = this.config.executablePath?.trim();
-        if (configuredPath) {
-            if (existsSync(configuredPath)) {
-                return configuredPath;
-            }
-            throw new Error(`Configured browser executable was not found: ${configuredPath}. ` +
-                'Set a valid executablePath or configure CHROME_PATH / PUPPETEER_EXECUTABLE_PATH / BROWSER_EXECUTABLE_PATH.');
-        }
-        const detectedPath = findBrowserExecutable();
-        if (detectedPath) {
-            return detectedPath;
-        }
-        logger.info('No explicit browser executable configured. Falling back to Puppeteer-managed browser resolution.');
-        return undefined;
-    }
-    async close() {
-        await this.clearAllData();
-        this.explicitlyClosed = true;
-        this.activePageIndex = null;
-        const browser = this.browser;
-        const disconnectOnly = this.connectedToExistingBrowser;
-        const pid = this.chromePid;
-        this.browser = null;
-        this.currentHeadless = null;
-        this.connectedToExistingBrowser = false;
-        this.chromePid = null;
-        if (this.cdpSession) {
-            this.cdpSession = null;
-            this.cdpListeners = {};
-        }
-        if (browser) {
-            if (disconnectOnly) {
-                await browser.disconnect();
-            }
-            else {
-                await this.closeBrowserWithForceKill(browser, pid);
-            }
-        }
-        logger.info('Browser closed and all data cleared');
-    }
-    async closeBrowserWithForceKill(browser, pid) {
-        try {
-            await Promise.race([
-                browser.close(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('browser.close() timed out')), CodeCollector.BROWSER_CLOSE_TIMEOUT_MS)),
-            ]);
-        }
-        catch (error) {
-            logger.warn('browser.close() failed or timed out, attempting force-kill:', error);
-            CodeCollector.forceKillPid(pid);
-        }
-    }
-    static forceKillPid(pid) {
-        if (!pid)
-            return;
-        try {
-            process.kill(pid, 'SIGKILL');
-            logger.info(`Force-killed Chrome process PID ${pid}`);
-        }
-        catch (error) {
-            if (error.code !== 'ESRCH') {
-                logger.warn(`Failed to force-kill Chrome PID ${pid}:`, error);
-            }
-        }
-    }
-    getChromePid() {
-        return this.chromePid;
-    }
-    getPageTargets() {
-        if (!this.browser) {
-            return [];
-        }
-        return this.browser.targets().filter((target) => target.type() === 'page');
-    }
-    async resolvePageTargetHandle(target, timeoutMs = 5000) {
-        const page = await Promise.race([
-            target.page(),
-            new Promise((_, reject) => {
-                setTimeout(() => {
-                    reject(new PrerequisiteError(`Timed out after ${timeoutMs}ms while resolving a Puppeteer Page handle from the attached Chrome target.`));
-                }, timeoutMs);
-            }),
-        ]);
-        if (!page) {
-            throw new PrerequisiteError('Attached browser target does not expose a Puppeteer Page handle in the current Chrome remote debugging mode.');
-        }
-        return page;
-    }
-    isExistingBrowserConnection() {
-        return this.connectedToExistingBrowser;
-    }
-    async getActivePage() {
-        if (!this.browser) {
-            if (this.explicitlyClosed) {
-                throw new PrerequisiteError('Browser was explicitly closed. Call browser_launch or browser_attach first.');
-            }
-            try {
-                await this.init();
-            }
-            catch (error) {
-                throw new PrerequisiteError(`Browser not available: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        const pageTargets = this.getPageTargets();
-        if (pageTargets.length === 0) {
-            return await this.browser.newPage();
-        }
-        if (this.activePageIndex !== null && this.activePageIndex < pageTargets.length) {
-            return await this.resolvePageTargetHandle(pageTargets[this.activePageIndex]);
-        }
-        const lastTarget = pageTargets[pageTargets.length - 1];
-        if (!lastTarget) {
-            throw new Error('Failed to get active page');
-        }
-        return await this.resolvePageTargetHandle(lastTarget);
-    }
-    async listPages() {
-        if (!this.browser) {
-            return [];
-        }
-        const targets = this.getPageTargets();
-        return targets.map((target, index) => ({
-            index,
-            url: target.url(),
-            title: '',
-        }));
-    }
-    async listResolvedPages(timeoutMs = 1500) {
-        if (!this.browser) {
-            return [];
-        }
-        const targets = this.getPageTargets();
-        const pages = await Promise.all(targets.map(async (target, index) => {
-            try {
-                const page = await this.resolvePageTargetHandle(target, timeoutMs);
-                let title = '';
-                try {
-                    title = await Promise.race([
-                        page.title(),
-                        new Promise((resolve) => {
-                            setTimeout(() => resolve(''), timeoutMs);
-                        }),
-                    ]);
-                }
-                catch {
-                    title = '';
-                }
-                return {
-                    index,
-                    url: target.url(),
-                    title,
-                    page,
-                };
-            }
-            catch {
-                return null;
-            }
-        }));
-        return pages.filter((page) => page !== null);
-    }
-    async selectPage(index) {
-        if (!this.browser) {
-            throw new Error('Browser not connected');
-        }
-        const pages = await this.listPages();
-        if (index < 0 || index >= pages.length) {
-            throw new Error(`Page index ${index} out of range (0-${pages.length - 1})`);
-        }
-        this.activePageIndex = index;
-        logger.info(`Active page set to index ${index}: ${pages[index].url}`);
-    }
-    async createPage(url) {
-        if (!this.browser) {
-            await this.init();
-        }
-        const page = await this.browser.newPage();
-        await page.setUserAgent(this.userAgent);
-        await this.applyAntiDetection(page);
-        if (url) {
-            await page.goto(url, {
-                waitUntil: 'networkidle2',
-                timeout: this.config.timeout,
-            });
-        }
-        logger.info(`New page created${url ? `: ${url}` : ''}`);
-        return page;
-    }
-    async applyAntiDetection(page) {
-        await page.evaluateOnNewDocument(() => {
-            Object.defineProperty(navigator, 'webdriver', {
-                get: () => false,
-            });
-            Object.defineProperty(navigator, 'plugins', {
-                get: () => [1, 2, 3, 4, 5],
-            });
-            Object.defineProperty(navigator, 'languages', {
-                get: () => ['en-US', 'en'],
-            });
-            const win = window;
-            if (!win.chrome) {
-                win.chrome = {
-                    runtime: {},
-                    loadTimes: function () { },
-                    csi: function () { },
-                    app: {},
-                };
-            }
-            const originalQuery = window.navigator.permissions.query;
-            window.navigator.permissions.query = (parameters) => {
-                if (parameters.name === 'notifications') {
-                    return Promise.resolve({ state: 'denied' });
-                }
-                return originalQuery(parameters);
-            };
-        });
-    }
-    async getStatus() {
-        if (!this.browser) {
-            return {
-                running: false,
-                pagesCount: 0,
-            };
-        }
-        try {
-            const version = await this.browser.version();
-            const pages = this.getPageTargets();
-            return {
-                running: true,
-                pagesCount: pages.length,
-                version,
-                effectiveHeadless: this.currentHeadless ?? undefined,
-            };
-        }
-        catch (error) {
-            logger.debug('Browser not running or disconnected:', error);
-            return {
-                running: false,
-                pagesCount: 0,
-            };
-        }
-    }
-    async collect(options) {
-        while (this.collectLock) {
-            try {
-                await this.collectLock;
-            }
-            catch {
-            }
-        }
-        let resolve;
-        let reject;
-        this.collectLock = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        try {
-            const result = await this.collectInner(options);
-            resolve(result);
-            return result;
-        }
-        catch (e) {
-            reject(e);
-            throw e;
-        }
-        finally {
-            this.collectLock = null;
-        }
-    }
-    async collectInner(options) {
-        return collectInnerImpl(this, options);
-    }
-    shouldCollectUrl(url, filterRules) {
-        return shouldCollectUrlImpl(url, filterRules);
-    }
-    async navigateWithRetry(page, url, options, maxRetries = 3) {
-        return navigateWithRetryImpl(page, url, options, maxRetries);
-    }
-    async getPerformanceMetrics(page) {
-        return getPerformanceMetricsImpl(page);
-    }
-    async collectPageMetadata(page) {
-        return collectPageMetadataImpl(page);
-    }
-    resolveDefaultChromeUserDataDir(channel = 'stable') {
-        const home = homedir();
-        if (process.platform === 'win32') {
-            const localAppData = process.env.LOCALAPPDATA ?? join(home, 'AppData', 'Local');
-            switch (channel) {
-                case 'beta':
-                    return join(localAppData, 'Google', 'Chrome Beta', 'User Data');
-                case 'dev':
-                    return join(localAppData, 'Google', 'Chrome Dev', 'User Data');
-                case 'canary':
-                    return join(localAppData, 'Google', 'Chrome SxS', 'User Data');
-                case 'stable':
-                default:
-                    return join(localAppData, 'Google', 'Chrome', 'User Data');
-            }
-        }
-        if (process.platform === 'darwin') {
-            const appSupport = join(home, 'Library', 'Application Support');
-            switch (channel) {
-                case 'beta':
-                    return join(appSupport, 'Google', 'Chrome Beta');
-                case 'dev':
-                    return join(appSupport, 'Google', 'Chrome Dev');
-                case 'canary':
-                    return join(appSupport, 'Google', 'Chrome Canary');
-                case 'stable':
-                default:
-                    return join(appSupport, 'Google', 'Chrome');
-            }
-        }
-        const configHome = process.env.XDG_CONFIG_HOME ?? join(home, '.config');
-        switch (channel) {
-            case 'beta':
-                return join(configHome, 'google-chrome-beta');
-            case 'dev':
-                return join(configHome, 'google-chrome-unstable');
-            case 'canary':
-                return join(configHome, 'google-chrome-canary');
-            case 'stable':
-            default:
-                return join(configHome, 'google-chrome');
-        }
-    }
-    async resolveAutoConnectWsEndpoint(options) {
-        const channel = options.channel ?? 'stable';
-        const userDataDir = options.userDataDir ?? this.resolveDefaultChromeUserDataDir(channel);
-        const devToolsActivePortPath = join(userDataDir, 'DevToolsActivePort');
-        let fileContent;
-        try {
-            fileContent = await readFile(devToolsActivePortPath, 'utf8');
-        }
-        catch (error) {
-            throw new Error(`Could not read DevToolsActivePort from "${devToolsActivePortPath}". Check if Chrome is running from this profile and remote debugging is enabled at chrome://inspect/#remote-debugging.`, { cause: error });
-        }
-        const [rawPort, rawPath] = fileContent
-            .split(/\r?\n/u)
-            .map((line) => line.trim())
-            .filter(Boolean);
-        if (!rawPort || !rawPath) {
-            throw new Error(`Invalid DevToolsActivePort contents found in "${devToolsActivePortPath}".`);
-        }
-        const port = Number.parseInt(rawPort, 10);
-        if (!Number.isInteger(port) || port <= 0 || port > 65535) {
-            throw new Error(`Invalid remote debugging port "${rawPort}" in "${devToolsActivePortPath}".`);
-        }
-        return `ws://127.0.0.1:${port}${rawPath}`;
-    }
-    async resolveConnectOptions(endpointOrOptions) {
-        if (typeof endpointOrOptions === 'string') {
-            const endpoint = endpointOrOptions.trim();
-            if (!endpoint) {
-                throw new Error('Connection endpoint cannot be empty.');
-            }
-            return endpoint.startsWith('ws://') || endpoint.startsWith('wss://')
-                ? { browserWSEndpoint: endpoint }
-                : { browserURL: endpoint };
-        }
-        if (endpointOrOptions.wsEndpoint) {
-            return { browserWSEndpoint: endpointOrOptions.wsEndpoint };
-        }
-        if (endpointOrOptions.browserURL) {
-            return { browserURL: endpointOrOptions.browserURL };
-        }
-        if (endpointOrOptions.autoConnect ||
-            endpointOrOptions.userDataDir ||
-            endpointOrOptions.channel) {
-            return {
-                browserWSEndpoint: await this.resolveAutoConnectWsEndpoint(endpointOrOptions),
-            };
-        }
-        throw new Error('browserURL, wsEndpoint, autoConnect, userDataDir, or channel is required to connect to an existing browser.');
-    }
-    isAutoConnectRequest(endpointOrOptions) {
-        return (typeof endpointOrOptions !== 'string' &&
-            Boolean(endpointOrOptions.autoConnect || endpointOrOptions.userDataDir || endpointOrOptions.channel));
-    }
-    getUnknownErrorMessage(error) {
-        if (error instanceof Error) {
-            return error.message;
-        }
-        if (typeof error === 'object' && error !== null) {
-            const directMessage = 'message' in error && typeof error.message === 'string' ? error.message.trim() : '';
-            if (directMessage) {
-                return directMessage;
-            }
-            const nestedError = 'error' in error ? error.error : undefined;
-            if (nestedError instanceof Error && nestedError.message) {
-                return nestedError.message;
-            }
-            if (typeof nestedError === 'object' && nestedError !== null) {
-                const nestedMessage = 'message' in nestedError && typeof nestedError.message === 'string'
-                    ? nestedError.message.trim()
-                    : '';
-                if (nestedMessage) {
-                    return nestedMessage;
-                }
-            }
-            const serialized = JSON.stringify(error);
-            if (serialized && serialized !== '{}') {
-                return serialized;
-            }
-        }
-        return String(error);
-    }
-    normalizeConnectError(error, target, endpointOrOptions) {
-        const message = this.getUnknownErrorMessage(error);
-        if (this.isAutoConnectRequest(endpointOrOptions) && /ECONNREFUSED/i.test(message)) {
-            return new Error(`Failed to connect to existing browser: ${message}. ` +
-                `Chrome is not currently listening at ${target}. ` +
-                'DevToolsActivePort may be stale after a browser restart. ' +
-                'Re-open Chrome, confirm remote debugging is enabled at chrome://inspect/#remote-debugging, click Allow if prompted, and retry.');
-        }
-        return error instanceof Error
-            ? error
-            : new Error(`Failed to connect to existing browser: ${message}`);
-    }
-    buildConnectTimeoutError(target, endpointOrOptions) {
-        const baseMessage = `Timed out after ${this.CONNECT_TIMEOUT_MS}ms while connecting to existing browser: ${target}. ` +
-            'The CDP handshake did not complete in time.';
-        if (this.isAutoConnectRequest(endpointOrOptions)) {
-            return new Error(`${baseMessage} If Chrome prompted for remote debugging approval, click Allow in Chrome and then retry the tool call.`);
-        }
-        return new Error(`${baseMessage} Verify that the browser debugging endpoint is reachable and retry.`);
-    }
-    async connectWithTimeout(connectOptions, target, endpointOrOptions) {
-        const attemptId = ++this.connectAttemptId;
-        return await new Promise((resolve, reject) => {
-            let settled = false;
-            const timer = setTimeout(() => {
-                settled = true;
-                if (this.connectAttemptId === attemptId) {
-                    this.connectAttemptId += 1;
-                }
-                reject(this.buildConnectTimeoutError(target, endpointOrOptions));
-            }, this.CONNECT_TIMEOUT_MS);
-            void connect({ ...connectOptions, defaultViewport: null })
-                .then(async (browser) => {
-                if (settled || this.connectAttemptId !== attemptId) {
-                    try {
-                        await browser.disconnect();
-                    }
-                    catch {
-                    }
-                    return;
-                }
-                settled = true;
-                clearTimeout(timer);
-                resolve(browser);
-            })
-                .catch((error) => {
-                if (settled || this.connectAttemptId !== attemptId) {
-                    return;
-                }
-                settled = true;
-                clearTimeout(timer);
-                reject(this.normalizeConnectError(error, target, endpointOrOptions));
-            });
-        });
-    }
-    async connect(endpointOrOptions) {
-        this.explicitlyClosed = false;
-        if (this.browser) {
-            try {
-                await this.browser.disconnect();
-            }
-            catch {
-            }
-            this.browser = null;
-            this.currentHeadless = null;
-        }
-        this.activePageIndex = null;
-        const connectOptions = await this.resolveConnectOptions(endpointOrOptions);
-        const target = connectOptions.browserWSEndpoint ??
-            connectOptions.browserURL ??
-            'auto-detected Chrome debugging endpoint';
-        logger.info(`Connecting to existing browser: ${target}`);
-        this.browser = await this.connectWithTimeout(connectOptions, target, endpointOrOptions);
-        this.connectedToExistingBrowser = true;
-        this.browser.on('disconnected', () => {
-            logger.warn('Browser disconnected');
-            this.browser = null;
-            this.currentHeadless = null;
-            this.connectedToExistingBrowser = false;
-            if (this.cdpSession) {
-                this.cdpSession = null;
-                this.cdpListeners = {};
-            }
-        });
-        logger.success('Connected to existing browser successfully');
-    }
-    getBrowser() {
-        return this.browser;
-    }
-    getCollectionStats() {
-        return {
-            totalCollected: this.collectedUrls.size,
-            uniqueUrls: this.collectedUrls.size,
-        };
-    }
-    clearCache() {
-        this.collectedUrls.clear();
-        logger.info('Collection cache cleared');
-    }
-    getCollectedFilesSummary() {
-        const summaries = Array.from(this.collectedFilesCache.values()).map((file) => ({
-            url: file.url,
-            size: file.size,
-            type: file.type,
-            truncated: typeof file.metadata?.truncated === 'boolean' ? file.metadata.truncated : undefined,
-            originalSize: typeof file.metadata?.originalSize === 'number' ? file.metadata.originalSize : undefined,
-        }));
-        logger.info(`Returning summary of ${summaries.length} collected files`);
-        return summaries;
-    }
-    getFileByUrl(url) {
-        const file = this.collectedFilesCache.get(url);
-        if (file) {
-            logger.info(`Returning file: ${url} (${(file.size / 1024).toFixed(2)} KB)`);
-            return file;
-        }
-        logger.warn(`File not found: ${url}`);
-        return null;
-    }
-    getFilesByPattern(pattern, limit = 20, maxTotalSize = this.MAX_RESPONSE_SIZE) {
-        const regex = new RegExp(pattern);
-        const matched = [];
-        for (const file of this.collectedFilesCache.values()) {
-            if (regex.test(file.url)) {
-                matched.push(file);
-            }
-        }
-        const returned = [];
-        let totalSize = 0;
-        let truncated = false;
-        for (let i = 0; i < matched.length && i < limit; i++) {
-            const file = matched[i];
-            if (file && totalSize + file.size <= maxTotalSize) {
-                returned.push(file);
-                totalSize += file.size;
-            }
-            else {
-                truncated = true;
-                break;
-            }
-        }
-        if (truncated || matched.length > limit) {
-            logger.warn(`Pattern "${pattern}" matched ${matched.length} files, returning ${returned.length} (limited by size/count)`);
-        }
-        logger.info(` Pattern "${pattern}": matched ${matched.length}, returning ${returned.length} files (${(totalSize / 1024).toFixed(2)} KB)`);
-        return {
-            files: returned,
-            totalSize,
-            matched: matched.length,
-            returned: returned.length,
-            truncated,
-        };
-    }
-    getTopPriorityFiles(topN = 10, maxTotalSize = this.MAX_RESPONSE_SIZE) {
-        const allFiles = Array.from(this.collectedFilesCache.values());
-        const scoredFiles = allFiles.map((file) => ({
-            file,
-            score: calculatePriorityScore(file),
-        }));
-        scoredFiles.sort((a, b) => b.score - a.score);
-        const selected = [];
-        let totalSize = 0;
-        for (let i = 0; i < Math.min(topN, scoredFiles.length); i++) {
-            const item = scoredFiles[i];
-            if (item?.file && totalSize + item.file.size <= maxTotalSize) {
-                selected.push(item.file);
-                totalSize += item.file.size;
-            }
-            else {
-                break;
-            }
-        }
-        logger.info(`Returning top ${selected.length}/${allFiles.length} priority files (${(totalSize / 1024).toFixed(2)} KB)`);
-        return {
-            files: selected,
-            totalSize,
-            totalFiles: allFiles.length,
-        };
-    }
-    clearCollectedFilesCache() {
-        const count = this.collectedFilesCache.size;
-        this.collectedFilesCache.clear();
-        logger.info(`Cleared collected files cache (${count} files)`);
-    }
-}