profclaw 0.0.1-beta.1

package/dist/plugins/search/duckduckgo.js

@@ -0,0 +1,171 @@
+/**
+ * DuckDuckGo Search Provider
+ *
+ * Free, privacy-focused search - great for fallback.
+ * Note: Uses the instant answer API, not official search API.
+ */
+// DuckDuckGo HTML search endpoint (no official API)
+const DDG_SEARCH_URL = 'https://html.duckduckgo.com/html/';
+class DuckDuckGoProvider {
+    metadata = DUCKDUCKGO_DEFINITION.metadata;
+    safeSearch;
+    constructor(config) {
+        this.safeSearch = config.settings?.safeSearch ?? true;
+    }
+    async search(query, options) {
+        const startTime = Date.now();
+        const limit = options?.limit || 10;
+        // Use DuckDuckGo HTML endpoint with form data
+        const formData = new URLSearchParams();
+        formData.append('q', query);
+        formData.append('kl', options?.region || 'wt-wt'); // Region
+        if (this.safeSearch || options?.safeSearch) {
+            formData.append('kp', '1'); // Safe search on
+        }
+        const response = await fetch(DDG_SEARCH_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'User-Agent': 'profClaw/1.0',
+            },
+            body: formData.toString(),
+        });
+        if (!response.ok) {
+            throw new Error(`DuckDuckGo search failed: ${response.status}`);
+        }
+        const html = await response.text();
+        const results = this.parseResults(html, limit);
+        const searchTime = Date.now() - startTime;
+        return {
+            results,
+            query,
+            searchTime,
+            provider: 'duckduckgo',
+        };
+    }
+    parseResults(html, limit) {
+        const results = [];
+        // Simple regex parsing for DuckDuckGo HTML results
+        // Match result blocks
+        const resultRegex = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([^<]*)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>([^<]*)/g;
+        let match;
+        while ((match = resultRegex.exec(html)) !== null && results.length < limit) {
+            const [, url, title, snippet] = match;
+            if (url && title) {
+                // DuckDuckGo wraps URLs, extract the actual URL
+                const actualUrl = this.extractUrl(url);
+                results.push({
+                    title: this.decodeHtml(title.trim()),
+                    url: actualUrl,
+                    snippet: this.decodeHtml(snippet?.trim() || ''),
+                    source: 'duckduckgo',
+                });
+            }
+        }
+        // Fallback: Try simpler pattern if main regex didn't match
+        if (results.length === 0) {
+            const linkRegex = /<a[^>]*class="[^"]*result__url[^"]*"[^>]*href="([^"]*)"[^>]*>.*?<\/a>[\s\S]*?<h2[^>]*class="[^"]*result__title[^"]*"[^>]*>[\s\S]*?<a[^>]*>([^<]*)<\/a>/g;
+            while ((match = linkRegex.exec(html)) !== null && results.length < limit) {
+                const [, url, title] = match;
+                if (url && title) {
+                    results.push({
+                        title: this.decodeHtml(title.trim()),
+                        url: this.extractUrl(url),
+                        snippet: '',
+                        source: 'duckduckgo',
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    extractUrl(wrappedUrl) {
+        // DuckDuckGo wraps URLs like: //duckduckgo.com/l/?uddg=https%3A%2F%2Fexample.com
+        if (wrappedUrl.includes('uddg=')) {
+            const match = wrappedUrl.match(/uddg=([^&]*)/);
+            if (match) {
+                return decodeURIComponent(match[1]);
+            }
+        }
+        // Return as-is if not wrapped
+        return wrappedUrl.startsWith('//') ? `https:${wrappedUrl}` : wrappedUrl;
+    }
+    decodeHtml(text) {
+        return text
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'")
+            .replace(/<[^>]*>/g, ''); // Strip any remaining HTML tags
+    }
+    async isAvailable() {
+        // DuckDuckGo is always available (no API key needed)
+        return true;
+    }
+    async healthCheck() {
+        try {
+            const startTime = Date.now();
+            await this.search('test', { limit: 1 });
+            const latency = Date.now() - startTime;
+            return {
+                healthy: true,
+                lastCheck: new Date(),
+                latency,
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                lastCheck: new Date(),
+                errorMessage: error instanceof Error ? error.message : 'Health check failed',
+            };
+        }
+    }
+}
+export const DUCKDUCKGO_DEFINITION = {
+    metadata: {
+        id: 'duckduckgo',
+        name: 'DuckDuckGo',
+        description: 'Privacy-focused search - free, no API key required',
+        category: 'search',
+        icon: 'shield',
+        version: '1.0.0',
+        homepage: 'https://duckduckgo.com',
+        pricing: {
+            type: 'free',
+        },
+        rateLimit: {
+            requestsPerSecond: 1, // Be nice to DuckDuckGo
+            requestsPerMinute: 30,
+        },
+    },
+    settingsSchema: {
+        credentials: [], // No credentials needed
+        settings: [
+            {
+                key: 'safeSearch',
+                type: 'boolean',
+                label: 'Safe Search',
+                description: 'Filter explicit content from results',
+                default: true,
+            },
+            {
+                key: 'region',
+                type: 'select',
+                label: 'Region',
+                description: 'Search region preference',
+                default: 'wt-wt',
+                options: [
+                    { value: 'wt-wt', label: 'No region (worldwide)' },
+                    { value: 'us-en', label: 'United States' },
+                    { value: 'uk-en', label: 'United Kingdom' },
+                    { value: 'de-de', label: 'Germany' },
+                    { value: 'fr-fr', label: 'France' },
+                ],
+            },
+        ],
+    },
+    factory: (config) => new DuckDuckGoProvider(config),
+};
+//# sourceMappingURL=duckduckgo.js.map

package/dist/plugins/search/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Search Provider Plugins
+ *
+ * Export all built-in search provider definitions.
+ */
+export { SERPER_DEFINITION } from './serper.js';
+export { TAVILY_DEFINITION } from './tavily.js';
+export { BRAVE_DEFINITION } from './brave.js';
+export { DUCKDUCKGO_DEFINITION } from './duckduckgo.js';
+export { SEARXNG_DEFINITION } from './searxng.js';
+import type { SearchPluginDefinition } from '../types.js';
+export declare const ALL_SEARCH_PLUGINS: SearchPluginDefinition[];
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/search/index.js

@@ -0,0 +1,23 @@
+/**
+ * Search Provider Plugins
+ *
+ * Export all built-in search provider definitions.
+ */
+export { SERPER_DEFINITION } from './serper.js';
+export { TAVILY_DEFINITION } from './tavily.js';
+export { BRAVE_DEFINITION } from './brave.js';
+export { DUCKDUCKGO_DEFINITION } from './duckduckgo.js';
+export { SEARXNG_DEFINITION } from './searxng.js';
+import { SERPER_DEFINITION } from './serper.js';
+import { TAVILY_DEFINITION } from './tavily.js';
+import { BRAVE_DEFINITION } from './brave.js';
+import { DUCKDUCKGO_DEFINITION } from './duckduckgo.js';
+import { SEARXNG_DEFINITION } from './searxng.js';
+export const ALL_SEARCH_PLUGINS = [
+    SERPER_DEFINITION,
+    TAVILY_DEFINITION,
+    BRAVE_DEFINITION,
+    DUCKDUCKGO_DEFINITION,
+    SEARXNG_DEFINITION,
+];
+//# sourceMappingURL=index.js.map

package/dist/plugins/search/searxng.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SearXNG Search Provider
+ *
+ * Self-hosted metasearch engine - complete privacy control.
+ * https://docs.searxng.org/
+ */
+import type { SearchPluginDefinition } from '../types.js';
+export declare const SEARXNG_DEFINITION: SearchPluginDefinition;
+//# sourceMappingURL=searxng.d.ts.map

package/dist/plugins/search/searxng.js

@@ -0,0 +1,170 @@
+/**
+ * SearXNG Search Provider
+ *
+ * Self-hosted metasearch engine - complete privacy control.
+ * https://docs.searxng.org/
+ */
+class SearXNGProvider {
+    metadata = SEARXNG_DEFINITION.metadata;
+    baseUrl;
+    engines;
+    constructor(config) {
+        this.baseUrl = config.credentials?.baseUrl || 'http://localhost:8080';
+        this.engines = config.settings?.engines || [];
+    }
+    async search(query, options) {
+        if (!this.baseUrl) {
+            throw new Error('SearXNG base URL not configured');
+        }
+        const startTime = Date.now();
+        const params = new URLSearchParams({
+            q: query,
+            format: 'json',
+        });
+        if (options?.limit)
+            params.set('pageno', '1'); // SearXNG uses pagination
+        if (options?.language)
+            params.set('language', options.language);
+        if (options?.safeSearch)
+            params.set('safesearch', '2'); // 0=off, 1=moderate, 2=strict
+        if (this.engines.length > 0) {
+            params.set('engines', this.engines.join(','));
+        }
+        const url = `${this.baseUrl.replace(/\/$/, '')}/search?${params}`;
+        const response = await fetch(url, {
+            headers: {
+                'Accept': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`SearXNG error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const searchTime = Date.now() - startTime;
+        const limit = options?.limit || 10;
+        const results = (data.results || []).slice(0, limit).map((item) => ({
+            title: item.title,
+            url: item.url,
+            snippet: item.content || '',
+            source: 'searxng',
+            metadata: {
+                engine: item.engine,
+                engines: item.engines,
+                category: item.category,
+                score: item.score,
+                publishedDate: item.publishedDate,
+            },
+        }));
+        return {
+            results,
+            query: data.query || query,
+            totalResults: data.number_of_results,
+            searchTime,
+            provider: 'searxng',
+        };
+    }
+    async isAvailable() {
+        if (!this.baseUrl)
+            return false;
+        try {
+            const response = await fetch(`${this.baseUrl}/config`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async healthCheck() {
+        if (!this.baseUrl) {
+            return {
+                healthy: false,
+                lastCheck: new Date(),
+                errorMessage: 'Base URL not configured',
+            };
+        }
+        try {
+            const startTime = Date.now();
+            const response = await fetch(`${this.baseUrl}/config`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok) {
+                return {
+                    healthy: false,
+                    lastCheck: new Date(),
+                    errorMessage: `SearXNG returned ${response.status}`,
+                };
+            }
+            const latency = Date.now() - startTime;
+            return {
+                healthy: true,
+                lastCheck: new Date(),
+                latency,
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                lastCheck: new Date(),
+                errorMessage: error instanceof Error ? error.message : 'Connection failed',
+            };
+        }
+    }
+}
+export const SEARXNG_DEFINITION = {
+    metadata: {
+        id: 'searxng',
+        name: 'SearXNG',
+        description: 'Self-hosted metasearch - 246+ sources, complete privacy',
+        category: 'search',
+        icon: 'server',
+        version: '1.0.0',
+        homepage: 'https://docs.searxng.org/',
+        pricing: {
+            type: 'free',
+        },
+        rateLimit: {
+            requestsPerSecond: 10, // Depends on your instance
+        },
+    },
+    settingsSchema: {
+        credentials: [
+            {
+                key: 'baseUrl',
+                type: 'url',
+                label: 'Instance URL',
+                description: 'URL of your SearXNG instance (e.g., http://localhost:8080)',
+                placeholder: 'http://localhost:8080',
+                required: true,
+            },
+        ],
+        settings: [
+            {
+                key: 'engines',
+                type: 'text',
+                label: 'Engines',
+                description: 'Comma-separated list of engines to use (leave empty for all)',
+                placeholder: 'google,duckduckgo,bing',
+            },
+            {
+                key: 'safeSearch',
+                type: 'boolean',
+                label: 'Safe Search',
+                description: 'Enable strict safe search filtering',
+                default: true,
+            },
+            {
+                key: 'timeout',
+                type: 'number',
+                label: 'Timeout (seconds)',
+                description: 'Request timeout in seconds',
+                default: 10,
+                validation: { min: 1, max: 60 },
+            },
+        ],
+    },
+    factory: (config) => new SearXNGProvider(config),
+};
+//# sourceMappingURL=searxng.js.map

package/dist/plugins/search/serper.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Serper Search Provider
+ *
+ * Fast and cost-effective Google Search API.
+ * https://serper.dev/
+ */
+import type { SearchPluginDefinition } from '../types.js';
+export declare const SERPER_DEFINITION: SearchPluginDefinition;
+//# sourceMappingURL=serper.d.ts.map

package/dist/plugins/search/serper.js

@@ -0,0 +1,135 @@
+/**
+ * Serper Search Provider
+ *
+ * Fast and cost-effective Google Search API.
+ * https://serper.dev/
+ */
+const SERPER_API_URL = 'https://google.serper.dev/search';
+class SerperProvider {
+    metadata = SERPER_DEFINITION.metadata;
+    apiKey;
+    baseUrl;
+    constructor(config) {
+        this.apiKey = config.credentials?.apiKey || '';
+        this.baseUrl = config.credentials?.baseUrl || SERPER_API_URL;
+    }
+    async search(query, options) {
+        if (!this.apiKey) {
+            throw new Error('Serper API key not configured');
+        }
+        const startTime = Date.now();
+        const body = {
+            q: query,
+            num: options?.limit || 10,
+        };
+        if (options?.language)
+            body.hl = options.language;
+        if (options?.region)
+            body.gl = options.region;
+        const response = await fetch(this.baseUrl, {
+            method: 'POST',
+            headers: {
+                'X-API-KEY': this.apiKey,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Serper API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const searchTime = Date.now() - startTime;
+        const results = (data.organic || []).map((item) => ({
+            title: item.title,
+            url: item.link,
+            snippet: item.snippet || '',
+            date: item.date,
+            source: 'serper',
+            metadata: {
+                position: item.position,
+                sitelinks: item.sitelinks,
+            },
+        }));
+        return {
+            results,
+            query,
+            totalResults: data.searchParameters?.totalResults,
+            searchTime,
+            provider: 'serper',
+        };
+    }
+    async isAvailable() {
+        return !!this.apiKey;
+    }
+    async healthCheck() {
+        if (!this.apiKey) {
+            return {
+                healthy: false,
+                lastCheck: new Date(),
+                errorMessage: 'API key not configured',
+            };
+        }
+        try {
+            const startTime = Date.now();
+            await this.search('test', { limit: 1 });
+            const latency = Date.now() - startTime;
+            return {
+                healthy: true,
+                lastCheck: new Date(),
+                latency,
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                lastCheck: new Date(),
+                errorMessage: error instanceof Error ? error.message : 'Health check failed',
+            };
+        }
+    }
+}
+// Plugin Definition
+export const SERPER_DEFINITION = {
+    metadata: {
+        id: 'serper',
+        name: 'Serper',
+        description: 'Fast Google Search API - cost-effective at scale',
+        category: 'search',
+        icon: 'search',
+        version: '1.0.0',
+        homepage: 'https://serper.dev',
+        pricing: {
+            type: 'paid',
+            costPer1k: 1.0, // $1 per 1000 queries at starter tier
+            freeQuota: 100, // 100 free queries
+        },
+        rateLimit: {
+            requestsPerSecond: 300,
+        },
+    },
+    settingsSchema: {
+        credentials: [
+            {
+                key: 'apiKey',
+                type: 'password',
+                label: 'API Key',
+                description: 'Your Serper API key from serper.dev',
+                placeholder: 'Enter your Serper API key',
+                required: true,
+            },
+        ],
+        settings: [
+            {
+                key: 'defaultLimit',
+                type: 'number',
+                label: 'Default Results',
+                description: 'Default number of results to return',
+                default: 10,
+                validation: { min: 1, max: 100 },
+            },
+        ],
+    },
+    factory: (config) => new SerperProvider(config),
+};
+//# sourceMappingURL=serper.js.map

package/dist/plugins/search/tavily.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Tavily Search Provider
+ *
+ * AI-optimized search API with safety filtering.
+ * https://tavily.com/
+ */
+import type { SearchPluginDefinition } from '../types.js';
+export declare const TAVILY_DEFINITION: SearchPluginDefinition;
+//# sourceMappingURL=tavily.d.ts.map

package/dist/plugins/search/tavily.js

@@ -0,0 +1,146 @@
+/**
+ * Tavily Search Provider
+ *
+ * AI-optimized search API with safety filtering.
+ * https://tavily.com/
+ */
+const TAVILY_API_URL = 'https://api.tavily.com/search';
+class TavilyProvider {
+    metadata = TAVILY_DEFINITION.metadata;
+    apiKey;
+    includeRawContent;
+    constructor(config) {
+        this.apiKey = config.credentials?.apiKey || '';
+        this.includeRawContent = config.settings?.includeRawContent || false;
+    }
+    async search(query, options) {
+        if (!this.apiKey) {
+            throw new Error('Tavily API key not configured');
+        }
+        const startTime = Date.now();
+        const body = {
+            api_key: this.apiKey,
+            query,
+            max_results: options?.limit || 10,
+            include_raw_content: this.includeRawContent,
+            include_images: options?.includeImages || false,
+        };
+        if (options?.includeDomains?.length) {
+            body.include_domains = options.includeDomains;
+        }
+        if (options?.excludeDomains?.length) {
+            body.exclude_domains = options.excludeDomains;
+        }
+        const response = await fetch(TAVILY_API_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Tavily API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const searchTime = Date.now() - startTime;
+        const results = (data.results || []).map((item) => ({
+            title: item.title,
+            url: item.url,
+            snippet: item.content || '',
+            source: 'tavily',
+            score: item.score,
+            metadata: {
+                rawContent: item.raw_content,
+            },
+        }));
+        return {
+            results,
+            query: data.query,
+            searchTime,
+            provider: 'tavily',
+        };
+    }
+    async isAvailable() {
+        return !!this.apiKey;
+    }
+    async healthCheck() {
+        if (!this.apiKey) {
+            return {
+                healthy: false,
+                lastCheck: new Date(),
+                errorMessage: 'API key not configured',
+            };
+        }
+        try {
+            const startTime = Date.now();
+            await this.search('test', { limit: 1 });
+            const latency = Date.now() - startTime;
+            return {
+                healthy: true,
+                lastCheck: new Date(),
+                latency,
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                lastCheck: new Date(),
+                errorMessage: error instanceof Error ? error.message : 'Health check failed',
+            };
+        }
+    }
+}
+export const TAVILY_DEFINITION = {
+    metadata: {
+        id: 'tavily',
+        name: 'Tavily',
+        description: 'AI-optimized search with safety filtering - built for agents',
+        category: 'search',
+        icon: 'brain',
+        version: '1.0.0',
+        homepage: 'https://tavily.com',
+        pricing: {
+            type: 'credit-based',
+            costPer1k: 8.0, // ~$0.008 per credit, 1 credit per search
+            freeQuota: 1000,
+        },
+        rateLimit: {
+            requestsPerMinute: 60,
+        },
+    },
+    settingsSchema: {
+        credentials: [
+            {
+                key: 'apiKey',
+                type: 'password',
+                label: 'API Key',
+                description: 'Your Tavily API key',
+                placeholder: 'tvly-...',
+                required: true,
+            },
+        ],
+        settings: [
+            {
+                key: 'includeRawContent',
+                type: 'boolean',
+                label: 'Include Raw Content',
+                description: 'Include full page content in results (uses more credits)',
+                default: false,
+            },
+            {
+                key: 'searchDepth',
+                type: 'select',
+                label: 'Search Depth',
+                description: 'Basic is faster, Advanced is more thorough',
+                default: 'basic',
+                options: [
+                    { value: 'basic', label: 'Basic (1 credit)' },
+                    { value: 'advanced', label: 'Advanced (2 credits)' },
+                ],
+            },
+        ],
+    },
+    factory: (config) => new TavilyProvider(config),
+};
+//# sourceMappingURL=tavily.js.map