infinicode 1.0.0 → 2.0.0

package/dist/kernel/workers/browser-worker.js

@@ -0,0 +1,92 @@
+import { BrowserController, actionArtifacts, htmlToMarkdown, } from '../browser/browser-controller.js';
+let sharedController;
+let controllerOptions;
+export function setBrowserController(controller) {
+    sharedController = controller;
+}
+export function setBrowserControllerOptions(options) {
+    controllerOptions = options;
+}
+function getController() {
+    if (!sharedController) {
+        sharedController = new BrowserController(controllerOptions ?? {});
+    }
+    return sharedController;
+}
+async function browserExecute(task, provider, model, ctx) {
+    const actions = task.input.context?.actions ?? [];
+    if (actions.length === 0) {
+        // No actions → fall back to LLM planning of browser steps.
+        const request = {
+            model: model.id,
+            systemPrompt: task.input.context?.systemPrompt,
+            prompt: task.input.prompt,
+            context: task.input.context,
+            maxTokens: 4096,
+            temperature: 0.3,
+        };
+        const result = await provider.complete(request);
+        const artifacts = result.content
+            ? [{ id: `${task.id}-out`, type: 'document', content: result.content, mimeType: 'text/markdown' }]
+            : [];
+        return {
+            content: result.content,
+            artifacts,
+            providerId: result.providerId,
+            modelId: result.modelId,
+            tokensIn: result.tokensIn,
+            tokensOut: result.tokensOut,
+            durationMs: result.durationMs,
+        };
+    }
+    const controller = getController();
+    await controller.init();
+    const results = [];
+    for (const action of actions) {
+        const result = await controller.runAction(action);
+        results.push(result);
+        ctx.logger.info(`Browser action ${action.type}: ${result.ok ? 'ok' : 'FAIL'} ${result.error ?? ''}`);
+        if (!result.ok && result.error) {
+            // continue collecting results; the LLM judge / recovery will decide
+        }
+    }
+    const text = results.map(r => r.text ?? '').filter(Boolean).join('\n\n');
+    const markdown = results.map(r => r.markdown ?? r.text ?? '').filter(Boolean).join('\n\n');
+    const artifacts = actionArtifacts(results);
+    // Optional LLM summarization of extracted content.
+    let summary = markdown || text;
+    if (text && text.length > 4000 && provider) {
+        try {
+            const request = {
+                model: model.id,
+                systemPrompt: 'Summarize the following browser-extracted content concisely, preserving key facts and any links.',
+                prompt: text.slice(0, 12000),
+                maxTokens: 1024,
+                temperature: 0.2,
+            };
+            const result = await provider.complete(request);
+            summary = result.content || markdown;
+        }
+        catch {
+            // keep raw extraction
+        }
+    }
+    return {
+        content: summary,
+        artifacts,
+        providerId: provider.info.id,
+        modelId: model.id,
+        tokensIn: 0,
+        tokensOut: 0,
+        durationMs: 0,
+    };
+}
+export function createBrowserWorker() {
+    return {
+        type: 'browser',
+        capabilities: ['browser', 'crawl', 'search', 'reasoning'],
+        preferences: { reasoning: 85, speed: 80, contextLength: 32_000 },
+        execute: browserExecute,
+    };
+}
+export { htmlToMarkdown };

package/dist/kernel/workers/builtin-workers.d.ts

@@ -0,0 +1,20 @@
+import type { WorkerExecuteFn, WorkerHandler } from '../worker-runtime.js';
+export { createResearchWorker } from './research-worker.js';
+export { createBrowserWorker } from './browser-worker.js';
+export declare function createCodingWorker(): WorkerHandler;
+export declare function createArchitectureWorker(): WorkerHandler;
+export declare function createReviewWorker(): WorkerHandler;
+export declare function createDocumentationWorker(): WorkerHandler;
+export declare function createTranslationWorker(): WorkerHandler;
+export declare function createTerminalWorker(): WorkerHandler;
+export declare function createVerificationWorker(): WorkerHandler;
+export declare function createVisionWorker(): WorkerHandler;
+/**
+ * Frontend worker — requests strong reasoning + very large context so the
+ * router picks a top model, and declares the frontend capabilities that gate
+ * it into the frontend-quality verifier. Produces production-grade UI code
+ * (HTML/CSS/vanilla JS). Prompts/briefs are supplied by the harness/task.
+ */
+export declare function createFrontendWorker(): WorkerHandler;
+export declare const ALL_BUILTIN_WORKERS: WorkerHandler[];
+export declare const EXECUTE_FN: WorkerExecuteFn;

