overai 1.4.0

package/dist/cli/features/fast-context.js

@@ -0,0 +1,310 @@
+"use strict";
+/**
+ * Fast Context - Fast retrieval and summarization pipeline
+ * Minimizes tokens and latency with deterministic caching
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastContext = void 0;
+exports.createFastContext = createFastContext;
+exports.getQuickContext = getQuickContext;
+/**
+ * Fast Context class for efficient context retrieval
+ */
+class FastContext {
+    constructor(config = {}) {
+        this.cache = new Map();
+        this.sources = new Map();
+        this.config = {
+            maxTokens: 4000,
+            cacheEnabled: true,
+            cacheTTL: 300000, // 5 minutes
+            ...config
+        };
+    }
+    /**
+     * Register a context source
+     */
+    registerSource(id, type, contents, metadata) {
+        const sources = contents.map((content, i) => ({
+            id: `${id}_${i}`,
+            type,
+            content,
+            metadata
+        }));
+        this.sources.set(id, sources);
+    }
+    /**
+     * Register memory as a source
+     */
+    registerMemory(memory) {
+        const entries = memory.getAll();
+        const sources = entries.map((entry, i) => ({
+            id: `memory_${i}`,
+            type: 'memory',
+            content: entry.content,
+            metadata: entry.metadata
+        }));
+        this.sources.set('memory', sources);
+    }
+    /**
+     * Register knowledge base as a source
+     */
+    registerKnowledge(knowledge) {
+        // Store reference for dynamic retrieval
+        this._knowledgeBase = knowledge;
+    }
+    /**
+     * Get context for a query
+     */
+    async getContext(query) {
+        const startTime = Date.now();
+        // Check cache
+        const cacheKey = this.getCacheKey(query);
+        if (this.config.cacheEnabled) {
+            const cached = this.getFromCache(cacheKey);
+            if (cached) {
+                return {
+                    ...cached.result,
+                    cached: true,
+                    latencyMs: Date.now() - startTime
+                };
+            }
+        }
+        // Gather relevant sources
+        const relevantSources = await this.gatherRelevantSources(query);
+        // Build context within token limit
+        const { context, sources, tokenCount } = await this.buildContext(relevantSources, query);
+        const result = {
+            context,
+            sources,
+            tokenCount,
+            cached: false,
+            latencyMs: Date.now() - startTime
+        };
+        // Cache result
+        if (this.config.cacheEnabled) {
+            this.addToCache(cacheKey, result);
+        }
+        return result;
+    }
+    /**
+     * Gather relevant sources for a query
+     */
+    async gatherRelevantSources(query) {
+        const allSources = [];
+        // Get from registered sources
+        for (const sources of this.sources.values()) {
+            allSources.push(...sources);
+        }
+        // Get from knowledge base if registered
+        const kb = this._knowledgeBase;
+        if (kb) {
+            try {
+                const kbResults = await kb.search(query, 10);
+                for (let i = 0; i < kbResults.length; i++) {
+                    allSources.push({
+                        id: `kb_${i}`,
+                        type: 'knowledge',
+                        content: kbResults[i].content,
+                        relevance: kbResults[i].score
+                    });
+                }
+            }
+            catch {
+                // Ignore knowledge base errors
+            }
+        }
+        // Score relevance if embedding provider available
+        if (this.config.embeddingProvider) {
+            await this.scoreRelevance(allSources, query);
+        }
+        else {
+            // Simple text matching fallback
+            this.scoreRelevanceSimple(allSources, query);
+        }
+        // Sort by relevance
+        allSources.sort((a, b) => (b.relevance || 0) - (a.relevance || 0));
+        return allSources;
+    }
+    /**
+     * Score relevance using embeddings
+     */
+    async scoreRelevance(sources, query) {
+        if (!this.config.embeddingProvider)
+            return;
+        const queryEmbedding = await this.config.embeddingProvider.embed(query);
+        for (const source of sources) {
+            if (source.relevance !== undefined)
+                continue; // Already scored
+            const sourceEmbedding = await this.config.embeddingProvider.embed(source.content);
+            source.relevance = this.cosineSimilarity(queryEmbedding, sourceEmbedding);
+        }
+    }
+    /**
+     * Simple text-based relevance scoring
+     */
+    scoreRelevanceSimple(sources, query) {
+        const queryWords = query.toLowerCase().split(/\s+/);
+        for (const source of sources) {
+            if (source.relevance !== undefined)
+                continue;
+            const contentLower = source.content.toLowerCase();
+            let score = 0;
+            for (const word of queryWords) {
+                if (contentLower.includes(word)) {
+                    score += 1 / queryWords.length;
+                }
+            }
+            // Boost for exact phrase match
+            if (contentLower.includes(query.toLowerCase())) {
+                score += 0.5;
+            }
+            source.relevance = Math.min(score, 1);
+        }
+    }
+    /**
+     * Build context from sources within token limit
+     */
+    async buildContext(sources, query) {
+        const maxTokens = this.config.maxTokens || 4000;
+        const usedSources = [];
+        const contextParts = [];
+        let tokenCount = 0;
+        for (const source of sources) {
+            const sourceTokens = this.estimateTokens(source.content);
+            if (tokenCount + sourceTokens <= maxTokens) {
+                contextParts.push(source.content);
+                usedSources.push(source);
+                tokenCount += sourceTokens;
+            }
+            else if (this.config.summarizer && sourceTokens > 100) {
+                // Try to summarize if too long
+                const remainingTokens = maxTokens - tokenCount;
+                if (remainingTokens > 50) {
+                    const summary = await this.config.summarizer(source.content, remainingTokens);
+                    const summaryTokens = this.estimateTokens(summary);
+                    if (tokenCount + summaryTokens <= maxTokens) {
+                        contextParts.push(summary);
+                        usedSources.push({ ...source, content: summary, metadata: { ...source.metadata, summarized: true } });
+                        tokenCount += summaryTokens;
+                    }
+                }
+            }
+            if (tokenCount >= maxTokens * 0.95)
+                break;
+        }
+        return {
+            context: contextParts.join('\n\n'),
+            sources: usedSources,
+            tokenCount
+        };
+    }
+    /**
+     * Get cache key for query
+     */
+    getCacheKey(query) {
+        // Simple hash
+        let hash = 0;
+        for (let i = 0; i < query.length; i++) {
+            const char = query.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return `ctx_${hash}`;
+    }
+    /**
+     * Get from cache
+     */
+    getFromCache(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return null;
+        // Check TTL
+        if (Date.now() - entry.timestamp > (this.config.cacheTTL || 300000)) {
+            this.cache.delete(key);
+            return null;
+        }
+        entry.hits++;
+        return entry;
+    }
+    /**
+     * Add to cache
+     */
+    addToCache(key, result) {
+        this.cache.set(key, {
+            result,
+            timestamp: Date.now(),
+            hits: 0
+        });
+        // Limit cache size
+        if (this.cache.size > 100) {
+            const oldest = Array.from(this.cache.entries())
+                .sort((a, b) => a[1].timestamp - b[1].timestamp)[0];
+            if (oldest) {
+                this.cache.delete(oldest[0]);
+            }
+        }
+    }
+    /**
+     * Clear cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache stats
+     */
+    getCacheStats() {
+        let totalHits = 0;
+        for (const entry of this.cache.values()) {
+            totalHits += entry.hits;
+        }
+        return { size: this.cache.size, totalHits };
+    }
+    /**
+     * Estimate token count
+     */
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Cosine similarity
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    /**
+     * Clear all sources
+     */
+    clearSources() {
+        this.sources.clear();
+        this._knowledgeBase = undefined;
+    }
+}
+exports.FastContext = FastContext;
+/**
+ * Create a fast context instance
+ */
+function createFastContext(config) {
+    return new FastContext(config);
+}
+/**
+ * Quick context retrieval
+ */
+async function getQuickContext(query, sources, maxTokens) {
+    const fc = createFastContext({ maxTokens, cacheEnabled: false });
+    fc.registerSource('quick', 'custom', sources);
+    const result = await fc.getContext(query);
+    return result.context;
+}

package/dist/cli/features/flow-display.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Flow Display - Textual DAG visualization for workflows
+ */
+export interface FlowNode {
+    id: string;
+    name: string;
+    type: 'agent' | 'tool' | 'condition' | 'parallel' | 'start' | 'end';
+    status?: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+    children?: string[];
+    metadata?: Record<string, any>;
+}
+export interface FlowGraph {
+    nodes: Map<string, FlowNode>;
+    edges: Array<{
+        from: string;
+        to: string;
+        label?: string;
+    }>;
+}
+export interface FlowDisplayConfig {
+    showStatus?: boolean;
+    showMetadata?: boolean;
+    compact?: boolean;
+    maxWidth?: number;
+}
+/**
+ * Flow Display class for DAG visualization
+ */
+export declare class FlowDisplay {
+    private graph;
+    private config;
+    constructor(config?: FlowDisplayConfig);
+    /**
+     * Add a node to the graph
+     */
+    addNode(node: FlowNode): void;
+    /**
+     * Add an edge between nodes
+     */
+    addEdge(from: string, to: string, label?: string): void;
+    /**
+     * Update node status
+     */
+    updateStatus(id: string, status: FlowNode['status']): void;
+    /**
+     * Build graph from workflow steps
+     */
+    fromWorkflowSteps(steps: Array<{
+        name: string;
+        type?: string;
+        condition?: string;
+    }>): void;
+    /**
+     * Render the graph as text
+     */
+    render(): string;
+    /**
+     * Render a single node and its children
+     */
+    private renderNode;
+    /**
+     * Format a node for display
+     */
+    private formatNode;
+    /**
+     * Render as simple ASCII box diagram
+     */
+    renderBoxes(): string;
+    /**
+     * Create a box for a node
+     */
+    private createBox;
+    /**
+     * Get status character
+     */
+    private getStatusChar;
+    /**
+     * Clear the graph
+     */
+    clear(): void;
+    /**
+     * Get graph data
+     */
+    getGraph(): FlowGraph;
+    /**
+     * Export to DOT format (for Graphviz)
+     */
+    toDot(): string;
+}
+/**
+ * Create a flow display instance
+ */
+export declare function createFlowDisplay(config?: FlowDisplayConfig): FlowDisplay;
+/**
+ * Quick render workflow steps
+ */
+export declare function renderWorkflow(steps: Array<{
+    name: string;
+    type?: string;
+}>): string;

package/dist/cli/features/flow-display.js

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * Flow Display - Textual DAG visualization for workflows
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowDisplay = void 0;
+exports.createFlowDisplay = createFlowDisplay;
+exports.renderWorkflow = renderWorkflow;
+/**
+ * Flow Display class for DAG visualization
+ */
+class FlowDisplay {
+    constructor(config = {}) {
+        this.config = {
+            showStatus: true,
+            showMetadata: false,
+            compact: false,
+            maxWidth: 80,
+            ...config
+        };
+        this.graph = {
+            nodes: new Map(),
+            edges: []
+        };
+    }
+    /**
+     * Add a node to the graph
+     */
+    addNode(node) {
+        this.graph.nodes.set(node.id, node);
+    }
+    /**
+     * Add an edge between nodes
+     */
+    addEdge(from, to, label) {
+        this.graph.edges.push({ from, to, label });
+    }
+    /**
+     * Update node status
+     */
+    updateStatus(id, status) {
+        const node = this.graph.nodes.get(id);
+        if (node) {
+            node.status = status;
+        }
+    }
+    /**
+     * Build graph from workflow steps
+     */
+    fromWorkflowSteps(steps) {
+        this.graph.nodes.clear();
+        this.graph.edges = [];
+        // Add start node
+        this.addNode({ id: 'start', name: 'Start', type: 'start' });
+        let prevId = 'start';
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            const id = `step_${i}`;
+            this.addNode({
+                id,
+                name: step.name,
+                type: step.type || 'agent',
+                status: 'pending'
+            });
+            this.addEdge(prevId, id, step.condition);
+            prevId = id;
+        }
+        // Add end node
+        this.addNode({ id: 'end', name: 'End', type: 'end' });
+        this.addEdge(prevId, 'end');
+    }
+    /**
+     * Render the graph as text
+     */
+    render() {
+        const lines = [];
+        const visited = new Set();
+        // Find root nodes (nodes with no incoming edges)
+        const hasIncoming = new Set(this.graph.edges.map(e => e.to));
+        const roots = Array.from(this.graph.nodes.keys()).filter(id => !hasIncoming.has(id));
+        if (roots.length === 0 && this.graph.nodes.size > 0) {
+            const firstKey = this.graph.nodes.keys().next().value;
+            if (firstKey)
+                roots.push(firstKey);
+        }
+        for (const root of roots) {
+            this.renderNode(root, '', true, lines, visited);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Render a single node and its children
+     */
+    renderNode(id, prefix, isLast, lines, visited) {
+        if (visited.has(id)) {
+            lines.push(`${prefix}${isLast ? '└── ' : '├── '}(cycle: ${id})`);
+            return;
+        }
+        visited.add(id);
+        const node = this.graph.nodes.get(id);
+        if (!node)
+            return;
+        const connector = isLast ? '└── ' : '├── ';
+        const nodeStr = this.formatNode(node);
+        lines.push(`${prefix}${connector}${nodeStr}`);
+        // Find children
+        const childEdges = this.graph.edges.filter(e => e.from === id);
+        const childPrefix = prefix + (isLast ? '    ' : '│   ');
+        for (let i = 0; i < childEdges.length; i++) {
+            const edge = childEdges[i];
+            const isLastChild = i === childEdges.length - 1;
+            if (edge.label) {
+                lines.push(`${childPrefix}${isLastChild ? '└' : '├'}─[${edge.label}]─┐`);
+                this.renderNode(edge.to, childPrefix + (isLastChild ? '  ' : '│ '), true, lines, visited);
+            }
+            else {
+                this.renderNode(edge.to, childPrefix, isLastChild, lines, visited);
+            }
+        }
+    }
+    /**
+     * Format a node for display
+     */
+    formatNode(node) {
+        const parts = [];
+        // Status indicator
+        if (this.config.showStatus && node.status) {
+            const statusIcons = {
+                pending: '○',
+                running: '◐',
+                completed: '●',
+                failed: '✗',
+                skipped: '◌'
+            };
+            parts.push(statusIcons[node.status] || '?');
+        }
+        // Type indicator
+        const typeIcons = {
+            agent: '🤖',
+            tool: '🔧',
+            condition: '❓',
+            parallel: '⫘',
+            start: '▶',
+            end: '■'
+        };
+        if (!this.config.compact) {
+            parts.push(typeIcons[node.type] || '□');
+        }
+        // Name
+        parts.push(node.name);
+        // Metadata
+        if (this.config.showMetadata && node.metadata) {
+            const meta = Object.entries(node.metadata)
+                .map(([k, v]) => `${k}=${v}`)
+                .join(', ');
+            if (meta) {
+                parts.push(`(${meta})`);
+            }
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Render as simple ASCII box diagram
+     */
+    renderBoxes() {
+        const lines = [];
+        const nodeList = Array.from(this.graph.nodes.values());
+        for (let i = 0; i < nodeList.length; i++) {
+            const node = nodeList[i];
+            const box = this.createBox(node);
+            lines.push(...box);
+            if (i < nodeList.length - 1) {
+                lines.push('    │');
+                lines.push('    ▼');
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Create a box for a node
+     */
+    createBox(node) {
+        const name = node.name;
+        const width = Math.max(name.length + 4, 20);
+        const padding = Math.floor((width - name.length - 2) / 2);
+        const statusChar = this.config.showStatus ? this.getStatusChar(node.status) : '';
+        const top = '┌' + '─'.repeat(width) + '┐';
+        const middle = '│' + ' '.repeat(padding) + statusChar + name + ' '.repeat(width - padding - name.length - statusChar.length) + '│';
+        const bottom = '└' + '─'.repeat(width) + '┘';
+        return [top, middle, bottom];
+    }
+    /**
+     * Get status character
+     */
+    getStatusChar(status) {
+        const chars = {
+            pending: '○ ',
+            running: '◐ ',
+            completed: '● ',
+            failed: '✗ ',
+            skipped: '◌ '
+        };
+        return status ? (chars[status] || '') : '';
+    }
+    /**
+     * Clear the graph
+     */
+    clear() {
+        this.graph.nodes.clear();
+        this.graph.edges = [];
+    }
+    /**
+     * Get graph data
+     */
+    getGraph() {
+        return this.graph;
+    }
+    /**
+     * Export to DOT format (for Graphviz)
+     */
+    toDot() {
+        const lines = ['digraph workflow {'];
+        lines.push('  rankdir=TB;');
+        lines.push('  node [shape=box];');
+        for (const [id, node] of this.graph.nodes) {
+            const label = node.name.replace(/"/g, '\\"');
+            const style = node.status === 'completed' ? 'filled' : '';
+            const fillcolor = node.status === 'completed' ? 'lightgreen' :
+                node.status === 'failed' ? 'lightcoral' : 'white';
+            lines.push(`  "${id}" [label="${label}" style="${style}" fillcolor="${fillcolor}"];`);
+        }
+        for (const edge of this.graph.edges) {
+            const label = edge.label ? ` [label="${edge.label}"]` : '';
+            lines.push(`  "${edge.from}" -> "${edge.to}"${label};`);
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+}
+exports.FlowDisplay = FlowDisplay;
+/**
+ * Create a flow display instance
+ */
+function createFlowDisplay(config) {
+    return new FlowDisplay(config);
+}
+/**
+ * Quick render workflow steps
+ */
+function renderWorkflow(steps) {
+    const display = createFlowDisplay();
+    display.fromWorkflowSteps(steps);
+    return display.render();
+}