genesis-ai-cli 7.4.7 → 7.5.0

package/dist/src/mcp/tool-chain.js

@@ -0,0 +1,323 @@
+"use strict";
+/**
+ * Genesis MCP Tool Chaining Framework
+ *
+ * Automatic orchestration of dependent tool calls.
+ * Enables workflows like: generate image → open it → edit it
+ *
+ * Features:
+ * - Declarative chain definitions
+ * - Automatic output → input mapping
+ * - Conditional branching
+ * - Error recovery and rollback
+ * - Chain execution history
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainBuilder = exports.ToolChainExecutor = exports.CHAIN_TEMPLATES = void 0;
+exports.getChainExecutor = getChainExecutor;
+exports.chain = chain;
+exports.executeChain = executeChain;
+const index_js_1 = require("./index.js");
+// ============================================================================
+// Predefined Chain Templates
+// ============================================================================
+exports.CHAIN_TEMPLATES = {
+    // Generate image and open it
+    'generate-and-display': {
+        id: 'generate-and-display',
+        name: 'Generate and Display Image',
+        description: 'Generate an image with Stability AI and open it in the default viewer',
+        steps: [
+            {
+                id: 'generate',
+                server: 'stability-ai',
+                tool: 'stability-ai-generate-image',
+                params: (ctx) => ({
+                    prompt: ctx.data.prompt || 'a beautiful landscape',
+                    outputImageFileName: ctx.data.filename || `genesis-${Date.now()}`,
+                }),
+                transform: (result) => ({
+                    imagePath: result.imagePath || result.outputPath || result,
+                }),
+            },
+            {
+                id: 'open',
+                server: 'filesystem',
+                tool: 'read_file',
+                params: (ctx) => ({
+                    path: ctx.results.get('generate')?.imagePath,
+                }),
+                condition: (ctx) => !!ctx.results.get('generate')?.imagePath,
+            },
+        ],
+    },
+    // Search and scrape
+    'search-and-scrape': {
+        id: 'search-and-scrape',
+        name: 'Search and Scrape',
+        description: 'Search for a topic and scrape the top result',
+        steps: [
+            {
+                id: 'search',
+                server: 'brave-search',
+                tool: 'brave_web_search',
+                params: (ctx) => ({
+                    query: ctx.data.query,
+                    count: 3,
+                }),
+                transform: (result) => ({
+                    url: result.results?.[0]?.url || result.web?.results?.[0]?.url,
+                    title: result.results?.[0]?.title || result.web?.results?.[0]?.title,
+                }),
+            },
+            {
+                id: 'scrape',
+                server: 'firecrawl',
+                tool: 'firecrawl_scrape',
+                params: (ctx) => ({
+                    url: ctx.results.get('search')?.url,
+                    formats: ['markdown'],
+                }),
+                condition: (ctx) => !!ctx.results.get('search')?.url,
+                onError: 'skip',
+            },
+        ],
+    },
+    // Research paper workflow
+    'research-paper': {
+        id: 'research-paper',
+        name: 'Research Paper Workflow',
+        description: 'Search arXiv, get citations, save to memory',
+        steps: [
+            {
+                id: 'search-arxiv',
+                server: 'arxiv',
+                tool: 'search_arxiv',
+                params: (ctx) => ({
+                    query: ctx.data.query,
+                    maxResults: 5,
+                }),
+            },
+            {
+                id: 'get-citations',
+                server: 'semantic-scholar',
+                tool: 'get_paper_citations',
+                params: (ctx) => {
+                    const papers = ctx.results.get('search-arxiv')?.papers || [];
+                    const firstPaper = papers[0];
+                    return {
+                        paperId: firstPaper?.id?.replace('arxiv:', '') || '',
+                        maxResults: 10,
+                    };
+                },
+                condition: (ctx) => {
+                    const papers = ctx.results.get('search-arxiv')?.papers || [];
+                    return papers.length > 0;
+                },
+                onError: 'skip',
+            },
+            {
+                id: 'save-to-memory',
+                server: 'memory',
+                tool: 'create_entities',
+                params: (ctx) => {
+                    const papers = ctx.results.get('search-arxiv')?.papers || [];
+                    return {
+                        entities: papers.slice(0, 3).map((p) => ({
+                            name: p.title || 'Unknown Paper',
+                            entityType: 'research_paper',
+                            observations: [
+                                `Authors: ${p.authors?.join(', ') || 'Unknown'}`,
+                                `Abstract: ${p.abstract?.slice(0, 200) || 'N/A'}...`,
+                            ],
+                        })),
+                    };
+                },
+                condition: (ctx) => {
+                    const papers = ctx.results.get('search-arxiv')?.papers || [];
+                    return papers.length > 0;
+                },
+            },
+        ],
+    },
+};
+// ============================================================================
+// Chain Executor
+// ============================================================================
+class ToolChainExecutor {
+    mcpClient = (0, index_js_1.getMCPClient)();
+    async execute(chain, initialData = {}) {
+        const context = {
+            results: new Map(),
+            currentStep: 0,
+            errors: [],
+            data: { ...chain.initialContext, ...initialData },
+            startTime: new Date(),
+            log: [],
+        };
+        let stepsExecuted = 0;
+        let stepsFailed = 0;
+        for (let i = 0; i < chain.steps.length; i++) {
+            const step = chain.steps[i];
+            context.currentStep = i;
+            // Check condition
+            if (step.condition && !step.condition(context)) {
+                this.log(context, step.id, 'skip', { reason: 'condition not met' });
+                continue;
+            }
+            const stepStart = Date.now();
+            this.log(context, step.id, 'start');
+            try {
+                // Resolve params (can be function)
+                const params = typeof step.params === 'function'
+                    ? step.params(context)
+                    : step.params;
+                // Execute the tool
+                const result = await this.executeStep(step, params, context);
+                if (!result.success) {
+                    throw new Error(result.error || 'Tool call failed');
+                }
+                // Transform result if needed
+                const transformedResult = step.transform
+                    ? step.transform(result.data)
+                    : result.data;
+                context.results.set(step.id, transformedResult);
+                stepsExecuted++;
+                this.log(context, step.id, 'success', {
+                    latency: Date.now() - stepStart,
+                    resultKeys: Object.keys(transformedResult || {}),
+                });
+            }
+            catch (error) {
+                stepsFailed++;
+                const err = error instanceof Error ? error : new Error(String(error));
+                context.errors.push({ stepId: step.id, error: err });
+                this.log(context, step.id, 'error', {
+                    message: err.message,
+                    latency: Date.now() - stepStart,
+                });
+                // Handle error based on strategy
+                if (step.onError === 'stop') {
+                    break;
+                }
+                else if (step.onError === 'retry') {
+                    const retryResult = await this.retryStep(step, context, step.maxRetries || 3);
+                    if (retryResult) {
+                        context.results.set(step.id, retryResult);
+                        stepsExecuted++;
+                        this.log(context, step.id, 'retry', { success: true });
+                    }
+                }
+                else if (typeof step.onError === 'function') {
+                    const recoveryStep = step.onError(err, context);
+                    if (recoveryStep) {
+                        // Insert recovery step
+                        chain.steps.splice(i + 1, 0, recoveryStep);
+                    }
+                }
+                // 'skip' just continues to next step
+            }
+        }
+        const finalResult = chain.finalTransform
+            ? chain.finalTransform(context)
+            : context.results.get(chain.steps[chain.steps.length - 1]?.id);
+        return {
+            success: stepsFailed === 0,
+            finalResult,
+            context,
+            totalLatency: Date.now() - context.startTime.getTime(),
+            stepsExecuted,
+            stepsFailed,
+        };
+    }
+    async executeStep(step, params, context) {
+        return this.mcpClient.call(step.server, step.tool, params);
+    }
+    async retryStep(step, context, maxRetries) {
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const params = typeof step.params === 'function'
+                    ? step.params(context)
+                    : step.params;
+                const result = await this.executeStep(step, params, context);
+                if (result.success) {
+                    return step.transform ? step.transform(result.data) : result.data;
+                }
+            }
+            catch {
+                // Continue retrying
+            }
+            // Exponential backoff
+            await new Promise(r => setTimeout(r, 100 * Math.pow(2, attempt)));
+        }
+        return null;
+    }
+    log(context, stepId, action, details) {
+        context.log.push({
+            timestamp: new Date(),
+            stepId,
+            action,
+            details,
+        });
+    }
+}
+exports.ToolChainExecutor = ToolChainExecutor;
+// ============================================================================
+// Chain Builder (Fluent API)
+// ============================================================================
+class ChainBuilder {
+    chain;
+    constructor(id, name) {
+        this.chain = {
+            id,
+            name,
+            steps: [],
+        };
+    }
+    description(desc) {
+        this.chain.description = desc;
+        return this;
+    }
+    initialContext(ctx) {
+        this.chain.initialContext = ctx;
+        return this;
+    }
+    step(step) {
+        this.chain.steps.push(step);
+        return this;
+    }
+    call(id, server, tool, params) {
+        return this.step({ id, server, tool, params });
+    }
+    finalTransform(fn) {
+        this.chain.finalTransform = fn;
+        return this;
+    }
+    build() {
+        return this.chain;
+    }
+}
+exports.ChainBuilder = ChainBuilder;
+// ============================================================================
+// Singleton & Factory
+// ============================================================================
+let executorInstance = null;
+function getChainExecutor() {
+    if (!executorInstance) {
+        executorInstance = new ToolChainExecutor();
+    }
+    return executorInstance;
+}
+function chain(id, name) {
+    return new ChainBuilder(id, name);
+}
+async function executeChain(chainOrId, data = {}) {
+    const executor = getChainExecutor();
+    const chainDef = typeof chainOrId === 'string'
+        ? exports.CHAIN_TEMPLATES[chainOrId]
+        : chainOrId;
+    if (!chainDef) {
+        throw new Error(`Chain not found: ${chainOrId}`);
+    }
+    return executor.execute(chainDef, data);
+}

package/dist/src/mcp/transformers.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Genesis MCP Result Transformers
+ *
+ * Composable data transformations for MCP tool results.
+ * Pipe-style API for chaining transformations.
+ *
+ * Features:
+ * - Common transformers (extract, filter, map, reduce)
+ * - Domain-specific transformers (papers, search, code)
+ * - Type-safe pipeline composition
+ * - Error handling in pipelines
+ * - Custom transformer creation
+ */
+export type Transformer<TIn, TOut> = (input: TIn) => TOut;
+export type AsyncTransformer<TIn, TOut> = (input: TIn) => Promise<TOut>;
+export interface TransformPipeline<T> {
+    pipe<TOut>(transformer: Transformer<T, TOut>): TransformPipeline<TOut>;
+    pipeAsync<TOut>(transformer: AsyncTransformer<T, TOut>): AsyncTransformPipeline<TOut>;
+    value(): T;
+    valueOr<TDefault>(fallback: TDefault): T | TDefault;
+}
+export interface AsyncTransformPipeline<T> {
+    pipe<TOut>(transformer: Transformer<T, TOut>): AsyncTransformPipeline<TOut>;
+    pipeAsync<TOut>(transformer: AsyncTransformer<T, TOut>): AsyncTransformPipeline<TOut>;
+    value(): Promise<T>;
+    valueOr<TDefault>(fallback: TDefault): Promise<T | TDefault>;
+}
+export declare function transform<T>(data: T): TransformPipeline<T>;
+export declare function transformAsync<T>(data: Promise<T>): AsyncTransformPipeline<T>;
+/**
+ * Extract a nested property by path
+ */
+export declare function extract<TIn, TOut = any>(path: string): Transformer<TIn, TOut | undefined>;
+/**
+ * Filter an array
+ */
+export declare function filter<T>(predicate: (item: T, index: number) => boolean): Transformer<T[], T[]>;
+/**
+ * Map over an array
+ */
+export declare function map<TIn, TOut>(mapper: (item: TIn, index: number) => TOut): Transformer<TIn[], TOut[]>;
+/**
+ * Reduce an array
+ */
+export declare function reduce<T, TOut>(reducer: (acc: TOut, item: T, index: number) => TOut, initial: TOut): Transformer<T[], TOut>;
+/**
+ * Take first N items
+ */
+export declare function take<T>(n: number): Transformer<T[], T[]>;
+/**
+ * Sort an array
+ */
+export declare function sort<T>(compareFn?: (a: T, b: T) => number): Transformer<T[], T[]>;
+/**
+ * Get unique items by key
+ */
+export declare function unique<T>(keyFn?: (item: T) => any): Transformer<T[], T[]>;
+/**
+ * Group by key
+ */
+export declare function groupBy<T>(keyFn: (item: T) => string): Transformer<T[], Record<string, T[]>>;
+/**
+ * Default value if null/undefined
+ */
+export declare function defaultTo<T>(fallback: T): Transformer<T | null | undefined, T>;
+/**
+ * Pluck a property from each item
+ */
+export declare function pluck<T, K extends keyof T>(key: K): Transformer<T[], T[K][]>;
+/**
+ * Flatten nested arrays
+ */
+export declare function flatten<T>(): Transformer<T[][], T[]>;
+/**
+ * Extract papers from arXiv/semantic-scholar results
+ */
+export declare function extractPapers(): Transformer<any, any[]>;
+/**
+ * Extract search results from brave/exa/firecrawl
+ */
+export declare function extractSearchResults(): Transformer<any, any[]>;
+/**
+ * Normalize search result to common format
+ */
+export interface NormalizedSearchResult {
+    title: string;
+    url: string;
+    description: string;
+    source: string;
+}
+export declare function normalizeSearchResult(): Transformer<any, NormalizedSearchResult>;
+/**
+ * Normalize paper to common format
+ */
+export interface NormalizedPaper {
+    id: string;
+    title: string;
+    authors: string[];
+    abstract: string;
+    url: string;
+    year?: number;
+    citations?: number;
+}
+export declare function normalizePaper(): Transformer<any, NormalizedPaper>;
+/**
+ * Filter by minimum citation count
+ */
+export declare function minCitations(min: number): Transformer<NormalizedPaper[], NormalizedPaper[]>;
+/**
+ * Sort papers by citations (descending)
+ */
+export declare function sortByCitations(): Transformer<NormalizedPaper[], NormalizedPaper[]>;
+/**
+ * Extract code from firecrawl/exa results
+ */
+export declare function extractCode(): Transformer<any, string[]>;
+/**
+ * Extract URLs from content
+ */
+export declare function extractUrls(): Transformer<any, string[]>;
+/**
+ * Summarize content to max length
+ */
+export declare function summarize(maxLength: number): Transformer<string, string>;
+/**
+ * Format as markdown list
+ */
+export declare function toMarkdownList(): Transformer<string[], string>;
+/**
+ * Format as numbered list
+ */
+export declare function toNumberedList(): Transformer<string[], string>;
+/**
+ * Compose multiple transformers into one
+ */
+export declare function compose<TIn, TOut>(...transformers: Transformer<any, any>[]): Transformer<TIn, TOut>;
+/**
+ * Create a transformer that tries multiple paths and returns first success
+ */
+export declare function tryPaths<TIn, TOut>(...paths: string[]): Transformer<TIn, TOut | undefined>;
+/**
+ * Conditional transformer
+ */
+export declare function when<T>(predicate: (input: T) => boolean, thenTransform: Transformer<T, T>, elseTransform?: Transformer<T, T>): Transformer<T, T>;
+/**
+ * Process arXiv search results into normalized papers
+ */
+export declare function processArxivResults(): Transformer<any, NormalizedPaper[]>;
+/**
+ * Process web search results into normalized format
+ */
+export declare function processSearchResults(): Transformer<any, NormalizedSearchResult[]>;
+/**
+ * Extract and summarize key information
+ */
+export declare function extractKeyInfo(maxItems?: number): Transformer<any, string[]>;