opc-agent 3.0.1 → 4.0.1

package/dist/tools/image-generator.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Image Generator — multi-backend image generation tool.
+ * Supports DALL·E (OpenAI), Stable Diffusion (local), and Replicate.
+ */
+export interface ImageGenConfig {
+    provider?: 'dalle' | 'stable-diffusion' | 'replicate';
+    openaiApiKey?: string;
+    replicateApiKey?: string;
+    sdApiUrl?: string;
+    defaultModel?: string;
+    defaultSize?: string;
+}
+export interface ImageGenResult {
+    success: boolean;
+    url?: string;
+    base64?: string;
+    error?: string;
+    provider: string;
+}
+export declare class ImageGenerator {
+    private config;
+    constructor(config?: ImageGenConfig);
+    /** Auto-detect best available provider */
+    detectProvider(): string | null;
+    /** Get configuration status for the settings UI */
+    getStatus(): {
+        configured: boolean;
+        providers: {
+            name: string;
+            configured: boolean;
+        }[];
+    };
+    generate(prompt: string, options?: {
+        provider?: string;
+        size?: string;
+        model?: string;
+    }): Promise<ImageGenResult>;
+    private generateDalle;
+    private generateSD;
+    private generateReplicate;
+}
+//# sourceMappingURL=image-generator.d.ts.map

