@crawlith/core 0.1.0 → 0.1.2

package/dist/graph/pagerank.js

@@ -1,102 +1,137 @@
+import { DEFAULTS } from '../constants.js';
 /**
- * Production-Grade Weighted PageRank Engine
+ * Service to analyze a site's link graph and compute PageRank metrics.
+ * Runs only on the full crawl graph.
  */
-export function computePageRank(graph, options = {}) {
-    const d = options.dampingFactor ?? 0.85;
-    const maxIterations = options.maxIterations ?? 40;
-    const epsilon = options.convergenceThreshold ?? 1e-5;
-    const soft404Threshold = options.soft404WeightThreshold ?? 0.8;
-    const allNodes = graph.getNodes();
-    const allEdges = graph.getEdges();
-    // 1. Filter Eligible Nodes
-    const eligibleNodes = allNodes.filter(node => {
-        if (node.noindex)
-            return false;
-        if (node.isCollapsed)
-            return false;
-        if (node.soft404Score && node.soft404Score > soft404Threshold)
-            return false;
-        if (node.canonical && node.canonical !== node.url)
-            return false;
-        if (node.status >= 400)
-            return false; // Don't pass rank to broken pages
-        return true;
-    });
-    const nodeCount = eligibleNodes.length;
-    if (nodeCount === 0)
-        return;
-    const nodeUrls = eligibleNodes.map(n => n.url);
-    const nodeMap = new Map();
-    eligibleNodes.forEach(n => nodeMap.set(n.url, n));
-    // Initialize PageRank
-    let pr = new Map();
-    nodeUrls.forEach(url => pr.set(url, 1 / nodeCount));
-    // Pre-calculate weighted outbound sums and inverted adjacency
-    const outWeights = new Map();
-    const incoming = new Map();
-    const sinks = [];
-    // Initialize outWeights for all eligible nodes
-    nodeUrls.forEach(url => outWeights.set(url, 0));
-    for (const edge of allEdges) {
-        if (nodeMap.has(edge.source) && nodeMap.has(edge.target)) {
-            const weight = edge.weight || 1.0;
-            const sources = incoming.get(edge.target) ?? [];
-            sources.push({ source: edge.source, weight });
-            incoming.set(edge.target, sources);
-            outWeights.set(edge.source, (outWeights.get(edge.source) || 0) + weight);
-        }
-    }
-    // Identify sinks
-    nodeUrls.forEach(url => {
-        if ((outWeights.get(url) || 0) === 0) {
-            sinks.push(url);
+export class PageRankService {
+    /**
+     * Computes a Production-Grade Weighted PageRank over the given graph.
+     * @param {Graph} graph - The full site graph structure.
+     * @param {PageRankOptions} options - Configuration overrides for damping factor, limits, etc.
+     * @returns {Map<string, PageRankRow>} The individual metrics keyed by exact normalized url.
+     */
+    evaluate(graph, options = {}) {
+        const d = options.dampingFactor ?? 0.85;
+        const maxIterations = options.maxIterations ?? 40;
+        const epsilon = options.convergenceThreshold ?? 1e-5;
+        const soft404Threshold = options.soft404WeightThreshold ?? 0.8;
+        const neutralScoreWhenFlat = options.neutralScoreWhenFlat ?? 50;
+        const allNodes = graph.getNodes();
+        const allEdges = graph.getEdges();
+        // 1. Filter Eligible Nodes
+        const eligibleNodes = allNodes.filter(node => {
+            if (node.noindex)
+                return false;
+            if (node.isCollapsed)
+                return false;
+            // Keep compat with other plugins mutating soft404Score onto nodes
+            if (node.soft404Score && node.soft404Score > soft404Threshold)
+                return false;
+            // canonical is stored as absolute URL; extract pathname for path-based comparison
+            if (node.canonical) {
+                try {
+                    const canonicalPath = new URL(node.canonical).pathname;
+                    if (canonicalPath !== node.url)
+                        return false;
+                }
+                catch {
+                    // if canonical isn't a valid URL, compare as-is
+                    if (node.canonical !== node.url)
+                        return false;
+                }
+            }
+            if (node.status >= 400)
+                return false; // Don't pass rank to broken pages
+            if (node.status === 0)
+                return false; // Don't pass rank to uncrawled/external pages
+            return true;
+        });
+        const nodeCount = eligibleNodes.length;
+        const results = new Map();
+        if (nodeCount === 0)
+            return results;
+        // Map URL to Index for O(1) access and TypedArray usage
+        const urlToIndex = new Map();
+        for (let i = 0; i < nodeCount; i++) {
+            urlToIndex.set(eligibleNodes[i].url, i);
         }
-    });
-    // Iterative Calculation
-    for (let i = 0; i < maxIterations; i++) {
-        const nextPr = new Map();
-        // Calculate total rank from sinks to redistribute
-        let sinkRankTotal = 0;
-        for (const url of sinks) {
-            sinkRankTotal += pr.get(url) || 0;
+        // Pre-calculate weighted outbound sums and inverted adjacency
+        const outWeights = new Float64Array(nodeCount);
+        const incoming = new Array(nodeCount).fill(null).map(() => []);
+        for (const edge of allEdges) {
+            const sourceIndex = urlToIndex.get(edge.source);
+            const targetIndex = urlToIndex.get(edge.target);
+            if (sourceIndex !== undefined && targetIndex !== undefined) {
+                const weight = edge.weight || 1.0;
+                incoming[targetIndex].push({ sourceIndex, weight });
+                outWeights[sourceIndex] += weight;
+            }
         }
-        const baseRank = (1 - d) / nodeCount + (d * sinkRankTotal / nodeCount);
-        for (const url of nodeUrls) {
-            let rankFromLinks = 0;
-            const sources = incoming.get(url) || [];
-            for (const edge of sources) {
-                const sourceRank = pr.get(edge.source) || 0;
-                const sourceOutWeight = outWeights.get(edge.source) || 1.0;
-                rankFromLinks += sourceRank * (edge.weight / sourceOutWeight);
+        // Identify sinks
+        const sinks = [];
+        for (let i = 0; i < nodeCount; i++) {
+            if (outWeights[i] === 0) {
+                sinks.push(i);
             }
-            const newRank = baseRank + d * rankFromLinks;
-            nextPr.set(url, newRank);
         }
-        // Convergence check
-        let maxDelta = 0;
-        for (const url of nodeUrls) {
-            const delta = Math.abs(nextPr.get(url) - pr.get(url));
-            if (delta > maxDelta)
-                maxDelta = delta;
+        // Initialize PageRank typed arrays
+        let pr = new Float64Array(nodeCount).fill(1 / nodeCount);
+        let nextPr = new Float64Array(nodeCount);
+        // Iterative Calculation
+        for (let iter = 0; iter < maxIterations; iter++) {
+            // Calculate total rank from sinks to redistribute
+            let sinkRankTotal = 0;
+            for (let i = 0; i < sinks.length; i++) {
+                sinkRankTotal += pr[sinks[i]];
+            }
+            const baseRank = (1 - d) / nodeCount + (d * sinkRankTotal / nodeCount);
+            let maxDelta = 0;
+            for (let i = 0; i < nodeCount; i++) {
+                let rankFromLinks = 0;
+                const sources = incoming[i];
+                for (let j = 0; j < sources.length; j++) {
+                    const edge = sources[j];
+                    const sourceRank = pr[edge.sourceIndex];
+                    const sourceOutWeight = outWeights[edge.sourceIndex] || 1.0;
+                    rankFromLinks += sourceRank * (edge.weight / sourceOutWeight);
+                }
+                const newRank = baseRank + d * rankFromLinks;
+                nextPr[i] = newRank;
+                const delta = Math.abs(newRank - pr[i]);
+                if (delta > maxDelta) {
+                    maxDelta = delta;
+                }
+            }
+            // Swap arrays
+            const temp = pr;
+            pr = nextPr;
+            nextPr = temp;
+            if (maxDelta < epsilon)
+                break;
         }
-        pr = nextPr;
-        if (maxDelta < epsilon)
-            break;
-    }
-    // 2. Normalization (0-100)
-    const ranks = Array.from(pr.values());
-    const minPR = Math.min(...ranks);
-    const maxPR = Math.max(...ranks);
-    const range = maxPR - minPR;
-    for (const node of eligibleNodes) {
-        const rawRank = pr.get(node.url);
-        node.pageRank = rawRank;
-        if (range > 1e-12) {
-            node.pageRankScore = 100 * (rawRank - minPR) / range;
+        // 2. Normalization (0-100)
+        let minPR = pr[0];
+        let maxPR = pr[0];
+        for (let i = 1; i < nodeCount; i++) {
+            const rank = pr[i];
+            if (rank < minPR)
+                minPR = rank;
+            if (rank > maxPR)
+                maxPR = rank;
         }
-        else {
-            // If there's no range, all eligible pages are equally important.
-            node.pageRankScore = 100;
+        const range = maxPR - minPR;
+        for (let i = 0; i < nodeCount; i++) {
+            const rawRank = pr[i];
+            const url = eligibleNodes[i].url;
+            let score = neutralScoreWhenFlat;
+            if (range > DEFAULTS.GRAPH_PRECISION) {
+                score = 100 * (rawRank - minPR) / range;
+            }
+            results.set(url, {
+                raw_rank: rawRank,
+                score: Number(score.toFixed(3))
+            });
         }
+        return results;
     }
 }

package/dist/graph/simhash.d.ts

@@ -2,6 +2,8 @@ export declare class SimHash {
     private static FNV_PRIME;
     private static FNV_OFFSET_BASIS;
     private static MAX_UINT64;
+    static readonly BANDS = 4;
+    static readonly BAND_WIDTH = 16;
     /**
      * Generates a 64-bit FNV-1a hash for a given string token.
      */
@@ -10,6 +12,10 @@ export declare class SimHash {
      * Generates a 64-bit SimHash from an array of tokens.
      */
     static generate(tokens: string[]): bigint;
+    /**
+     * Splits a 64-bit SimHash into 4 bands of 16 bits.
+     */
+    static getBands(simhash: bigint): number[];
     /**
      * Computes the Hamming distance between two 64-bit hashes.
      */

package/dist/graph/simhash.js

@@ -2,6 +2,8 @@ export class SimHash {
     static FNV_PRIME = 1099511628211n;
     static FNV_OFFSET_BASIS = 14695981039346656037n;
     static MAX_UINT64 = 0xffffffffffffffffn;
+    static BANDS = 4;
+    static BAND_WIDTH = 16;
     /**
      * Generates a 64-bit FNV-1a hash for a given string token.
      */
@@ -40,6 +42,18 @@ export class SimHash {
         }
         return simhash;
     }
+    /**
+     * Splits a 64-bit SimHash into 4 bands of 16 bits.
+     */
+    static getBands(simhash) {
+        const bands = [];
+        for (let i = 0; i < SimHash.BANDS; i++) {
+            // Extract 16-bit chunks
+            const chunk = Number((simhash >> BigInt(i * SimHash.BAND_WIDTH)) & 0xffffn);
+            bands.push(chunk);
+        }
+        return bands;
+    }
     /**
      * Computes the Hamming distance between two 64-bit hashes.
      */

package/dist/index.d.ts

@@ -1,24 +1,35 @@
+export * from './scoring/health.js';
 export * from './crawler/crawl.js';
+export * from './crawler/normalize.js';
 export * from './crawler/metricsRunner.js';
+export * from './crawler/trap.js';
 export * from './graph/metrics.js';
-export * from './report/html.js';
-export * from './report/sitegraph_template.js';
-export * from './report/sitegraphExport.js';
 export * from './graph/graph.js';
-export * from './diff/compare.js';
-export * from './scoring/orphanSeverity.js';
+export * from './graph/simhash.js';
 export * from './graph/pagerank.js';
-export * from './graph/duplicate.js';
-export * from './graph/cluster.js';
-export * from './scoring/hits.js';
+export * from './graph/hits.js';
+export * from './diff/compare.js';
+export * from './diff/service.js';
 export * from './analysis/analyze.js';
 export * from './analysis/content.js';
 export * from './analysis/seo.js';
 export * from './analysis/images.js';
 export * from './analysis/links.js';
+export * from './analysis/scoring.js';
+export * from './analysis/clustering.js';
+export * from './analysis/duplicate.js';
+export * from './analysis/soft404.js';
+export * from './analysis/heading.js';
+export * from './analysis/orphan.js';
 export * from './audit/index.js';
 export * from './audit/types.js';
+export * from './report/html.js';
+export * from './report/crawl_template.js';
+export * from './report/crawlExport.js';
+export * from './report/export.js';
+export * from './report/insight.js';
 export * from './db/index.js';
+export * from './db/reset.js';
 export * from './db/graphLoader.js';
 export * from './db/repositories/SiteRepository.js';
 export * from './db/repositories/SnapshotRepository.js';
@@ -28,3 +39,13 @@ export * from './db/repositories/MetricsRepository.js';
 export * from './lock/lockManager.js';
 export * from './lock/hashKey.js';
 export * from './utils/version.js';
+export * from './utils/secureConfig.js';
+export * from './events.js';
+export * from './plugin-system/plugin-types.js';
+export * from './plugin-system/plugin-loader.js';
+export * from './plugin-system/plugin-registry.js';
+export * from './plugin-system/plugin-cli.js';
+export * from './ports/index.js';
+export * from './application/usecase.js';
+export * from './application/usecases.js';
+export { Command } from 'commander';

package/dist/index.js

@@ -1,24 +1,35 @@
+export * from './scoring/health.js';
 export * from './crawler/crawl.js';
+export * from './crawler/normalize.js';
 export * from './crawler/metricsRunner.js';
+export * from './crawler/trap.js';
 export * from './graph/metrics.js';
-export * from './report/html.js';
-export * from './report/sitegraph_template.js';
-export * from './report/sitegraphExport.js';
 export * from './graph/graph.js';
-export * from './diff/compare.js';
-export * from './scoring/orphanSeverity.js';
+export * from './graph/simhash.js';
 export * from './graph/pagerank.js';
-export * from './graph/duplicate.js';
-export * from './graph/cluster.js';
-export * from './scoring/hits.js';
+export * from './graph/hits.js';
+export * from './diff/compare.js';
+export * from './diff/service.js';
 export * from './analysis/analyze.js';
 export * from './analysis/content.js';
 export * from './analysis/seo.js';
 export * from './analysis/images.js';
 export * from './analysis/links.js';
+export * from './analysis/scoring.js';
+export * from './analysis/clustering.js';
+export * from './analysis/duplicate.js';
+export * from './analysis/soft404.js';
+export * from './analysis/heading.js';
+export * from './analysis/orphan.js';
 export * from './audit/index.js';
 export * from './audit/types.js';
+export * from './report/html.js';
+export * from './report/crawl_template.js';
+export * from './report/crawlExport.js';
+export * from './report/export.js';
+export * from './report/insight.js';
 export * from './db/index.js';
+export * from './db/reset.js';
 export * from './db/graphLoader.js';
 export * from './db/repositories/SiteRepository.js';
 export * from './db/repositories/SnapshotRepository.js';
@@ -28,3 +39,13 @@ export * from './db/repositories/MetricsRepository.js';
 export * from './lock/lockManager.js';
 export * from './lock/hashKey.js';
 export * from './utils/version.js';
+export * from './utils/secureConfig.js';
+export * from './events.js';
+export * from './plugin-system/plugin-types.js';
+export * from './plugin-system/plugin-loader.js';
+export * from './plugin-system/plugin-registry.js';
+export * from './plugin-system/plugin-cli.js';
+export * from './ports/index.js';
+export * from './application/usecase.js';
+export * from './application/usecases.js';
+export { Command } from 'commander';

package/dist/lock/hashKey.js

@@ -20,7 +20,7 @@ const RELEVANT_FLAGS = [
     'concurrency'
 ];
 export function generateLockKey(commandName, targetUrl, options) {
-    // Respect the query stripping option consistent with sitegraph logic
+    // Respect the query stripping option consistent with crawl logic
     const stripQuery = !options.query;
     const normalizedTarget = normalizeUrl(targetUrl, '', { stripQuery }) || targetUrl;
     // Extract relevant options in a deterministic order

package/dist/lock/lockManager.d.ts

@@ -1,7 +1,11 @@
+import { EngineContext } from '../events.js';
 export declare class LockManager {
     private static lockFilePath;
+    private static context;
     private static get lockDir();
-    static acquireLock(commandName: string, targetUrl: string, options: any, force?: boolean): Promise<void>;
+    static acquireLock(commandName: string, targetUrl: string, options: any, context?: EngineContext, force?: boolean): Promise<void>;
     static releaseLock(): void;
+    static clearAllLocks(): Promise<number>;
+    private static log;
     private static registerHandlers;
 }

package/dist/lock/lockManager.js

@@ -2,18 +2,18 @@ import fs from 'node:fs/promises';
 import { existsSync, unlinkSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import chalk from 'chalk';
 import { generateLockKey } from './hashKey.js';
 import { isPidAlive } from './pidCheck.js';
 export class LockManager {
     static lockFilePath = null;
+    static context = null;
     static get lockDir() {
         return path.join(os.homedir(), '.crawlith', 'locks');
     }
-    static async acquireLock(commandName, targetUrl, options, force = false) {
+    static async acquireLock(commandName, targetUrl, options, context, force = false) {
+        this.context = context || null;
         const lockHash = generateLockKey(commandName, targetUrl, options);
         // Ensure lock directory exists
-        // We can use sync or async here. Since this is one-time setup, async is fine.
         await fs.mkdir(this.lockDir, { recursive: true });
         const lockPath = path.join(this.lockDir, `${lockHash}.lock`);
         // Check existing lock
@@ -29,10 +29,10 @@ export class LockManager {
             catch (_e) {
                 // Corrupted -> Treat as stale
                 isStale = true;
-                pid = 0; // Fallback, though unused if isStale is true
+                pid = 0;
             }
             if (force) {
-                console.warn(chalk.yellow('Force mode enabled. Overriding existing lock.'));
+                this.log('warn', 'Force mode enabled. Overriding existing lock.');
                 try {
                     unlinkSync(lockPath);
                 }
@@ -40,11 +40,11 @@ export class LockManager {
             }
             else {
                 if (!isStale) {
-                    console.error(chalk.red(`Crawlith: command already running for ${targetUrl} (PID ${pid})`));
+                    this.log('error', `Crawlith: command already running for ${targetUrl} (PID ${pid})`);
                     process.exit(1);
                 }
                 else {
-                    console.log(chalk.gray('Detected stale lock. Continuing execution.'));
+                    this.log('info', 'Detected stale lock. Continuing execution.');
                     try {
                         unlinkSync(lockPath);
                     }
@@ -68,8 +68,7 @@ export class LockManager {
         }
         catch (error) {
             if (error.code === 'EEXIST') {
-                // Race condition: another process created lock between our check and open
-                console.error(chalk.red(`Crawlith: command already running for ${targetUrl} (Race condition)`));
+                this.log('error', `Crawlith: command already running for ${targetUrl} (Race condition)`);
                 process.exit(1);
             }
             throw error;
@@ -86,15 +85,41 @@ export class LockManager {
             }
         }
     }
+    static async clearAllLocks() {
+        if (!existsSync(this.lockDir))
+            return 0;
+        const files = await fs.readdir(this.lockDir);
+        const lockFiles = files.filter(f => f.endsWith('.lock'));
+        let count = 0;
+        for (const file of lockFiles) {
+            try {
+                await fs.unlink(path.join(this.lockDir, file));
+                count++;
+            }
+            catch { /* ignore */ }
+        }
+        return count;
+    }
+    static log(type, message, error) {
+        if (this.context) {
+            this.context.emit({ type, message, error });
+        }
+        else {
+            // Fallback for legacy usage or when no context provided
+            if (type === 'error')
+                console.error(message, error || '');
+            else if (type === 'warn')
+                console.warn(message);
+            else
+                console.log(message);
+        }
+    }
     static registerHandlers() {
         // Ensure cleanup only happens once
         const cleanup = () => {
             this.releaseLock();
         };
-        // process.on('exit') is only called when process.exit() is called or event loop empties.
-        // It requires synchronous cleanup.
         process.on('exit', cleanup);
-        // Signals
         process.on('SIGINT', () => {
             cleanup();
             process.exit(130);
@@ -104,7 +129,7 @@ export class LockManager {
             process.exit(143);
         });
         process.on('uncaughtException', (err) => {
-            console.error(chalk.red('Uncaught Exception:'), err);
+            this.log('error', 'Uncaught Exception', err);
             cleanup();
             process.exit(1);
         });

package/dist/plugin-system/plugin-cli.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+/**
+ * Standard utility for plugins to register their configuration commands.
+ * This ensures a consistent 'config <plugin> set' CLI pattern across the ecosystem.
+ *
+ * @param cli - The main Commander instance (must have name 'crawlith').
+ * @param pluginName - The unique name of the plugin (e.g., 'pagespeed').
+ * @param credentialLabel - Human-readable label for the credential (e.g., 'Google API Key').
+ */
+export declare function registerPluginConfigCommand(cli: Command, pluginName: string, credentialLabel: string): void;

package/dist/plugin-system/plugin-cli.js

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import { setEncryptedConfigKey } from '../utils/secureConfig.js';
+/**
+ * Standard utility for plugins to register their configuration commands.
+ * This ensures a consistent 'config <plugin> set' CLI pattern across the ecosystem.
+ *
+ * @param cli - The main Commander instance (must have name 'crawlith').
+ * @param pluginName - The unique name of the plugin (e.g., 'pagespeed').
+ * @param credentialLabel - Human-readable label for the credential (e.g., 'Google API Key').
+ */
+export function registerPluginConfigCommand(cli, pluginName, credentialLabel) {
+    // Only register subcommands if we are in the root 'crawlith' CLI context
+    if (cli.name() !== 'crawlith')
+        return;
+    // Find or create 'config' command
+    let configCmd = cli.commands.find(c => c.name() === 'config');
+    if (!configCmd) {
+        configCmd = new Command('config').description('Manage Crawlith plugin configuration');
+        cli.addCommand(configCmd);
+    }
+    // Define plugin-specific subcommand
+    const pluginConfigCmd = new Command(pluginName).description(`Manage ${pluginName} configuration`);
+    pluginConfigCmd
+        .command('set <value>')
+        .description(`Set and encrypt ${credentialLabel}`)
+        .action((value) => {
+        setEncryptedConfigKey(pluginName, value);
+        console.log(`✅ ${credentialLabel} for ${pluginName} saved and encrypted.`);
+    });
+    configCmd.addCommand(pluginConfigCmd);
+}

package/dist/plugin-system/plugin-config.d.ts

@@ -0,0 +1,16 @@
+export declare class PluginConfig {
+    private pluginName;
+    constructor(pluginName: string);
+    /**
+     * Get a decrypted config key for the current plugin.
+     */
+    get(keyName?: string): string;
+    /**
+     * Get a decrypted config key, or throw a user-friendly error if it's missing.
+     */
+    require(keyName?: string): string;
+    /**
+     * Set/Encrypt a config key for the current plugin.
+     */
+    set(value: string): void;
+}

package/dist/plugin-system/plugin-config.js

@@ -0,0 +1,36 @@
+import { getDecryptedConfigKey, setEncryptedConfigKey } from '../utils/secureConfig.js';
+export class PluginConfig {
+    pluginName;
+    constructor(pluginName) {
+        this.pluginName = pluginName;
+    }
+    /**
+     * Get a decrypted config key for the current plugin.
+     */
+    get(keyName) {
+        const section = keyName || this.pluginName;
+        // Safety check: ensure plugins can only access their own config section
+        if (section !== this.pluginName) {
+            throw new Error(`Security Violation: Plugin "${this.pluginName}" attempted to access config for "${section}"`);
+        }
+        return getDecryptedConfigKey(section);
+    }
+    /**
+     * Get a decrypted config key, or throw a user-friendly error if it's missing.
+     */
+    require(keyName) {
+        try {
+            return this.get(keyName);
+        }
+        catch (_error) {
+            const section = keyName || this.pluginName;
+            throw new Error(`Missing ${section} configuration. Please run: crawlith config ${section} set <value>`, { cause: _error });
+        }
+    }
+    /**
+     * Set/Encrypt a config key for the current plugin.
+     */
+    set(value) {
+        setEncryptedConfigKey(this.pluginName, value);
+    }
+}

package/dist/plugin-system/plugin-loader.d.ts

@@ -0,0 +1,17 @@
+import { CrawlithPlugin } from './plugin-types.js';
+export interface PluginLoaderLogger {
+    debug(msg: string): void;
+    info?(msg: string): void;
+    warn?(msg: string): void;
+    error?(msg: string): void;
+}
+export declare class PluginLoader {
+    private plugins;
+    private logger?;
+    constructor(logger?: PluginLoaderLogger);
+    discover(rootPath: string): Promise<CrawlithPlugin[]>;
+    private loadFromDir;
+    private loadFromNodeModules;
+    private tryLoadPlugin;
+    private validatePlugin;
+}