genesis-ai-cli 7.4.8 → 7.5.0

package/dist/src/mcp/transformers.js

@@ -0,0 +1,362 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = transform;
+exports.transformAsync = transformAsync;
+exports.extract = extract;
+exports.filter = filter;
+exports.map = map;
+exports.reduce = reduce;
+exports.take = take;
+exports.sort = sort;
+exports.unique = unique;
+exports.groupBy = groupBy;
+exports.defaultTo = defaultTo;
+exports.pluck = pluck;
+exports.flatten = flatten;
+exports.extractPapers = extractPapers;
+exports.extractSearchResults = extractSearchResults;
+exports.normalizeSearchResult = normalizeSearchResult;
+exports.normalizePaper = normalizePaper;
+exports.minCitations = minCitations;
+exports.sortByCitations = sortByCitations;
+exports.extractCode = extractCode;
+exports.extractUrls = extractUrls;
+exports.summarize = summarize;
+exports.toMarkdownList = toMarkdownList;
+exports.toNumberedList = toNumberedList;
+exports.compose = compose;
+exports.tryPaths = tryPaths;
+exports.when = when;
+exports.processArxivResults = processArxivResults;
+exports.processSearchResults = processSearchResults;
+exports.extractKeyInfo = extractKeyInfo;
+// ============================================================================
+// Pipeline Implementation
+// ============================================================================
+class SyncPipeline {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    pipe(transformer) {
+        return new SyncPipeline(transformer(this.data));
+    }
+    pipeAsync(transformer) {
+        return new AsyncPipelineImpl(Promise.resolve(this.data).then(transformer));
+    }
+    value() {
+        return this.data;
+    }
+    valueOr(fallback) {
+        return this.data ?? fallback;
+    }
+}
+class AsyncPipelineImpl {
+    dataPromise;
+    constructor(dataPromise) {
+        this.dataPromise = dataPromise;
+    }
+    pipe(transformer) {
+        return new AsyncPipelineImpl(this.dataPromise.then(transformer));
+    }
+    pipeAsync(transformer) {
+        return new AsyncPipelineImpl(this.dataPromise.then(transformer));
+    }
+    async value() {
+        return this.dataPromise;
+    }
+    async valueOr(fallback) {
+        try {
+            const result = await this.dataPromise;
+            return result ?? fallback;
+        }
+        catch {
+            return fallback;
+        }
+    }
+}
+function transform(data) {
+    return new SyncPipeline(data);
+}
+function transformAsync(data) {
+    return new AsyncPipelineImpl(data);
+}
+// ============================================================================
+// Common Transformers
+// ============================================================================
+/**
+ * Extract a nested property by path
+ */
+function extract(path) {
+    return (input) => {
+        const parts = path.split('.');
+        let current = input;
+        for (const part of parts) {
+            if (current === undefined || current === null)
+                return undefined;
+            current = current[part];
+        }
+        return current;
+    };
+}
+/**
+ * Filter an array
+ */
+function filter(predicate) {
+    return (input) => (Array.isArray(input) ? input.filter(predicate) : []);
+}
+/**
+ * Map over an array
+ */
+function map(mapper) {
+    return (input) => (Array.isArray(input) ? input.map(mapper) : []);
+}
+/**
+ * Reduce an array
+ */
+function reduce(reducer, initial) {
+    return (input) => (Array.isArray(input) ? input.reduce(reducer, initial) : initial);
+}
+/**
+ * Take first N items
+ */
+function take(n) {
+    return (input) => (Array.isArray(input) ? input.slice(0, n) : []);
+}
+/**
+ * Sort an array
+ */
+function sort(compareFn) {
+    return (input) => (Array.isArray(input) ? [...input].sort(compareFn) : []);
+}
+/**
+ * Get unique items by key
+ */
+function unique(keyFn = (x) => x) {
+    return (input) => {
+        if (!Array.isArray(input))
+            return [];
+        const seen = new Set();
+        return input.filter((item) => {
+            const key = keyFn(item);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    };
+}
+/**
+ * Group by key
+ */
+function groupBy(keyFn) {
+    return (input) => {
+        if (!Array.isArray(input))
+            return {};
+        return input.reduce((acc, item) => {
+            const key = keyFn(item);
+            if (!acc[key])
+                acc[key] = [];
+            acc[key].push(item);
+            return acc;
+        }, {});
+    };
+}
+/**
+ * Default value if null/undefined
+ */
+function defaultTo(fallback) {
+    return (input) => input ?? fallback;
+}
+/**
+ * Pluck a property from each item
+ */
+function pluck(key) {
+    return (input) => (Array.isArray(input) ? input.map((item) => item[key]) : []);
+}
+/**
+ * Flatten nested arrays
+ */
+function flatten() {
+    return (input) => (Array.isArray(input) ? input.flat() : []);
+}
+// ============================================================================
+// Domain-Specific Transformers (MCP Results)
+// ============================================================================
+/**
+ * Extract papers from arXiv/semantic-scholar results
+ */
+function extractPapers() {
+    return (input) => {
+        if (!input)
+            return [];
+        return input.papers || input.results || input.data || [];
+    };
+}
+/**
+ * Extract search results from brave/exa/firecrawl
+ */
+function extractSearchResults() {
+    return (input) => {
+        if (!input)
+            return [];
+        return (input.results ||
+            input.web?.results ||
+            input.data ||
+            input.pages ||
+            []);
+    };
+}
+function normalizeSearchResult() {
+    return (input) => ({
+        title: input.title || input.name || 'Untitled',
+        url: input.url || input.link || input.href || '',
+        description: input.description || input.snippet || input.abstract || '',
+        source: input.source || input.domain || extractDomain(input.url || ''),
+    });
+}
+function extractDomain(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function normalizePaper() {
+    return (input) => ({
+        id: input.id || input.paperId || input.arxivId || '',
+        title: input.title || 'Untitled',
+        authors: Array.isArray(input.authors)
+            ? input.authors.map((a) => (typeof a === 'string' ? a : a.name || ''))
+            : [],
+        abstract: input.abstract || input.summary || '',
+        url: input.url || input.link || `https://arxiv.org/abs/${input.id || ''}`,
+        year: input.year || input.publicationDate?.split('-')[0],
+        citations: input.citationCount || input.citations,
+    });
+}
+/**
+ * Filter by minimum citation count
+ */
+function minCitations(min) {
+    return filter((paper) => (paper.citations || 0) >= min);
+}
+/**
+ * Sort papers by citations (descending)
+ */
+function sortByCitations() {
+    return sort((a, b) => (b.citations || 0) - (a.citations || 0));
+}
+/**
+ * Extract code from firecrawl/exa results
+ */
+function extractCode() {
+    return (input) => {
+        const content = input.content || input.markdown || input.text || '';
+        const codeBlockRegex = /```[\s\S]*?```/g;
+        const matches = content.match(codeBlockRegex) || [];
+        return matches.map((block) => block.replace(/```\w*\n?/g, '').trim());
+    };
+}
+/**
+ * Extract URLs from content
+ */
+function extractUrls() {
+    return (input) => {
+        const content = typeof input === 'string' ? input : JSON.stringify(input);
+        const urlRegex = /https?:\/\/[^\s"'<>)]+/g;
+        return content.match(urlRegex) || [];
+    };
+}
+/**
+ * Summarize content to max length
+ */
+function summarize(maxLength) {
+    return (input) => {
+        if (!input || input.length <= maxLength)
+            return input || '';
+        return input.slice(0, maxLength - 3) + '...';
+    };
+}
+/**
+ * Format as markdown list
+ */
+function toMarkdownList() {
+    return (input) => Array.isArray(input) ? input.map((item) => `- ${item}`).join('\n') : '';
+}
+/**
+ * Format as numbered list
+ */
+function toNumberedList() {
+    return (input) => Array.isArray(input) ? input.map((item, i) => `${i + 1}. ${item}`).join('\n') : '';
+}
+// ============================================================================
+// Transformer Composition
+// ============================================================================
+/**
+ * Compose multiple transformers into one
+ */
+function compose(...transformers) {
+    return (input) => {
+        return transformers.reduce((acc, transformer) => transformer(acc), input);
+    };
+}
+/**
+ * Create a transformer that tries multiple paths and returns first success
+ */
+function tryPaths(...paths) {
+    return (input) => {
+        for (const path of paths) {
+            const result = extract(path)(input);
+            if (result !== undefined)
+                return result;
+        }
+        return undefined;
+    };
+}
+/**
+ * Conditional transformer
+ */
+function when(predicate, thenTransform, elseTransform) {
+    return (input) => {
+        if (predicate(input)) {
+            return thenTransform(input);
+        }
+        return elseTransform ? elseTransform(input) : input;
+    };
+}
+// ============================================================================
+// Prebuilt Pipelines
+// ============================================================================
+/**
+ * Process arXiv search results into normalized papers
+ */
+function processArxivResults() {
+    return compose(extractPapers(), map(normalizePaper()), sortByCitations());
+}
+/**
+ * Process web search results into normalized format
+ */
+function processSearchResults() {
+    return compose(extractSearchResults(), map(normalizeSearchResult()), unique((r) => r.url));
+}
+/**
+ * Extract and summarize key information
+ */
+function extractKeyInfo(maxItems = 5) {
+    return compose(extractSearchResults(), map(normalizeSearchResult()), take(maxItems), map((r) => `${r.title}: ${summarize(100)(r.description)}`));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genesis-ai-cli",
-  "version": "7.4.8",
+  "version": "7.5.0",
   "description": "Autonomous AI System Creator - Brain ON by default, Active Inference integrated, Curiosity-driven, Φ monitoring in every response",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",