package/dist/tools/image-generator.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Image Generator — multi-backend image generation tool.
+ * Supports DALL·E (OpenAI), Stable Diffusion (local), and Replicate.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageGenerator = void 0;
+class ImageGenerator {
+    config;
+    constructor(config) {
+        this.config = {
+            provider: config?.provider,
+            openaiApiKey: config?.openaiApiKey || process.env.OPENAI_API_KEY,
+            replicateApiKey: config?.replicateApiKey || process.env.REPLICATE_API_TOKEN,
+            sdApiUrl: config?.sdApiUrl || process.env.SD_API_URL,
+            defaultModel: config?.defaultModel || 'dall-e-3',
+            defaultSize: config?.defaultSize || '1024x1024',
+        };
+    }
+    /** Auto-detect best available provider */
+    detectProvider() {
+        if (this.config.openaiApiKey)
+            return 'dalle';
+        if (this.config.sdApiUrl)
+            return 'stable-diffusion';
+        if (this.config.replicateApiKey)
+            return 'replicate';
+        return null;
+    }
+    /** Get configuration status for the settings UI */
+    getStatus() {
+        return {
+            configured: !!this.detectProvider(),
+            providers: [
+                { name: 'dalle', configured: !!this.config.openaiApiKey },
+                { name: 'stable-diffusion', configured: !!this.config.sdApiUrl },
+                { name: 'replicate', configured: !!this.config.replicateApiKey },
+            ],
+        };
+    }
+    async generate(prompt, options) {
+        const provider = options?.provider || this.config.provider || this.detectProvider();
+        if (!provider) {
+            return { success: false, error: 'No image generation provider configured. Please set OPENAI_API_KEY, SD_API_URL, or REPLICATE_API_TOKEN.', provider: 'none' };
+        }
+        switch (provider) {
+            case 'dalle': return this.generateDalle(prompt, options);
+            case 'stable-diffusion': return this.generateSD(prompt, options);
+            case 'replicate': return this.generateReplicate(prompt, options);
+            default: return { success: false, error: `Unknown provider: ${provider}`, provider };
+        }
+    }
+    async generateDalle(prompt, options) {
+        const apiKey = this.config.openaiApiKey;
+        if (!apiKey)
+            return { success: false, error: 'OPENAI_API_KEY not configured', provider: 'dalle' };
+        try {
+            const res = await fetch('https://api.openai.com/v1/images/generations', {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: options?.model || this.config.defaultModel || 'dall-e-3',
+                    prompt,
+                    size: options?.size || this.config.defaultSize || '1024x1024',
+                    n: 1,
+                }),
+            });
+            const data = await res.json();
+            if (data.error)
+                return { success: false, error: data.error.message, provider: 'dalle' };
+            const url = data.data?.[0]?.url;
+            return url ? { success: true, url, provider: 'dalle' } : { success: false, error: 'No image returned', provider: 'dalle' };
+        }
+        catch (err) {
+            return { success: false, error: err.message, provider: 'dalle' };
+        }
+    }
+    async generateSD(prompt, options) {
+        const apiUrl = this.config.sdApiUrl;
+        if (!apiUrl)
+            return { success: false, error: 'SD_API_URL not configured', provider: 'stable-diffusion' };
+        try {
+            const [w, h] = (options?.size || '1024x1024').split('x').map(Number);
+            const res = await fetch(`${apiUrl}/sdapi/v1/txt2img`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ prompt, width: w || 1024, height: h || 1024 }),
+            });
+            const data = await res.json();
+            if (data.images?.length) {
+                return { success: true, base64: data.images[0], provider: 'stable-diffusion' };
+            }
+            return { success: false, error: 'No image generated', provider: 'stable-diffusion' };
+        }
+        catch (err) {
+            return { success: false, error: err.message, provider: 'stable-diffusion' };
+        }
+    }
+    async generateReplicate(prompt, _options) {
+        const apiKey = this.config.replicateApiKey;
+        if (!apiKey)
+            return { success: false, error: 'REPLICATE_API_TOKEN not configured', provider: 'replicate' };
+        try {
+            const res = await fetch('https://api.replicate.com/v1/predictions', {
+                method: 'POST',
+                headers: { 'Authorization': `Token ${apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    version: 'stability-ai/sdxl:39ed52f2a78e934b3ba6e2a89f5b1c712de7dfea535525255b1aa35c5565e08b',
+                    input: { prompt },
+                }),
+            });
+            const prediction = await res.json();
+            if (prediction.error)
+                return { success: false, error: prediction.error, provider: 'replicate' };
+            // Poll for completion (max 60s)
+            const getUrl = prediction.urls?.get || `https://api.replicate.com/v1/predictions/${prediction.id}`;
+            for (let i = 0; i < 30; i++) {
+                await new Promise(r => setTimeout(r, 2000));
+                const poll = await fetch(getUrl, { headers: { 'Authorization': `Token ${apiKey}` } });
+                const result = await poll.json();
+                if (result.status === 'succeeded' && result.output?.length) {
+                    return { success: true, url: result.output[0], provider: 'replicate' };
+                }
+                if (result.status === 'failed') {
+                    return { success: false, error: result.error || 'Generation failed', provider: 'replicate' };
+                }
+            }
+            return { success: false, error: 'Timeout waiting for image generation', provider: 'replicate' };
+        }
+        catch (err) {
+            return { success: false, error: err.message, provider: 'replicate' };
+        }
+    }
+}
+exports.ImageGenerator = ImageGenerator;
+//# sourceMappingURL=image-generator.js.map

package/dist/tools/web-scraper.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Web Scraper - v0.10.0
+ * Fetch URL content and extract readable text in markdown format.
+ * Uses a simple readability-style extraction (no external dependencies).
+ */
+export interface ScrapedContent {
+    title: string;
+    content: string;
+    url: string;
+    wordCount: number;
+}
+/**
+ * Fetch a URL and extract readable content as markdown.
+ */
+export declare function scrapeUrl(url: string, maxLength?: number): Promise<ScrapedContent>;
+/**
+ * Extract readable content from HTML using simple heuristics.
+ */
+export declare function extractReadableContent(html: string, url: string, maxLength?: number): ScrapedContent;
+//# sourceMappingURL=web-scraper.d.ts.map

package/dist/tools/web-scraper.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Web Scraper - v0.10.0
+ * Fetch URL content and extract readable text in markdown format.
+ * Uses a simple readability-style extraction (no external dependencies).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scrapeUrl = scrapeUrl;
+exports.extractReadableContent = extractReadableContent;
+const MAX_CONTENT_LENGTH = 5000;
+/**
+ * Fetch a URL and extract readable content as markdown.
+ */
+async function scrapeUrl(url, maxLength = MAX_CONTENT_LENGTH) {
+    const response = await fetch(url, {
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+            Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        },
+        signal: AbortSignal.timeout(15000),
+        redirect: 'follow',
+    });
+    const contentType = response.headers.get('content-type') || '';
+    const text = await response.text();
+    // If not HTML, return raw text
+    if (!contentType.includes('html')) {
+        const truncated = text.slice(0, maxLength);
+        return {
+            title: url,
+            content: truncated,
+            url,
+            wordCount: truncated.split(/\s+/).length,
+        };
+    }
+    return extractReadableContent(text, url, maxLength);
+}
+/**
+ * Extract readable content from HTML using simple heuristics.
+ */
+function extractReadableContent(html, url, maxLength = MAX_CONTENT_LENGTH) {
+    // Extract title
+    const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    const title = titleMatch ? decodeEntities(titleMatch[1]).trim() : url;
+    // Remove non-content elements
+    let content = html;
+    // Remove script, style, nav, header, footer, aside, iframe
+    const removePatterns = [
+        /<script[\s\S]*?<\/script>/gi,
+        /<style[\s\S]*?<\/style>/gi,
+        /<nav[\s\S]*?<\/nav>/gi,
+        /<footer[\s\S]*?<\/footer>/gi,
+        /<aside[\s\S]*?<\/aside>/gi,
+        /<iframe[\s\S]*?<\/iframe>/gi,
+        /<noscript[\s\S]*?<\/noscript>/gi,
+        /<!--[\s\S]*?-->/g,
+    ];
+    for (const pattern of removePatterns) {
+        content = content.replace(pattern, '');
+    }
+    // Try to find main content area
+    const mainContent = findMainContent(content);
+    content = mainContent || content;
+    // Convert to markdown-ish text
+    content = htmlToMarkdown(content);
+    // Clean up whitespace
+    content = content
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/[ \t]+/g, ' ')
+        .trim();
+    // Truncate
+    if (content.length > maxLength) {
+        content = content.slice(0, maxLength) + '\n\n...[truncated]';
+    }
+    return {
+        title,
+        content,
+        url,
+        wordCount: content.split(/\s+/).filter(Boolean).length,
+    };
+}
+/**
+ * Try to find the main content area of the page.
+ */
+function findMainContent(html) {
+    // Try common content selectors
+    const patterns = [
+        /<article[^>]*>([\s\S]*?)<\/article>/i,
+        /<main[^>]*>([\s\S]*?)<\/main>/i,
+        /<div[^>]*class="[^"]*(?:content|article|post|entry|main)[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+        /<div[^>]*id="[^"]*(?:content|article|post|entry|main)[^"]*"[^>]*>([\s\S]*?)<\/div>/i,
+    ];
+    for (const pattern of patterns) {
+        const match = html.match(pattern);
+        if (match && match[1] && match[1].length > 200) {
+            return match[1];
+        }
+    }
+    // Fallback: find body content
+    const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+    return bodyMatch ? bodyMatch[1] : null;
+}
+/**
+ * Simple HTML to Markdown conversion.
+ */
+function htmlToMarkdown(html) {
+    let md = html;
+    // Headers
+    md = md.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, '\n# $1\n');
+    md = md.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, '\n## $1\n');
+    md = md.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, '\n### $1\n');
+    md = md.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, '\n#### $1\n');
+    md = md.replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, '\n##### $1\n');
+    md = md.replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, '\n###### $1\n');
+    // Paragraphs and line breaks
+    md = md.replace(/<p[^>]*>/gi, '\n');
+    md = md.replace(/<\/p>/gi, '\n');
+    md = md.replace(/<br\s*\/?>/gi, '\n');
+    // Links
+    md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, '[$2]($1)');
+    // Bold and italic
+    md = md.replace(/<(?:strong|b)[^>]*>([\s\S]*?)<\/(?:strong|b)>/gi, '**$1**');
+    md = md.replace(/<(?:em|i)[^>]*>([\s\S]*?)<\/(?:em|i)>/gi, '*$1*');
+    // Code
+    md = md.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, '`$1`');
+    md = md.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, '\n```\n$1\n```\n');
+    // Lists
+    md = md.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, '- $1\n');
+    // Blockquote
+    md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, '\n> $1\n');
+    // Remove remaining HTML tags
+    md = md.replace(/<[^>]+>/g, '');
+    // Decode entities
+    md = decodeEntities(md);
+    return md;
+}
+function decodeEntities(text) {
+    return text
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;/g, "'")
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&#(\d+);/g, (_, n) => String.fromCharCode(parseInt(n)))
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, n) => String.fromCharCode(parseInt(n, 16)));
+}
+//# sourceMappingURL=web-scraper.js.map

