infinicode 1.0.0 → 2.0.0

package/dist/kernel/sdk/plugin-sdk.js

@@ -0,0 +1,40 @@
+export function definePlugin(name) {
+    const manifest = { name, version: '0.1.0' };
+    let subscriptions;
+    let onEventFn;
+    const commands = [];
+    let onRegisterFn;
+    let onDestroyFn;
+    const builder = {
+        version(v) { manifest.version = v; return this; },
+        description(d) { manifest.description = d; return this; },
+        subscribe(types, handler) {
+            subscriptions = types;
+            onEventFn = handler;
+            manifest.subscriptions = types;
+            return this;
+        },
+        command(name, description, handler) {
+            commands.push({ name, description, handler });
+            return this;
+        },
+        onRegister(fn) { onRegisterFn = fn; return this; },
+        onDestroy(fn) { onDestroyFn = fn; return this; },
+        onEvent(handler) { onEventFn = handler; return this; },
+        build() {
+            if (commands.length > 0)
+                manifest.commands = commands;
+            const plugin = { manifest };
+            if (onRegisterFn)
+                plugin.onRegister = onRegisterFn;
+            if (onDestroyFn)
+                plugin.onDestroy = onDestroyFn;
+            if (onEventFn)
+                plugin.onEvent = onEventFn;
+            if (subscriptions)
+                manifest.subscriptions = subscriptions;
+            return plugin;
+        },
+    };
+    return builder;
+}

package/dist/kernel/search/search-controller.d.ts

@@ -0,0 +1,32 @@
+export interface SearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+    markdown?: string;
+    crawledAt?: number;
+    error?: string;
+}
+export interface SearchOptions {
+    searxngUrl?: string;
+    /** Number of results to request from SearXNG. */
+    maxResults?: number;
+    /** Number of top results to crawl for full content. */
+    crawlTop?: number;
+    /** Per-request timeout ms. */
+    timeoutMs?: number;
+    /** Extra query params for SearXNG. */
+    searxngParams?: Record<string, string>;
+}
+export declare class SearchController {
+    private opts;
+    constructor(opts?: SearchOptions);
+    setOptions(opts: SearchOptions): void;
+    search(query: string): Promise<SearchResult[]>;
+    private querySearXNG;
+    private queryDuckDuckGo;
+    crawl(url: string): Promise<{
+        markdown: string;
+        text: string;
+        title: string;
+    } | null>;
+}

package/dist/kernel/search/search-controller.js

