mark-improving-agent 2.2.0

package/dist/core/cognition/thought-graph.js

@@ -0,0 +1,495 @@
+/**
+ * Thought Graph - Framework of Thoughts (FoT)
+ *
+ * Paper: "Framework of Thoughts: Cognitive Process Integration via Graph of Operations"
+ *
+ * Key concepts:
+ * - Graph of Operations (GoO): DAG of operations representing reasoning process
+ * - Thought Graph (TG): Graph representation of thought chains
+ * - Operation nodes: Selectors (for/while/if) and actions
+ * - Thought nodes: Primitive operations
+ * - Meta-cognition through: Replanning, Self-Verification, Reflection
+ *
+ * Key strategies:
+ * - Divide and Conquer: Break complex problems
+ * - Multi-Path Exploration: Try multiple approaches
+ * - Backtracking: Revert to previous state
+ * - Self-Verification: Check intermediate results
+ */
+import { randomUUID } from 'crypto';
+const DEFAULT_OPTIONS = {
+    maxDepth: 10,
+    maxNodes: 100,
+    verificationThreshold: 0.75,
+    enableSelfVerification: true,
+    enableBacktracking: true,
+    enableMultiPath: true,
+};
+export function createThoughtGraph(options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const nodes = new Map();
+    const edges = new Map();
+    let rootId = null;
+    let nodeCount = 0;
+    function generateNodeId() {
+        return `node-${Date.now()}-${randomUUID().slice(0, 8)}`;
+    }
+    function generateEdgeId() {
+        return `edge-${Date.now()}-${randomUUID().slice(0, 8)}`;
+    }
+    function addEdge(sourceId, targetId, relation) {
+        const edge = {
+            id: generateEdgeId(),
+            sourceId,
+            targetId,
+            relation,
+            weight: 1.0,
+        };
+        edges.set(edge.id, edge);
+        // Update parent's children
+        const parent = nodes.get(sourceId);
+        if (parent) {
+            if (!parent.children)
+                parent.children = [];
+            parent.children.push(targetId);
+        }
+    }
+    function addPrimitive(content, parentId) {
+        const id = generateNodeId();
+        const node = {
+            id,
+            type: 'primitive',
+            content,
+            depth: parentId ? (nodes.get(parentId)?.depth ?? 0) + 1 : 0,
+            confidence: 0.7,
+            verified: false,
+            timestamp: Date.now(),
+        };
+        nodes.set(id, node);
+        nodeCount++;
+        if (!rootId)
+            rootId = id;
+        if (parentId) {
+            node.parent = parentId;
+            addEdge(parentId, id, 'sequence');
+        }
+        return node;
+    }
+    function addSelector(type, condition, parentId) {
+        const id = generateNodeId();
+        const node = {
+            id,
+            type: 'selector',
+            content: `${type.toUpperCase()}: ${condition}`,
+            depth: parentId ? (nodes.get(parentId)?.depth ?? 0) + 1 : 0,
+            confidence: 0.6,
+            verified: false,
+            metadata: { selectorType: type, condition },
+            timestamp: Date.now(),
+        };
+        nodes.set(id, node);
+        nodeCount++;
+        if (!rootId)
+            rootId = id;
+        if (parentId) {
+            node.parent = parentId;
+            addEdge(parentId, id, 'sequence');
+        }
+        return node;
+    }
+    function addAction(content, parentId) {
+        const id = generateNodeId();
+        const node = {
+            id,
+            type: 'action',
+            content,
+            depth: parentId ? (nodes.get(parentId)?.depth ?? 0) + 1 : 0,
+            confidence: 0.8,
+            verified: false,
+            timestamp: Date.now(),
+        };
+        nodes.set(id, node);
+        nodeCount++;
+        if (!rootId)
+            rootId = id;
+        if (parentId) {
+            node.parent = parentId;
+            addEdge(parentId, id, 'sequence');
+        }
+        return node;
+    }
+    function addVerification(nodeId) {
+        const parent = nodes.get(nodeId);
+        const id = generateNodeId();
+        const node = {
+            id,
+            type: 'verification',
+            content: `VERIFY: ${parent?.content ?? nodeId}`,
+            depth: parent ? parent.depth + 1 : 0,
+            confidence: 0.9,
+            verified: true,
+            metadata: { verifiedNodeId: nodeId },
+            timestamp: Date.now(),
+        };
+        nodes.set(id, node);
+        nodeCount++;
+        addEdge(nodeId, id, 'verifies');
+        return node;
+    }
+    function addReflection(content, parentId) {
+        const id = generateNodeId();
+        const node = {
+            id,
+            type: 'reflection',
+            content: `REFLECT: ${content}`,
+            depth: parentId ? (nodes.get(parentId)?.depth ?? 0) + 1 : 0,
+            confidence: 0.5,
+            verified: false,
+            metadata: { isMetaCognitive: true },
+            timestamp: Date.now(),
+        };
+        nodes.set(id, node);
+        nodeCount++;
+        if (parentId) {
+            node.parent = parentId;
+            addEdge(parentId, id, 'sequence');
+        }
+        return node;
+    }
+    function getNode(id) {
+        return nodes.get(id);
+    }
+    function getPath(fromId, toId) {
+        // BFS to find path between nodes
+        const visited = new Set();
+        const queue = [[fromId]];
+        while (queue.length > 0) {
+            const path = queue.shift();
+            const current = path[path.length - 1];
+            if (current === toId)
+                return path;
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            const currentNode = nodes.get(current);
+            if (currentNode?.children) {
+                for (const childId of currentNode.children) {
+                    if (!visited.has(childId)) {
+                        queue.push([...path, childId]);
+                    }
+                }
+            }
+        }
+        return [];
+    }
+    function getLeaves() {
+        const leaves = [];
+        for (const node of nodes.values()) {
+            if (!node.children || node.children.length === 0) {
+                leaves.push(node);
+            }
+        }
+        return leaves;
+    }
+    function verifyNode(nodeId) {
+        const node = nodes.get(nodeId);
+        if (!node)
+            return { passed: false, confidence: 0 };
+        // Self-verification logic
+        const checks = [];
+        // Check if node has acceptable confidence
+        checks.push(node.confidence >= opts.verificationThreshold);
+        // Check if node content is non-empty
+        checks.push(node.content.length > 0);
+        // Check if depth is within limits
+        checks.push(node.depth <= opts.maxDepth);
+        const passed = checks.every(c => c);
+        const confidence = passed ? node.confidence : node.confidence * 0.5;
+        return { passed, confidence };
+    }
+    function verifyPath(nodeIds) {
+        const issues = [];
+        let totalConfidence = 0;
+        for (const nodeId of nodeIds) {
+            const { passed, confidence } = verifyNode(nodeId);
+            totalConfidence += confidence;
+            if (!passed) {
+                const node = nodes.get(nodeId);
+                issues.push(`Node ${nodeId} (${node?.type}) failed verification`);
+            }
+        }
+        const avgConfidence = nodeIds.length > 0 ? totalConfidence / nodeIds.length : 0;
+        return {
+            passed: issues.length === 0,
+            confidence: avgConfidence,
+            issues,
+        };
+    }
+    function backtrack(fromId) {
+        const node = nodes.get(fromId);
+        if (!node)
+            return null;
+        // Find the parent or sibling path
+        if (node.parent) {
+            const parent = nodes.get(node.parent);
+            if (parent?.parent) {
+                return parent.parent;
+            }
+            return parent?.id ?? null;
+        }
+        return null;
+    }
+    function getAlternativePaths(nodeId) {
+        if (!opts.enableMultiPath)
+            return [];
+        const alternatives = [];
+        const node = nodes.get(nodeId);
+        if (!node || !node.children || node.children.length <= 1)
+            return alternatives;
+        // For selector nodes, get paths through each child
+        if (node.type === 'selector' && node.children.length > 1) {
+            for (const childId of node.children) {
+                const path = getPath(rootId, childId);
+                if (path.length > 0)
+                    alternatives.push(path);
+            }
+        }
+        return alternatives;
+    }
+    function selfVerify() {
+        const issues = [];
+        let totalConfidence = 0;
+        let verifiedCount = 0;
+        for (const node of nodes.values()) {
+            const { passed, confidence } = verifyNode(node.id);
+            totalConfidence += confidence;
+            if (passed) {
+                verifiedCount++;
+            }
+            else {
+                issues.push(`Node ${node.id} (${node.type}): ${node.content.slice(0, 30)}...`);
+            }
+        }
+        return {
+            verified: issues.length === 0,
+            issues,
+            confidence: totalConfidence / (nodes.size || 1),
+        };
+    }
+    function reflect() {
+        const insights = [];
+        const improvements = [];
+        // Analyze node depth distribution
+        const depthCount = new Map();
+        for (const node of nodes.values()) {
+            depthCount.set(node.depth, (depthCount.get(node.depth) || 0) + 1);
+        }
+        // Deep thoughts might indicate over-complexity
+        const maxDepth = Math.max(...Array.from(depthCount.keys()));
+        if (maxDepth > opts.maxDepth * 0.8) {
+            insights.push(`Graph is relatively deep (${maxDepth} levels) - consider simplification`);
+            improvements.push('Break complex reasoning into smaller sub-problems');
+        }
+        // Check verification coverage
+        const verifiedCount = Array.from(nodes.values()).filter(n => n.verified).length;
+        const verificationRatio = verifiedCount / (nodes.size || 1);
+        if (verificationRatio < 0.5) {
+            insights.push(`Low verification coverage (${(verificationRatio * 100).toFixed(0)}%)`);
+            improvements.push('Add more self-verification nodes to critical paths');
+        }
+        // Check confidence distribution
+        const confidences = Array.from(nodes.values()).map(n => n.confidence);
+        const avgConfidence = confidences.reduce((a, b) => a + b, 0) / (confidences.length || 1);
+        if (avgConfidence < opts.verificationThreshold) {
+            insights.push(`Average confidence (${(avgConfidence * 100).toFixed(0)}%) below threshold`);
+            improvements.push('Strengthen weak reasoning steps with more evidence');
+        }
+        // Check for selector balance
+        const selectors = Array.from(nodes.values()).filter(n => n.type === 'selector');
+        if (selectors.length > 0) {
+            insights.push(`Using ${selectors.length} control flow selectors`);
+        }
+        return { insights, improvements };
+    }
+    function buildFromThoughts(thoughts) {
+        let currentParent;
+        for (const thought of thoughts) {
+            const node = addPrimitive(thought, currentParent);
+            currentParent = node.id;
+        }
+        return execute();
+    }
+    function execute() {
+        if (!rootId) {
+            return {
+                graph: { nodes, edges, rootId },
+                path: [],
+                success: false,
+                confidence: 0,
+                verifiedPaths: [],
+                failedNodes: [],
+            };
+        }
+        // DFS execution from root
+        const path = [];
+        const verifiedPaths = [];
+        const failedNodes = [];
+        function traverse(nodeId) {
+            const node = nodes.get(nodeId);
+            if (!node)
+                return;
+            path.push(nodeId);
+            // Self-verify if enabled
+            if (opts.enableSelfVerification && node.type !== 'verification') {
+                const { passed } = verifyNode(nodeId);
+                if (passed) {
+                    verifiedPaths.push(nodeId);
+                }
+                else {
+                    failedNodes.push(nodeId);
+                    // Backtrack if enabled and node failed
+                    if (opts.enableBacktracking && node.type === 'primitive') {
+                        const alternative = backtrack(nodeId);
+                        if (alternative) {
+                            // Try alternative path
+                            const alternatives = getAlternativePaths(alternative);
+                            if (alternatives.length > 0) {
+                                const altPath = alternatives[0];
+                                for (const altId of altPath) {
+                                    if (!path.includes(altId)) {
+                                        traverse(altId);
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Recurse to children
+            if (node.children) {
+                for (const childId of node.children) {
+                    if (!path.includes(childId)) {
+                        traverse(childId);
+                    }
+                }
+            }
+        }
+        traverse(rootId);
+        const { passed, confidence } = verifyPath(path);
+        return {
+            graph: { nodes, edges, rootId },
+            path,
+            success: passed && failedNodes.length === 0,
+            confidence,
+            verifiedPaths,
+            failedNodes,
+        };
+    }
+    function executeFrom(nodeId) {
+        const startNode = nodes.get(nodeId);
+        if (!startNode) {
+            return {
+                graph: { nodes, edges, rootId },
+                path: [],
+                success: false,
+                confidence: 0,
+                verifiedPaths: [],
+                failedNodes: [],
+            };
+        }
+        const path = [];
+        const verifiedPaths = [];
+        const failedNodes = [];
+        function traverse(id) {
+            const node = nodes.get(id);
+            if (!node)
+                return;
+            path.push(id);
+            if (opts.enableSelfVerification) {
+                const { passed } = verifyNode(id);
+                if (passed) {
+                    verifiedPaths.push(id);
+                }
+                else {
+                    failedNodes.push(id);
+                }
+            }
+            if (node.children) {
+                for (const childId of node.children) {
+                    if (!path.includes(childId)) {
+                        traverse(childId);
+                    }
+                }
+            }
+        }
+        traverse(nodeId);
+        const { passed, confidence } = verifyPath(path);
+        return {
+            graph: { nodes, edges, rootId },
+            path,
+            success: passed && failedNodes.length === 0,
+            confidence,
+            verifiedPaths,
+            failedNodes,
+        };
+    }
+    function serialize() {
+        return JSON.stringify({
+            nodes: Array.from(nodes.entries()),
+            edges: Array.from(edges.entries()),
+            rootId,
+        });
+    }
+    function getStats() {
+        let maxDepth = 0;
+        let verifiedCount = 0;
+        let totalConfidence = 0;
+        for (const node of nodes.values()) {
+            if (node.depth > maxDepth)
+                maxDepth = node.depth;
+            if (node.verified)
+                verifiedCount++;
+            totalConfidence += node.confidence;
+        }
+        return {
+            nodeCount: nodes.size,
+            edgeCount: edges.size,
+            maxDepth,
+            verifiedCount,
+            avgConfidence: nodes.size > 0 ? totalConfidence / nodes.size : 0,
+        };
+    }
+    return {
+        buildFromThoughts,
+        addPrimitive,
+        addSelector,
+        addAction,
+        addVerification,
+        addReflection,
+        getNode,
+        getPath,
+        getLeaves,
+        verifyNode,
+        verifyPath,
+        backtrack,
+        getAlternativePaths,
+        selfVerify,
+        reflect,
+        execute,
+        executeFrom,
+        serialize: () => serialize(),
+        getStats,
+    };
+}
+// Static deserialize method
+export function deserializeThoughtGraph(data) {
+    const parsed = JSON.parse(data);
+    const nodes = new Map(parsed.nodes);
+    const edges = new Map(parsed.edges);
+    return {
+        nodes,
+        edges,
+        rootId: parsed.rootId,
+    };
+}

package/dist/core/cognition/tool-augmented-llm.js

@@ -0,0 +1,188 @@
+/**
+ * Tool-Augmented LLM - External Tool Integration
+ *
+ * Paper: "Tool-Augmented Language Models" (2301.06789)
+ * Concept: LLM with ability to use external tools
+ *
+ * Key mechanisms:
+ * - Tool selection with confidence
+ * - Sequential tool use for complex tasks
+ * - Reflection on tool results
+ * - Error handling and recovery
+ */
+/**
+ * Predefined tools for mark-improving-agent
+ */
+export const DEFAULT_TOOLS = [
+    {
+        id: 'memory_search',
+        name: 'search_memory',
+        description: 'Search long-term memory for relevant information',
+        parameters: {
+            query: { type: 'string', required: true, description: 'Search query' },
+            limit: { type: 'number', required: false, description: 'Max results (default: 5)' },
+        },
+        confidence: 0.95,
+        requiresApproval: false,
+    },
+    {
+        id: 'lesson_check',
+        name: 'check_lesson_bank',
+        description: 'Check lesson bank for relevant error patterns',
+        parameters: {
+            pattern: { type: 'string', required: true, description: 'Error pattern to check' },
+        },
+        confidence: 0.9,
+        requiresApproval: false,
+    },
+    {
+        id: 'self_verify',
+        name: 'verify_reasoning',
+        description: 'Self-verify reasoning chain for consistency',
+        parameters: {
+            reasoning: { type: 'string', required: true, description: 'Reasoning chain to verify' },
+        },
+        confidence: 0.85,
+        requiresApproval: false,
+    },
+    {
+        id: 'dream_consolidate',
+        name: 'dream_consolidation',
+        description: 'Run dream consolidation for memory integration',
+        parameters: {
+            intensity: { type: 'number', required: false, description: 'Consolidation intensity 0-1' },
+        },
+        confidence: 0.8,
+        requiresApproval: false,
+    },
+    {
+        id: 'knowledge_graph',
+        name: 'query_knowledge_graph',
+        description: 'Query knowledge graph for structured relationships',
+        parameters: {
+            query: { type: 'string', required: true, description: 'Query for KG' },
+            relation: { type: 'string', required: false, description: 'Filter by relation type' },
+        },
+        confidence: 0.85,
+        requiresApproval: false,
+    },
+    {
+        id: 'security_check',
+        name: 'check_security',
+        description: 'Check for sensitive information in content',
+        parameters: {
+            content: { type: 'string', required: true, description: 'Content to check' },
+        },
+        confidence: 0.95,
+        requiresApproval: false,
+    },
+    {
+        id: 'reflect',
+        name: 'self_reflect',
+        description: 'Perform self-reflection on recent actions',
+        parameters: {
+            focus: { type: 'string', required: false, description: 'Focus area for reflection' },
+        },
+        confidence: 0.75,
+        requiresApproval: false,
+    },
+];
+export function createToolAugmentedLLM(tools = DEFAULT_TOOLS) {
+    const toolMap = new Map();
+    const executions = [];
+    let totalExecutions = 0;
+    let successfulExecutions = 0;
+    // Register all tools
+    for (const tool of tools) {
+        toolMap.set(tool.id, tool);
+    }
+    function registerTool(tool) {
+        toolMap.set(tool.id, tool);
+    }
+    function selectTool(query, context) {
+        const queryLower = query.toLowerCase();
+        let bestMatch = null;
+        let bestScore = 0;
+        for (const tool of toolMap.values()) {
+            let score = 0;
+            // Check name match
+            if (tool.name.toLowerCase().includes(queryLower)) {
+                score += 0.5;
+            }
+            // Check description match
+            if (tool.description.toLowerCase().includes(queryLower)) {
+                score += 0.3;
+            }
+            // Apply tool confidence as tiebreaker
+            score += tool.confidence * 0.2;
+            if (score > bestScore) {
+                bestScore = score;
+                bestMatch = tool;
+            }
+        }
+        return bestScore > 0.3 ? bestMatch : null;
+    }
+    async function execute(tool, params) {
+        const start = Date.now();
+        totalExecutions++;
+        // Simulate tool execution
+        const execution = {
+            toolId: tool.id,
+            parameters: params,
+            result: `Executed ${tool.name} with params: ${JSON.stringify(params)}`,
+            success: true,
+            duration: Date.now() - start,
+            timestamp: Date.now(),
+        };
+        // Simulate occasional failures
+        if (Math.random() < 0.05) {
+            execution.success = false;
+            execution.error = 'Simulated tool failure';
+            execution.result = '';
+        }
+        if (execution.success) {
+            successfulExecutions++;
+        }
+        executions.push(execution);
+        return execution;
+    }
+    async function executeSequence(query, maxTools = 3) {
+        const selectedTools = [];
+        let remainingQuery = query;
+        let toolsUsed = 0;
+        // Sequential tool selection
+        while (toolsUsed < maxTools) {
+            const tool = selectTool(remainingQuery);
+            if (!tool)
+                break;
+            selectedTools.push(tool);
+            const execution = await execute(tool, { query: remainingQuery });
+            // Update query based on result
+            remainingQuery = execution.result || remainingQuery;
+            toolsUsed++;
+        }
+        return {
+            output: selectedTools.map(t => t.name).join(' -> '),
+            confidence: selectedTools.length > 0
+                ? selectedTools.reduce((sum, t) => sum + t.confidence, 0) / selectedTools.length
+                : 0,
+            suggestions: selectedTools.length < maxTools
+                ? ['Task completed']
+                : ['More tools may be needed'],
+        };
+    }
+    function getToolStats() {
+        return {
+            tools: toolMap.size,
+            executions: totalExecutions,
+            successRate: totalExecutions > 0 ? successfulExecutions / totalExecutions : 0,
+        };
+    }
+    return {
+        registerTool,
+        selectTool,
+        execute,
+        executeSequence,
+        getToolStats,
+    };
+}