package/dist/kernel/workers/builtin-workers.js

@@ -0,0 +1,120 @@
+import { createBrowserWorker } from './browser-worker.js';
+import { createResearchWorker } from './research-worker.js';
+async function defaultExecute(task, provider, model, _ctx) {
+    const request = {
+        model: model.id,
+        prompt: task.input.prompt,
+        systemPrompt: task.input.context?.systemPrompt,
+        context: task.input.context,
+        artifacts: task.input.artifacts,
+        maxTokens: 4096,
+        temperature: 0.3,
+    };
+    const result = await provider.complete(request);
+    const artifacts = result.content
+        ? [{ id: `${task.id}-out`, type: 'document', content: result.content, mimeType: 'text/markdown' }]
+        : [];
+    return {
+        content: result.content,
+        artifacts,
+        providerId: result.providerId,
+        modelId: result.modelId,
+        tokensIn: result.tokensIn,
+        tokensOut: result.tokensOut,
+        durationMs: result.durationMs,
+    };
+}
+export { createResearchWorker } from './research-worker.js';
+export { createBrowserWorker } from './browser-worker.js';
+export function createCodingWorker() {
+    return {
+        type: 'coding',
+        capabilities: ['coding', 'reasoning', 'filesystem', 'terminal'],
+        preferences: { reasoning: 95, speed: 80, contextLength: 32_000 },
+        execute: defaultExecute,
+    };
+}
+export function createArchitectureWorker() {
+    return {
+        type: 'architecture',
+        capabilities: ['architecture', 'planning', 'reasoning'],
+        preferences: { reasoning: 95, contextLength: 64_000 },
+        execute: defaultExecute,
+    };
+}
+export function createReviewWorker() {
+    return {
+        type: 'review',
+        capabilities: ['review', 'coding', 'reasoning'],
+        preferences: { reasoning: 90, contextLength: 32_000 },
+        execute: defaultExecute,
+    };
+}
+export function createDocumentationWorker() {
+    return {
+        type: 'documentation',
+        capabilities: ['documentation', 'summarize', 'reasoning'],
+        preferences: { reasoning: 80, speed: 80, contextLength: 16_000 },
+        execute: defaultExecute,
+    };
+}
+export function createTranslationWorker() {
+    return {
+        type: 'translation',
+        capabilities: ['translation', 'reasoning'],
+        preferences: { reasoning: 85, contextLength: 16_000 },
+        execute: defaultExecute,
+    };
+}
+export function createTerminalWorker() {
+    return {
+        type: 'terminal',
+        capabilities: ['terminal', 'coding', 'filesystem'],
+        preferences: { reasoning: 85, speed: 90, contextLength: 8_000 },
+        execute: defaultExecute,
+    };
+}
+export function createVerificationWorker() {
+    return {
+        type: 'verification',
+        capabilities: ['verification', 'reasoning', 'review'],
+        preferences: { reasoning: 95, contextLength: 16_000 },
+        execute: defaultExecute,
+    };
+}
+export function createVisionWorker() {
+    return {
+        type: 'vision',
+        capabilities: ['vision', 'ocr', 'reasoning'],
+        preferences: { reasoning: 85, vision: true, contextLength: 16_000 },
+        execute: defaultExecute,
+    };
+}
+/**
+ * Frontend worker — requests strong reasoning + very large context so the
+ * router picks a top model, and declares the frontend capabilities that gate
+ * it into the frontend-quality verifier. Produces production-grade UI code
+ * (HTML/CSS/vanilla JS). Prompts/briefs are supplied by the harness/task.
+ */
+export function createFrontendWorker() {
+    return {
+        type: 'frontend',
+        capabilities: ['frontend', 'coding', 'design', 'accessibility', 'dataviz', 'animation', 'reasoning', 'architecture'],
+        preferences: { reasoning: 95, speed: 60, contextLength: 200_000 },
+        execute: defaultExecute,
+    };
+}
+export const ALL_BUILTIN_WORKERS = [
+    createResearchWorker(),
+    createCodingWorker(),
+    createArchitectureWorker(),
+    createReviewWorker(),
+    createDocumentationWorker(),
+    createTranslationWorker(),
+    createTerminalWorker(),
+    createVerificationWorker(),
+    createVisionWorker(),
+    createFrontendWorker(),
+    createBrowserWorker(),
+];
+export const EXECUTE_FN = defaultExecute;