package/dist/tools/web-search.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Web Search Engine Manager - v0.10.0
+ * Supports multiple search backends with automatic fallback.
+ * Default: DuckDuckGo (free, no API key required).
+ */
+export interface SearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+}
+export interface SearchOptions {
+    maxResults?: number;
+    engine?: SearchEngine;
+}
+export type SearchEngine = 'duckduckgo' | 'brave' | 'searxng' | 'google';
+export interface SearchEngineConfig {
+    enabled: boolean;
+    apiKey?: string;
+    baseUrl?: string;
+}
+export interface WebSearchConfig {
+    defaultEngine: SearchEngine;
+    enabled: boolean;
+    engines: Partial<Record<SearchEngine, SearchEngineConfig>>;
+}
+export declare const DEFAULT_SEARCH_CONFIG: WebSearchConfig;
+/**
+ * Parse DuckDuckGo HTML search results.
+ */
+export declare function parseDuckDuckGoHTML(html: string): SearchResult[];
+/**
+ * Search using DuckDuckGo HTML interface (no API key needed).
+ */
+export declare function searchDuckDuckGo(query: string, maxResults?: number): Promise<SearchResult[]>;
+/**
+ * Search using Brave Search API.
+ */
+export declare function searchBrave(query: string, apiKey: string, maxResults?: number): Promise<SearchResult[]>;
+/**
+ * Search using SearXNG instance.
+ */
+export declare function searchSearXNG(query: string, baseUrl: string, maxResults?: number): Promise<SearchResult[]>;
+/**
+ * Search using Google Custom Search API.
+ */
+export declare function searchGoogle(query: string, apiKey: string, maxResults?: number): Promise<SearchResult[]>;
+/**
+ * Unified search function with fallback.
+ */
+export declare function webSearch(query: string, config?: WebSearchConfig, options?: SearchOptions): Promise<SearchResult[]>;
+//# sourceMappingURL=web-search.d.ts.map