@@ -0,0 +1,141 @@
+/**
+ * OpenKernel — Search Controller
+ *
+ * Default stack: SearXNG → Crawler → Markdown → LLM.
+ *
+ *   1. Query SearXNG /search?q=...&format=json  → list of result URLs + snippets
+ *   2. Crawl each result URL (fetch HTML)        → raw page
+ *   3. Convert to Markdown                       → readable text
+ *   4. (LLM summarization is performed by the research worker, not here)
+ *
+ * If SearXNG is not configured/unreachable, falls back to a generic
+ * DuckDuckGo HTML scrape so the research worker remains functional.
+ */
+import { htmlToMarkdown, stripHtml, extractTitle } from '../browser/browser-controller.js';
+const DEFAULT_MAX = 8;
+const DEFAULT_CRAWL_TOP = 3;
+export class SearchController {
+    opts;
+    constructor(opts = {}) {
+        this.opts = { maxResults: DEFAULT_MAX, crawlTop: DEFAULT_CRAWL_TOP, timeoutMs: 15_000, ...opts };
+    }
+    setOptions(opts) {
+        this.opts = { ...this.opts, ...opts };
+    }
+    async search(query) {
+        const results = this.opts.searxngUrl
+            ? await this.querySearXNG(query)
+            : await this.queryDuckDuckGo(query);
+        const crawlTop = Math.min(this.opts.crawlTop ?? DEFAULT_CRAWL_TOP, results.length);
+        for (let i = 0; i < crawlTop; i++) {
+            const r = results[i];
+            if (!r.url)
+                continue;
+            const crawled = await this.crawl(r.url);
+            if (crawled) {
+                r.markdown = crawled.markdown;
+                r.snippet = r.snippet || crawled.text.slice(0, 280);
+                r.crawledAt = Date.now();
+            }
+            else {
+                r.error = 'crawl failed';
+            }
+        }
+        return results;
+    }
+    async querySearXNG(query) {
+        const url = new URL(`${this.opts.searxngUrl}/search`);
+        url.searchParams.set('q', query);
+        url.searchParams.set('format', 'json');
+        if (this.opts.searxngParams) {
+            for (const [k, v] of Object.entries(this.opts.searxngParams)) {
+                url.searchParams.set(k, v);
+            }
+        }
+        try {
+            const response = await fetch(url.toString(), {
+                headers: { Accept: 'application/json', 'User-Agent': 'OpenKernel-Search/1.0' },
+                signal: AbortSignal.timeout(this.opts.timeoutMs ?? 15_000),
+            });
+            if (!response.ok)
+                throw new Error(`SearXNG HTTP ${response.status}`);
+            const data = (await response.json());
+            return (data.results ?? [])
+                .slice(0, this.opts.maxResults ?? DEFAULT_MAX)
+                .map(r => ({
+                title: r.title ?? r.url ?? '',
+                url: r.url ?? '',
+                snippet: r.content ?? '',
+            }));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // fall back to DuckDuckGo
+            const ddg = await this.queryDuckDuckGo(query);
+            ddg.forEach(r => { r.error = `searxng failed (${message}); ddg fallback`; });
+            return ddg;
+        }
+    }
+    async queryDuckDuckGo(query) {
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+        try {
+            const response = await fetch(url, {
+                headers: { 'User-Agent': 'OpenKernel-Search/1.0' },
+                signal: AbortSignal.timeout(this.opts.timeoutMs ?? 15_000),
+            });
+            if (!response.ok)
+                throw new Error(`DuckDuckGo HTTP ${response.status}`);
+            const html = await response.text();
+            return parseDuckDuckGo(html).slice(0, this.opts.maxResults ?? DEFAULT_MAX);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return [{ title: 'search failed', url: '', snippet: message, error: message }];
+        }
+    }
+    async crawl(url) {
+        try {
+            const response = await fetch(url, {
+                headers: { 'User-Agent': 'OpenKernel-Crawler/1.0' },
+                signal: AbortSignal.timeout(this.opts.timeoutMs ?? 15_000),
+            });
+            if (!response.ok)
+                return null;
+            const html = await response.text();
+            return {
+                title: extractTitle(html),
+                text: stripHtml(html),
+                markdown: htmlToMarkdown(html),
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function parseDuckDuckGo(html) {
+    const results = [];
+    const linkRegex = /<a[^>]+class="result__a"[^>]*href="([^"]+)"[^>]*>([^<]*)<\/a>/gi;
+    const snippetRegex = /<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+    const links = [...html.matchAll(linkRegex)];
+    const snippets = [...html.matchAll(snippetRegex)];
+    for (let i = 0; i < links.length; i++) {
+        const href = links[i][1] ?? '';
+        const title = stripHtml(links[i][2] ?? '');
+        const snippet = stripHtml(snippets[i]?.[1] ?? '');
+        results.push({ title, url: decodeDdgHref(href), snippet });
+    }
+    return results;
+}
+function decodeDdgHref(href) {
+    const match = href.match(/uddg=([^&]+)/);
+    if (match) {
+        try {
+            return decodeURIComponent(match[1]);
+        }
+        catch {
+            return href;
+        }
+    }
+    return href.startsWith('//') ? `https:${href}` : href;
+}

package/dist/kernel/setup.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Bridge infinicode config (Conf) → OpenKernel Kernel instance.
+ * Registers the configured Ollama master + cloud providers as providers.
+ * Honors per-worker model pins by injecting them into the router.
+ */
+import type Conf from 'conf';
+import { Kernel } from '../kernel/index.js';
+import type { Logger } from '../kernel/index.js';
+import type { InfinicodeConfig } from './config-schema.js';
+export type { InfinicodeConfig, CloudProviderConfig, WorkerModelPref } from './config-schema.js';
+export declare function buildKernelFromConfig(config: Conf<InfinicodeConfig>, options?: {
+    logger?: Logger;
+}): Kernel;

package/dist/kernel/setup.js

@@ -0,0 +1,59 @@
+import { Kernel, OllamaProvider, OpenAICompatibleProvider, GeminiProvider } from '../kernel/index.js';
+import { getProviderPreset } from './free-providers.js';
+export function buildKernelFromConfig(config, options) {
+    const masterUrl = config.get('masterUrl');
+    const tailscaleMasterUrl = config.get('tailscaleMasterUrl');
+    const defaultModel = config.get('defaultModel');
+    const ollamaOptions = {
+        id: 'ollama',
+        name: 'Ollama',
+        baseURL: masterUrl,
+        fallbackURL: tailscaleMasterUrl,
+        defaultModel,
+    };
+    const kernel = new Kernel({ loadBuiltinWorkers: true, logger: options?.logger });
+    kernel.registerProvider('ollama', new OllamaProvider(ollamaOptions));
+    // Register cloud providers
+    const cloudProviders = config.get('cloudProviders') ?? [];
+    for (const cfg of cloudProviders) {
+        if (!cfg.enabled)
+            continue;
+        const preset = getProviderPreset(cfg.id);
+        if (cfg.id === 'gemini') {
+            const geminiOptions = {
+                id: cfg.id,
+                name: cfg.name,
+                apiKey: cfg.apiKey ?? '',
+                baseURL: cfg.baseURL,
+                knownModels: preset?.knownModels ?? [],
+            };
+            kernel.registerProvider(cfg.id, new GeminiProvider(geminiOptions));
+            continue;
+        }
+        const options = {
+            id: cfg.id,
+            name: cfg.name,
+            baseURL: cfg.baseURL,
+            apiKey: cfg.apiKey,
+            headerName: cfg.headerName,
+            knownModels: preset?.knownModels ?? [],
+        };
+        kernel.registerProvider(cfg.id, new OpenAICompatibleProvider(options));
+    }
+    // Apply per-worker model pins — the worker runtime honors them when routing.
+    const workerModels = config.get('workerModels') ?? {};
+    if (workerModels && Object.keys(workerModels).length > 0) {
+        const pins = new Map();
+        for (const [type, pref] of Object.entries(workerModels)) {
+            if (pref)
+                pins.set(type, pref);
+        }
+        kernel.workerRuntime.setWorkerPins(pins);
+    }
+    // Apply the configured default policy.
+    const policyName = config.get('policy');
+    if (policyName) {
+        kernel.setDefaultPolicy(policyName);
+    }
+    return kernel;
+}