package/dist/kernel/workers/research-worker.d.ts

@@ -0,0 +1,5 @@
+import type { WorkerHandler } from '../worker-runtime.js';
+import { SearchController } from '../search/search-controller.js';
+export declare function setSearchController(controller: SearchController): void;
+export declare function setSearchControllerOptions(options: Record<string, unknown>): void;
+export declare function createResearchWorker(): WorkerHandler;

package/dist/kernel/workers/research-worker.js

@@ -0,0 +1,90 @@
+import { SearchController } from '../search/search-controller.js';
+let sharedController;
+let controllerOptions;
+export function setSearchController(controller) {
+    sharedController = controller;
+}
+export function setSearchControllerOptions(options) {
+    controllerOptions = options;
+}
+function getController() {
+    if (!sharedController) {
+        sharedController = new SearchController(controllerOptions ?? {});
+    }
+    return sharedController;
+}
+async function researchExecute(task, provider, model, ctx) {
+    const query = task.input.context?.query ?? task.input.prompt;
+    if (!query || !query.trim()) {
+        return defaultComplete(task, provider, model);
+    }
+    const controller = getController();
+    const results = await controller.search(query);
+    ctx.logger.info(`Research: ${results.length} results for "${query.slice(0, 60)}"`);
+    if (results.length === 0) {
+        return defaultComplete(task, provider, model);
+    }
+    const sourcesBlock = results
+        .map((r, i) => `[${i + 1}] ${r.title}\n    ${r.url}\n    ${r.snippet}`)
+        .join('\n\n');
+    const crawledBlock = results
+        .filter(r => r.markdown)
+        .map((r, i) => `--- Source ${i + 1}: ${r.title} ---\n${r.markdown?.slice(0, 4000)}`)
+        .join('\n\n');
+    const request = {
+        model: model.id,
+        systemPrompt: 'You are a research assistant. Using ONLY the provided sources, write a concise summary with inline citations in [n] format. Do not invent facts. List sources at the end.',
+        prompt: `Query: ${query}\n\nSources:\n${sourcesBlock}\n\nFull content:\n${crawledBlock.slice(0, 12000)}\n\nSummary:`,
+        maxTokens: 2048,
+        temperature: 0.2,
+    };
+    const result = await provider.complete(request);
+    const artifacts = [
+        { id: `${task.id}-summary`, type: 'document', content: result.content, mimeType: 'text/markdown' },
+        ...results.map((r, i) => ({
+            id: `${task.id}-src-${i}`,
+            type: 'url',
+            content: `${r.title}\n${r.url}`,
+            mimeType: 'text/plain',
+            metadata: { url: r.url, crawledAt: r.crawledAt },
+        })),
+    ];
+    return {
+        content: result.content,
+        artifacts,
+        providerId: result.providerId,
+        modelId: result.modelId,
+        tokensIn: result.tokensIn,
+        tokensOut: result.tokensOut,
+        durationMs: result.durationMs,
+    };
+}
+async function defaultComplete(task, provider, model) {
+    const request = {
+        model: model.id,
+        systemPrompt: task.input.context?.systemPrompt,
+        prompt: task.input.prompt,
+        context: task.input.context,
+        artifacts: task.input.artifacts,
+        maxTokens: 4096,
+        temperature: 0.3,
+    };
+    const result = await provider.complete(request);
+    return {
+        content: result.content,
+        artifacts: [{ id: `${task.id}-out`, type: 'document', content: result.content, mimeType: 'text/markdown' }],
+        providerId: result.providerId,
+        modelId: result.modelId,
+        tokensIn: result.tokensIn,
+        tokensOut: result.tokensOut,
+        durationMs: result.durationMs,
+    };
+}
+export function createResearchWorker() {
+    return {
+        type: 'research',
+        capabilities: ['search', 'crawl', 'summarize', 'citations', 'reasoning'],
+        preferences: { reasoning: 90, speed: 70, contextLength: 32_000 },
+        execute: researchExecute,
+    };
+}

package/dist/prompt-ascii-video-animation.d.ts

@@ -0,0 +1,2 @@
+export declare const PROMPT_ASCII_VIDEO_FRAMES: string[];
+export declare const PROMPT_ASCII_VIDEO_FPS = 24;