package/dist/tools/web-search.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Web Search Engine Manager - v0.10.0
+ * Supports multiple search backends with automatic fallback.
+ * Default: DuckDuckGo (free, no API key required).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SEARCH_CONFIG = void 0;
+exports.parseDuckDuckGoHTML = parseDuckDuckGoHTML;
+exports.searchDuckDuckGo = searchDuckDuckGo;
+exports.searchBrave = searchBrave;
+exports.searchSearXNG = searchSearXNG;
+exports.searchGoogle = searchGoogle;
+exports.webSearch = webSearch;
+exports.DEFAULT_SEARCH_CONFIG = {
+    defaultEngine: 'duckduckgo',
+    enabled: true,
+    engines: {
+        duckduckgo: { enabled: true },
+    },
+};
+/**
+ * Parse DuckDuckGo HTML search results.
+ */
+function parseDuckDuckGoHTML(html) {
+    const results = [];
+    // Match result blocks: <a class="result__a" href="...">title</a> ... <a class="result__snippet">snippet</a>
+    const resultBlocks = html.split(/class="result__body"/);
+    for (let i = 1; i < resultBlocks.length && results.length < 10; i++) {
+        const block = resultBlocks[i];
+        // Extract URL and title from result__a
+        const linkMatch = block.match(/class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/);
+        if (!linkMatch)
+            continue;
+        let url = linkMatch[1];
+        const title = stripHTML(linkMatch[2]).trim();
+        // DuckDuckGo wraps URLs in redirect, extract actual URL
+        const uddgMatch = url.match(/[?&]uddg=([^&]+)/);
+        if (uddgMatch) {
+            url = decodeURIComponent(uddgMatch[1]);
+        }
+        // Extract snippet
+        const snippetMatch = block.match(/class="result__snippet"[^>]*>([\s\S]*?)<\/a>/);
+        const snippet = snippetMatch ? stripHTML(snippetMatch[1]).trim() : '';
+        if (title && url) {
+            results.push({ title, url, snippet });
+        }
+    }
+    return results;
+}
+/**
+ * Search using DuckDuckGo HTML interface (no API key needed).
+ */
+async function searchDuckDuckGo(query, maxResults = 5) {
+    const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+    const response = await fetch(url, {
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        },
+        signal: AbortSignal.timeout(15000),
+    });
+    const html = await response.text();
+    return parseDuckDuckGoHTML(html).slice(0, maxResults);
+}
+/**
+ * Search using Brave Search API.
+ */
+async function searchBrave(query, apiKey, maxResults = 5) {
+    const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=${maxResults}`;
+    const response = await fetch(url, {
+        headers: { 'X-Subscription-Token': apiKey, Accept: 'application/json' },
+        signal: AbortSignal.timeout(15000),
+    });
+    const data = await response.json();
+    return (data.web?.results || []).slice(0, maxResults).map((r) => ({
+        title: r.title || '',
+        url: r.url || '',
+        snippet: r.description || '',
+    }));
+}
+/**
+ * Search using SearXNG instance.
+ */
+async function searchSearXNG(query, baseUrl, maxResults = 5) {
+    const url = `${baseUrl.replace(/\/$/, '')}/search?q=${encodeURIComponent(query)}&format=json`;
+    const response = await fetch(url, { signal: AbortSignal.timeout(15000) });
+    const data = await response.json();
+    return (data.results || []).slice(0, maxResults).map((r) => ({
+        title: r.title || '',
+        url: r.url || '',
+        snippet: r.content || '',
+    }));
+}
+/**
+ * Search using Google Custom Search API.
+ */
+async function searchGoogle(query, apiKey, maxResults = 5) {
+    // apiKey format: "key:cx" (API key and Custom Search Engine ID)
+    const [key, cx] = apiKey.split(':');
+    const url = `https://www.googleapis.com/customsearch/v1?q=${encodeURIComponent(query)}&key=${key}&cx=${cx}&num=${maxResults}`;
+    const response = await fetch(url, { signal: AbortSignal.timeout(15000) });
+    const data = await response.json();
+    return (data.items || []).slice(0, maxResults).map((r) => ({
+        title: r.title || '',
+        url: r.link || '',
+        snippet: r.snippet || '',
+    }));
+}
+/**
+ * Unified search function with fallback.
+ */
+async function webSearch(query, config, options) {
+    const cfg = config || exports.DEFAULT_SEARCH_CONFIG;
+    if (!cfg.enabled)
+        return [];
+    const maxResults = options?.maxResults || 5;
+    const engine = options?.engine || cfg.defaultEngine;
+    // Try requested engine first, then fallback chain
+    const fallbackOrder = [engine, 'duckduckgo', 'brave', 'searxng', 'google']
+        .filter((e, i, arr) => arr.indexOf(e) === i);
+    for (const eng of fallbackOrder) {
+        const engCfg = cfg.engines[eng];
+        if (engCfg && !engCfg.enabled)
+            continue;
+        try {
+            switch (eng) {
+                case 'duckduckgo':
+                    return await searchDuckDuckGo(query, maxResults);
+                case 'brave':
+                    if (engCfg?.apiKey)
+                        return await searchBrave(query, engCfg.apiKey, maxResults);
+                    continue;
+                case 'searxng':
+                    if (engCfg?.baseUrl)
+                        return await searchSearXNG(query, engCfg.baseUrl, maxResults);
+                    continue;
+                case 'google':
+                    if (engCfg?.apiKey)
+                        return await searchGoogle(query, engCfg.apiKey, maxResults);
+                    continue;
+            }
+        }
+        catch {
+            continue; // Fallback to next engine
+        }
+    }
+    return [];
+}
+function stripHTML(html) {
+    return html.replace(/<[^>]+>/g, '').replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#x27;/g, "'").replace(/&nbsp;/g, ' ');
+}
+//# sourceMappingURL=web-search.js.map