profclaw 0.0.1-beta.2 → 2.0.0

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

@@ -1,9 +0,0 @@
-/**
- * Brave Search Provider
- *
- * Privacy-focused search with independent index.
- * https://brave.com/search/api/
- */
-import type { SearchPluginDefinition } from '../types.js';
-export declare const BRAVE_DEFINITION: SearchPluginDefinition;
-//# sourceMappingURL=brave.d.ts.map

package/dist/plugins/search/brave.js

@@ -1,157 +0,0 @@
-/**
- * Brave Search Provider
- *
- * Privacy-focused search with independent index.
- * https://brave.com/search/api/
- */
-const BRAVE_API_URL = 'https://api.search.brave.com/res/v1/web/search';
-class BraveProvider {
-    metadata = BRAVE_DEFINITION.metadata;
-    apiKey;
-    safeSearch;
-    constructor(config) {
-        this.apiKey = config.credentials?.apiKey || '';
-        this.safeSearch = config.settings?.safeSearch || 'moderate';
-    }
-    async search(query, options) {
-        if (!this.apiKey) {
-            throw new Error('Brave Search API key not configured');
-        }
-        const startTime = Date.now();
-        const params = new URLSearchParams({
-            q: query,
-            count: String(options?.limit || 10),
-            safesearch: this.safeSearch,
-        });
-        if (options?.language)
-            params.set('search_lang', options.language);
-        if (options?.region)
-            params.set('country', options.region);
-        if (options?.freshness) {
-            const freshnessMap = {
-                day: 'pd',
-                week: 'pw',
-                month: 'pm',
-                year: 'py',
-            };
-            params.set('freshness', freshnessMap[options.freshness] || '');
-        }
-        const response = await fetch(`${BRAVE_API_URL}?${params}`, {
-            headers: {
-                'Accept': 'application/json',
-                'Accept-Encoding': 'gzip',
-                'X-Subscription-Token': this.apiKey,
-            },
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Brave Search API error: ${response.status} - ${error}`);
-        }
-        const data = await response.json();
-        const searchTime = Date.now() - startTime;
-        const results = (data.web?.results || []).map((item) => ({
-            title: item.title,
-            url: item.url,
-            snippet: item.description || '',
-            date: item.age,
-            source: 'brave',
-            favicon: item.profile?.img,
-            metadata: {
-                language: item.language,
-                familyFriendly: item.family_friendly,
-                extraSnippets: item.extra_snippets,
-            },
-        }));
-        return {
-            results,
-            query: data.query?.original || query,
-            totalResults: data.web?.total_results,
-            searchTime,
-            provider: 'brave',
-        };
-    }
-    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 BRAVE_DEFINITION = {
-    metadata: {
-        id: 'brave',
-        name: 'Brave Search',
-        description: 'Privacy-first search with independent index - great for enterprise',
-        category: 'search',
-        icon: 'shield-check',
-        version: '1.0.0',
-        homepage: 'https://brave.com/search/api/',
-        pricing: {
-            type: 'freemium',
-            costPer1k: 3.0,
-            freeQuota: 2000, // 2000 free queries/month
-        },
-        rateLimit: {
-            requestsPerSecond: 1, // Free tier
-            requestsPerMinute: 15, // Free tier
-        },
-    },
-    settingsSchema: {
-        credentials: [
-            {
-                key: 'apiKey',
-                type: 'password',
-                label: 'API Key',
-                description: 'Your Brave Search API key',
-                placeholder: 'BSA...',
-                required: true,
-            },
-        ],
-        settings: [
-            {
-                key: 'safeSearch',
-                type: 'select',
-                label: 'Safe Search',
-                description: 'Content filtering level',
-                default: 'moderate',
-                options: [
-                    { value: 'off', label: 'Off' },
-                    { value: 'moderate', label: 'Moderate' },
-                    { value: 'strict', label: 'Strict' },
-                ],
-            },
-            {
-                key: 'useGoggles',
-                type: 'boolean',
-                label: 'Use Goggles',
-                description: 'Enable custom result re-ranking with Brave Goggles',
-                default: false,
-            },
-        ],
-    },
-    factory: (config) => new BraveProvider(config),
-};
-//# sourceMappingURL=brave.js.map

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

@@ -1,9 +0,0 @@
-/**
- * DuckDuckGo Search Provider
- *
- * Free, privacy-focused search - great for fallback.
- * Note: Uses the instant answer API, not official search API.
- */
-import type { SearchPluginDefinition } from '../types.js';
-export declare const DUCKDUCKGO_DEFINITION: SearchPluginDefinition;
-//# sourceMappingURL=duckduckgo.d.ts.map

package/dist/plugins/search/duckduckgo.js

@@ -1,171 +0,0 @@
-/**
- * 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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,23 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1,170 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-/**
- * 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