gthinking 1.3.0 → 2.1.1

package/dist/reasoning.js

@@ -1,845 +0,0 @@
-"use strict";
-/**
- * Reasoning Module
- * Advanced logical reasoning with Chain of Thought, hypothesis testing, and multi-step problem solving
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reasoningEngine = exports.ReasoningEngine = void 0;
-const types_1 = require("./types");
-const events_1 = require("events");
-const llm_service_1 = require("./llm-service");
-class LogicalRulesEngine {
-    constructor() {
-        this.rules = new Map();
-    }
-    addRule(rule) {
-        this.rules.set(rule.id, rule);
-    }
-    infer(facts) {
-        const inferences = [];
-        this.rules.forEach(rule => {
-            const premisesMet = rule.premises.every(premise => facts.some(fact => this.match(fact, premise)));
-            if (premisesMet) {
-                inferences.push({
-                    conclusion: rule.conclusion,
-                    confidence: rule.confidence,
-                    rule
-                });
-            }
-        });
-        return inferences.sort((a, b) => b.confidence - a.confidence);
-    }
-    match(fact, premise) {
-        // Simple pattern matching - in real implementation use NLP
-        const factWords = fact.toLowerCase().split(/\s+/);
-        const premiseWords = premise.toLowerCase().split(/\s+/);
-        const matchCount = premiseWords.filter(pw => factWords.some(fw => fw.includes(pw) || pw.includes(fw))).length;
-        return matchCount / premiseWords.length > 0.7;
-    }
-    getRulesByDomain(domain) {
-        return Array.from(this.rules.values()).filter(r => r.domain === domain);
-    }
-}
-// ============================================================================
-// CHAIN OF THOUGHT GENERATOR
-// ============================================================================
-class ChainOfThoughtGenerator {
-    constructor() {
-        this.thoughtId = 0;
-    }
-    generate(question, maxDepth = 5) {
-        const thoughts = [];
-        const rootThought = {
-            id: this.nextThoughtId(),
-            content: question,
-            children: [],
-            depth: 0,
-            confidence: 1.0,
-            type: 'question'
-        };
-        thoughts.push(rootThought);
-        // Generate thought chain
-        this.expandThought(rootThought, thoughts, maxDepth, 0);
-        // Generate final answer based on thought chain
-        const finalAnswer = this.synthesizeAnswer(thoughts);
-        return {
-            id: `cot_${Date.now()}`,
-            initialQuestion: question,
-            thoughts,
-            finalAnswer,
-            completeness: this.calculateCompleteness(thoughts)
-        };
-    }
-    expandThought(parent, thoughts, maxDepth, currentDepth) {
-        if (currentDepth >= maxDepth)
-            return;
-        const expansions = this.generateExpansions(parent, currentDepth);
-        expansions.forEach(expansion => {
-            const child = {
-                id: this.nextThoughtId(),
-                content: expansion.content,
-                parentId: parent.id,
-                children: [],
-                depth: currentDepth + 1,
-                confidence: expansion.confidence * parent.confidence,
-                type: expansion.type
-            };
-            parent.children.push(child.id);
-            thoughts.push(child);
-            // Recursively expand if it's an observation or inference
-            if (expansion.type === 'observation' || expansion.type === 'inference') {
-                this.expandThought(child, thoughts, maxDepth, currentDepth + 1);
-            }
-        });
-    }
-    generateExpansions(thought, depth) {
-        const expansions = [];
-        const content = thought.content.toLowerCase();
-        // Generate contextual expansions based on thought type
-        if (thought.type === 'question') {
-            expansions.push({ content: `Let me break down this question into parts.`, type: 'observation', confidence: 0.9 }, { content: `What are the key elements involved?`, type: 'observation', confidence: 0.85 }, { content: `What do I already know about this?`, type: 'observation', confidence: 0.8 });
-        }
-        else if (thought.type === 'observation') {
-            expansions.push({ content: `This suggests that...`, type: 'inference', confidence: 0.75 }, { content: `One implication is...`, type: 'inference', confidence: 0.7 }, { content: `However, we must also consider...`, type: 'observation', confidence: 0.65 });
-        }
-        else if (thought.type === 'inference') {
-            if (depth < 3) {
-                expansions.push({ content: `Building on this inference...`, type: 'inference', confidence: 0.7 }, { content: `This leads to the conclusion that...`, type: 'conclusion', confidence: 0.8 });
-            }
-            else {
-                expansions.push({ content: `Therefore, we can conclude...`, type: 'conclusion', confidence: 0.85 });
-            }
-        }
-        return expansions;
-    }
-    synthesizeAnswer(thoughts) {
-        const conclusions = thoughts.filter(t => t.type === 'conclusion');
-        const inferences = thoughts.filter(t => t.type === 'inference');
-        if (conclusions.length > 0) {
-            const topConclusion = conclusions.sort((a, b) => b.confidence - a.confidence)[0];
-            return topConclusion.content + ' Based on the analysis: ' +
-                inferences.slice(0, 3).map(i => i.content).join('; ') + '.';
-        }
-        return 'Based on the analysis: ' + inferences.slice(0, 3).map(i => i.content).join('; ') + '.';
-    }
-    calculateCompleteness(thoughts) {
-        const hasQuestion = thoughts.some(t => t.type === 'question');
-        const hasObservations = thoughts.some(t => t.type === 'observation');
-        const hasInferences = thoughts.some(t => t.type === 'inference');
-        const hasConclusions = thoughts.some(t => t.type === 'conclusion');
-        const elements = [hasQuestion, hasObservations, hasInferences, hasConclusions];
-        return elements.filter(Boolean).length / elements.length;
-    }
-    nextThoughtId() {
-        return `thought_${++this.thoughtId}`;
-    }
-}
-// ============================================================================
-// HYPOTHESIS MANAGER
-// ============================================================================
-class HypothesisManager {
-    constructor() {
-        this.hypotheses = new Map();
-    }
-    createHypothesis(statement) {
-        const hypothesis = {
-            id: `hypothesis_${Date.now()}`,
-            statement,
-            supportingEvidence: [],
-            contradictingEvidence: [],
-            tests: [],
-            status: 'proposed',
-            confidence: 0.5
-        };
-        this.hypotheses.set(hypothesis.id, hypothesis);
-        return hypothesis;
-    }
-    addEvidence(hypothesisId, evidence, supporting) {
-        const hypothesis = this.hypotheses.get(hypothesisId);
-        if (!hypothesis)
-            throw new Error(`Hypothesis ${hypothesisId} not found`);
-        if (supporting) {
-            hypothesis.supportingEvidence.push(evidence);
-        }
-        else {
-            hypothesis.contradictingEvidence.push(evidence);
-        }
-        this.updateConfidence(hypothesis);
-    }
-    addTest(hypothesisId, test) {
-        const hypothesis = this.hypotheses.get(hypothesisId);
-        if (!hypothesis)
-            throw new Error(`Hypothesis ${hypothesisId} not found`);
-        hypothesis.tests.push(test);
-    }
-    runTest(hypothesisId, testId, outcome) {
-        const hypothesis = this.hypotheses.get(hypothesisId);
-        if (!hypothesis)
-            throw new Error(`Hypothesis ${hypothesisId} not found`);
-        const test = hypothesis.tests.find(t => t.id === testId);
-        if (!test)
-            throw new Error(`Test ${testId} not found`);
-        test.actualOutcome = outcome;
-        test.passed = outcome === test.expectedOutcome;
-        this.updateStatus(hypothesis);
-    }
-    updateConfidence(hypothesis) {
-        const supportWeight = hypothesis.supportingEvidence.reduce((sum, e) => sum + e.strength, 0);
-        const contradictWeight = hypothesis.contradictingEvidence.reduce((sum, e) => sum + e.strength, 0);
-        const totalWeight = supportWeight + contradictWeight;
-        if (totalWeight === 0) {
-            hypothesis.confidence = 0.5;
-        }
-        else {
-            hypothesis.confidence = supportWeight / totalWeight;
-        }
-    }
-    updateStatus(hypothesis) {
-        const completedTests = hypothesis.tests.filter(t => t.passed !== undefined);
-        const passedTests = completedTests.filter(t => t.passed);
-        if (completedTests.length === 0) {
-            hypothesis.status = 'testing';
-        }
-        else if (passedTests.length === completedTests.length && hypothesis.confidence > 0.8) {
-            hypothesis.status = 'confirmed';
-        }
-        else if (passedTests.length === 0 && completedTests.length > 2) {
-            hypothesis.status = 'rejected';
-        }
-        else {
-            hypothesis.status = 'testing';
-        }
-    }
-    getHypothesis(id) {
-        return this.hypotheses.get(id);
-    }
-    getAllHypotheses() {
-        return Array.from(this.hypotheses.values());
-    }
-    getHypothesesByStatus(status) {
-        return this.getAllHypotheses().filter(h => h.status === status);
-    }
-}
-// ============================================================================
-// PROBLEM DECOMPOSITION ENGINE
-// ============================================================================
-class ProblemDecompositionEngine {
-    decompose(problem) {
-        const subProblems = [];
-        const dependencies = [];
-        // Analyze problem structure
-        const problemParts = this.identifyProblemParts(problem);
-        // Create sub-problems
-        problemParts.forEach((part, index) => {
-            const subProblem = {
-                id: `sub_${index}`,
-                description: part.description,
-                difficulty: part.difficulty,
-                estimatedTime: part.estimatedTime,
-                prerequisites: [],
-                status: types_1.TaskStatus.PENDING
-            };
-            subProblems.push(subProblem);
-        });
-        // Identify dependencies
-        subProblems.forEach((sub, i) => {
-            subProblems.forEach((other, j) => {
-                if (i !== j && this.hasDependency(sub, other)) {
-                    dependencies.push({
-                        from: sub.id,
-                        to: other.id,
-                        type: 'requires'
-                    });
-                    sub.prerequisites.push(other.id);
-                }
-            });
-        });
-        // Determine solution strategy
-        const solutionStrategy = this.determineStrategy(subProblems, dependencies);
-        return {
-            id: `decomp_${Date.now()}`,
-            originalProblem: problem,
-            subProblems,
-            dependencies,
-            solutionStrategy
-        };
-    }
-    identifyProblemParts(problem) {
-        const parts = [];
-        // Simple decomposition based on keywords
-        const keywords = {
-            research: { difficulty: 0.7, time: 120 },
-            analyze: { difficulty: 0.6, time: 90 },
-            design: { difficulty: 0.8, time: 180 },
-            implement: { difficulty: 0.75, time: 240 },
-            test: { difficulty: 0.5, time: 60 },
-            optimize: { difficulty: 0.85, time: 150 },
-            evaluate: { difficulty: 0.55, time: 45 },
-            plan: { difficulty: 0.4, time: 30 }
-        };
-        const problemLower = problem.toLowerCase();
-        Object.entries(keywords).forEach(([keyword, config]) => {
-            if (problemLower.includes(keyword)) {
-                parts.push({
-                    description: `${keyword.charAt(0).toUpperCase() + keyword.slice(1)} phase of the problem`,
-                    difficulty: config.difficulty,
-                    estimatedTime: config.time
-                });
-            }
-        });
-        // If no specific parts identified, create generic ones
-        if (parts.length === 0) {
-            parts.push({ description: 'Understand the problem', difficulty: 0.4, estimatedTime: 30 }, { description: 'Research and gather information', difficulty: 0.6, estimatedTime: 60 }, { description: 'Develop solution approach', difficulty: 0.7, estimatedTime: 90 }, { description: 'Implement the solution', difficulty: 0.75, estimatedTime: 120 }, { description: 'Verify and validate', difficulty: 0.5, estimatedTime: 45 });
-        }
-        return parts;
-    }
-    hasDependency(sub1, sub2) {
-        // Check if sub1 requires sub2 based on description
-        const orderIndicators = {
-            'understand': [],
-            'research': ['understand'],
-            'design': ['research', 'understand'],
-            'implement': ['design', 'research'],
-            'test': ['implement'],
-            'optimize': ['test', 'implement'],
-            'evaluate': ['test', 'implement', 'optimize'],
-            'plan': ['understand', 'research']
-        };
-        const sub1Keywords = Object.keys(orderIndicators).filter(k => sub1.description.toLowerCase().includes(k));
-        const sub2Keywords = Object.keys(orderIndicators).filter(k => sub2.description.toLowerCase().includes(k));
-        return sub1Keywords.some(k1 => sub2Keywords.some(k2 => orderIndicators[k1]?.includes(k2)));
-    }
-    determineStrategy(subProblems, dependencies) {
-        const criticalPath = this.findCriticalPath(subProblems, dependencies);
-        const totalTime = subProblems.reduce((sum, sp) => sum + sp.estimatedTime, 0);
-        const avgDifficulty = subProblems.reduce((sum, sp) => sum + sp.difficulty, 0) / subProblems.length;
-        if (avgDifficulty > 0.7) {
-            return `Divide-and-conquer approach recommended. Tackle critical path first: ${criticalPath.join(' → ')}. Estimated total time: ${totalTime} minutes.`;
-        }
-        else if (dependencies.length > subProblems.length) {
-            return `Sequential approach with careful dependency management. Start with: ${criticalPath[0]}.`;
-        }
-        else {
-            return `Parallel processing possible. Focus on: ${criticalPath.join(', ')}.`;
-        }
-    }
-    findCriticalPath(subProblems, dependencies) {
-        // Simplified critical path - in real implementation use topological sort
-        const visited = new Set();
-        const path = [];
-        const visit = (subId) => {
-            if (visited.has(subId))
-                return;
-            visited.add(subId);
-            const prereqs = dependencies
-                .filter(d => d.to === subId && d.type === 'requires')
-                .map(d => d.from);
-            prereqs.forEach(visit);
-            const sub = subProblems.find(s => s.id === subId);
-            if (sub)
-                path.push(sub.description);
-        };
-        subProblems.forEach(sp => visit(sp.id));
-        return path.length > 0 ? path : subProblems.map(s => s.description);
-    }
-}
-// ============================================================================
-// REASONING ENGINE
-// ============================================================================
-class ReasoningEngine extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.sessions = new Map();
-        this.rulesEngine = new LogicalRulesEngine();
-        this.cotGenerator = new ChainOfThoughtGenerator();
-        this.hypothesisManager = new HypothesisManager();
-        this.decompositionEngine = new ProblemDecompositionEngine();
-        this.initializeDefaultRules();
-    }
-    initializeDefaultRules() {
-        // Add some default logical rules
-        this.rulesEngine.addRule({
-            id: 'rule_cause_effect',
-            premises: ['A causes B', 'A occurred'],
-            conclusion: 'B will occur',
-            confidence: 0.8,
-            domain: 'causality'
-        });
-        this.rulesEngine.addRule({
-            id: 'rule_generalization',
-            premises: ['All X are Y', 'Z is X'],
-            conclusion: 'Z is Y',
-            confidence: 0.95,
-            domain: 'logic'
-        });
-        this.rulesEngine.addRule({
-            id: 'rule_analogy',
-            premises: ['A is similar to B', 'A has property P'],
-            conclusion: 'B likely has property P',
-            confidence: 0.7,
-            domain: 'analogy'
-        });
-    }
-    /**
-     * Perform reasoning on a problem
-     */
-    async reason(problem, options = {}) {
-        const { type = types_1.ReasoningType.DEDUCTIVE, maxSteps = 5, generateCOT = true } = options;
-        const sessionId = this.generateId();
-        const startTime = Date.now();
-        const session = {
-            id: sessionId,
-            problem,
-            type,
-            steps: [],
-            confidence: 0,
-            startTime: new Date()
-        };
-        this.sessions.set(sessionId, session);
-        this.emit('reasoning_start', {
-            id: sessionId,
-            stage: types_1.ThinkingStage.REASONING,
-            timestamp: new Date(),
-            data: { problem, type }
-        });
-        try {
-            // Generate Chain of Thought if enabled (via LLM implicitly or explicitly)
-            let cot;
-            // Try LLM-based reasoning first
-            await this.executeReasoningWithLLM(session, maxSteps);
-            // If LLM failed (empty steps), fallback to internal engines
-            if (session.steps.length === 0) {
-                if (generateCOT) {
-                    cot = this.cotGenerator.generate(problem, maxSteps);
-                }
-                switch (type) {
-                    case types_1.ReasoningType.DEDUCTIVE:
-                        await this.executeDeductiveReasoning(session, maxSteps);
-                        break;
-                    case types_1.ReasoningType.INDUCTIVE:
-                        await this.executeInductiveReasoning(session, maxSteps);
-                        break;
-                    case types_1.ReasoningType.ABDUCTIVE:
-                        await this.executeAbductiveReasoning(session, maxSteps);
-                        break;
-                    case types_1.ReasoningType.ANALOGICAL:
-                        await this.executeAnalogicalReasoning(session, maxSteps);
-                        break;
-                    case types_1.ReasoningType.CAUSAL:
-                        await this.executeCausalReasoning(session, maxSteps);
-                        break;
-                    case types_1.ReasoningType.COUNTERFACTUAL:
-                        await this.executeCounterfactualReasoning(session, maxSteps);
-                        break;
-                }
-                // Generate conclusion for fallback
-                session.conclusion = this.generateConclusion(session, cot);
-                session.confidence = this.calculateSessionConfidence(session);
-            }
-            session.endTime = new Date();
-            this.emit('reasoning_complete', {
-                id: sessionId,
-                stage: types_1.ThinkingStage.REASONING,
-                timestamp: new Date(),
-                data: {
-                    session,
-                    steps: session.steps.length,
-                    confidence: session.confidence
-                }
-            });
-            return session;
-        }
-        catch (error) {
-            this.emit('reasoning_error', {
-                id: sessionId,
-                stage: types_1.ThinkingStage.REASONING,
-                timestamp: new Date(),
-                data: { error }
-            });
-            throw new types_1.ThinkingError(`Reasoning failed: ${error instanceof Error ? error.message : 'Unknown error'}`, types_1.ThinkingStage.REASONING, true, error instanceof Error ? error : undefined);
-        }
-    }
-    async executeReasoningWithLLM(session, maxSteps) {
-        const prompt = `
-      You are an expert reasoning engine.
-      Problem: "${session.problem}"
-      Task: Perform ${session.type} reasoning with approximately ${maxSteps} steps.
-      
-      Return a JSON object with this exact structure (no markdown, just JSON):
-      {
-        "steps": [
-          {
-            "stepNumber": number,
-            "premise": "string (the basis for this step)",
-            "inference": "string (the logical deduction)",
-            "confidence": number (0.0 to 1.0)
-          }
-        ],
-        "conclusion": "string (final conclusion)",
-        "overallConfidence": number (0.0 to 1.0)
-      }
-    `;
-        try {
-            const response = await llm_service_1.llmService.generateText({ prompt });
-            const jsonMatch = response.match(/\{[\s\S]*\}/);
-            if (jsonMatch) {
-                const result = JSON.parse(jsonMatch[0]);
-                if (Array.isArray(result.steps)) {
-                    result.steps.forEach((s, i) => {
-                        session.steps.push({
-                            id: `step_${i}`,
-                            stepNumber: s.stepNumber || i + 1,
-                            premise: s.premise || '',
-                            inference: s.inference || '',
-                            evidence: [],
-                            assumptions: [],
-                            confidence: s.confidence || 0.8,
-                            nextSteps: []
-                        });
-                    });
-                }
-                session.conclusion = result.conclusion;
-                session.confidence = result.overallConfidence || 0.8;
-            }
-        }
-        catch (error) {
-            console.warn('LLM reasoning failed, falling back to internal engine', error);
-            // Fallback handled in caller
-        }
-    }
-    async executeDeductiveReasoning(session, maxSteps) {
-        const facts = this.extractFacts(session.problem);
-        for (let i = 0; i < maxSteps; i++) {
-            const inferences = this.rulesEngine.infer(facts);
-            if (inferences.length === 0)
-                break;
-            const topInference = inferences[0];
-            const step = {
-                id: `step_${i}`,
-                stepNumber: i + 1,
-                premise: facts.join(', '),
-                inference: topInference.conclusion,
-                evidence: [{
-                        source: 'logical_rules',
-                        excerpt: `Rule: ${topInference.rule.premises.join(' AND ')} => ${topInference.rule.conclusion}`,
-                        location: 'rules_engine',
-                        strength: topInference.confidence
-                    }],
-                assumptions: topInference.rule.premises,
-                confidence: topInference.confidence,
-                nextSteps: inferences.slice(1).map(inf => inf.conclusion)
-            };
-            session.steps.push(step);
-            facts.push(topInference.conclusion);
-        }
-    }
-    async executeInductiveReasoning(session, maxSteps) {
-        // Pattern-based reasoning from specific to general
-        const observations = this.extractObservations(session.problem);
-        for (let i = 0; i < maxSteps && i < observations.length; i++) {
-            const pattern = this.identifyPattern(observations.slice(0, i + 1));
-            const step = {
-                id: `step_${i}`,
-                stepNumber: i + 1,
-                premise: observations.slice(0, i + 1).join('; '),
-                inference: `Pattern identified: ${pattern.description}`,
-                evidence: observations.map(obs => ({
-                    source: 'observation',
-                    excerpt: obs,
-                    location: 'problem_statement',
-                    strength: 0.7
-                })),
-                assumptions: ['Observations are representative', 'Pattern will continue'],
-                confidence: pattern.confidence,
-                nextSteps: ['Test pattern with new data', 'Formulate general rule']
-            };
-            session.steps.push(step);
-        }
-    }
-    async executeAbductiveReasoning(session, maxSteps) {
-        // Inference to the best explanation
-        const observations = this.extractObservations(session.problem);
-        const possibleExplanations = this.generateExplanations(observations);
-        for (let i = 0; i < maxSteps && i < possibleExplanations.length; i++) {
-            const explanation = possibleExplanations[i];
-            const step = {
-                id: `step_${i}`,
-                stepNumber: i + 1,
-                premise: observations.join('; '),
-                inference: `Best explanation: ${explanation.description}`,
-                evidence: [{
-                        source: 'abductive_inference',
-                        excerpt: explanation.supportingEvidence,
-                        location: 'generated_explanation',
-                        strength: explanation.plausibility
-                    }],
-                assumptions: explanation.assumptions,
-                confidence: explanation.plausibility,
-                nextSteps: possibleExplanations.slice(i + 1).map(e => `Alternative: ${e.description}`)
-            };
-            session.steps.push(step);
-        }
-    }
-    async executeAnalogicalReasoning(session, maxSteps) {
-        // Reasoning by analogy
-        const sourceDomain = this.extractDomain(session.problem);
-        const analogies = this.findAnalogies(sourceDomain);
-        for (let i = 0; i < maxSteps && i < analogies.length; i++) {
-            const analogy = analogies[i];
-            const step = {
-                id: `step_${i}`,
-                stepNumber: i + 1,
-                premise: `Source domain: ${sourceDomain}`,
-                inference: `Analogous to: ${analogy.targetDomain}. Therefore: ${analogy.inferredProperty}`,
-                evidence: [{
-                        source: 'analogy',
-                        excerpt: `Similarity: ${analogy.similarityDescription}`,
-                        location: 'analogy_mapping',
-                        strength: analogy.similarityScore
-                    }],
-                assumptions: ['Analogous domains share relevant properties'],
-                confidence: analogy.similarityScore,
-                nextSteps: analogies.slice(i + 1).map(a => `Alternative analogy: ${a.targetDomain}`)
-            };
-            session.steps.push(step);
-        }
-    }
-    async executeCausalReasoning(session, maxSteps) {
-        // Cause-effect reasoning
-        const causalChain = this.identifyCausalChain(session.problem);
-        for (let i = 0; i < maxSteps && i < causalChain.length; i++) {
-            const causalLink = causalChain[i];
-            const step = {
-                id: `step_${i}`,
-                stepNumber: i + 1,
-                premise: `Cause: ${causalLink.cause}`,
-                inference: `Effect: ${causalLink.effect}`,
-                evidence: [{
-                        source: 'causal_analysis',
-                        excerpt: causalLink.mechanism,
-                        location: 'causal_chain',
-                        strength: causalLink.confidence
-                    }],
-                assumptions: ['Causal relationship is consistent', 'No confounding factors'],
-                confidence: causalLink.confidence,
-                nextSteps: causalChain.slice(i + 1).map(c => `Next effect: ${c.effect}`)
-            };
-            session.steps.push(step);
-        }
-    }
-    async executeCounterfactualReasoning(session, maxSteps) {
-        // What-if reasoning
-        const counterfactuals = this.generateCounterfactuals(session.problem);
-        for (let i = 0; i < maxSteps && i < counterfactuals.length; i++) {
-            const cf = counterfactuals[i];
-            const step = {
-                id: `step_${i}`,
-                stepNumber: i + 1,
-                premise: `Actual: ${cf.actual}`,
-                inference: `If ${cf.condition}, then ${cf.outcome}`,
-                evidence: [{
-                        source: 'counterfactual',
-                        excerpt: cf.reasoning,
-                        location: 'counterfactual_analysis',
-                        strength: cf.plausibility
-                    }],
-                assumptions: cf.assumptions,
-                confidence: cf.plausibility,
-                nextSteps: counterfactuals.slice(i + 1).map(c => `Alternative: If ${c.condition}`)
-            };
-            session.steps.push(step);
-        }
-    }
-    /**
-     * Create and test a hypothesis
-     */
-    createHypothesis(statement) {
-        return this.hypothesisManager.createHypothesis(statement);
-    }
-    addEvidenceToHypothesis(hypothesisId, evidence, supporting) {
-        this.hypothesisManager.addEvidence(hypothesisId, evidence, supporting);
-    }
-    /**
-     * Decompose a complex problem
-     */
-    decomposeProblem(problem) {
-        return this.decompositionEngine.decompose(problem);
-    }
-    /**
-     * Generate Chain of Thought for a question
-     */
-    generateChainOfThought(question, maxDepth) {
-        return this.cotGenerator.generate(question, maxDepth);
-    }
-    // Helper methods
-    generateId() {
-        return `reasoning_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    }
-    extractFacts(problem) {
-        // Simplified fact extraction
-        return problem
-            .split(/[.!?]+/)
-            .map(s => s.trim())
-            .filter(s => s.length > 10);
-    }
-    extractObservations(problem) {
-        return this.extractFacts(problem);
-    }
-    identifyPattern(observations) {
-        // Simplified pattern identification
-        const commonWords = this.findCommonElements(observations);
-        return {
-            description: `Common elements: ${commonWords.join(', ')}`,
-            confidence: Math.min(0.9, observations.length * 0.2)
-        };
-    }
-    findCommonElements(strings) {
-        if (strings.length === 0)
-            return [];
-        const wordSets = strings.map(s => new Set(s.toLowerCase().split(/\s+/)));
-        const common = Array.from(wordSets[0]).filter(word => wordSets.every(set => set.has(word)) && word.length > 4);
-        return common.slice(0, 5);
-    }
-    generateExplanations(observations) {
-        return [
-            {
-                description: `Explanation based on ${observations.length} observations`,
-                plausibility: 0.7,
-                supportingEvidence: observations.join('; '),
-                assumptions: ['Observations are accurate', 'No hidden factors']
-            }
-        ];
-    }
-    extractDomain(problem) {
-        const domains = ['business', 'technology', 'science', 'health', 'education', 'finance'];
-        const problemLower = problem.toLowerCase();
-        return domains.find(d => problemLower.includes(d)) || 'general';
-    }
-    findAnalogies(sourceDomain) {
-        const analogies = {
-            business: [
-                { target: 'ecosystem', property: 'interconnected components', similarity: 'both have interdependent parts' },
-                { target: 'organism', property: 'growth and adaptation', similarity: 'both evolve over time' }
-            ],
-            technology: [
-                { target: 'biology', property: 'modular components', similarity: 'both use building blocks' },
-                { target: 'language', property: 'syntax and structure', similarity: 'both have rules and patterns' }
-            ]
-        };
-        return (analogies[sourceDomain] || []).map(a => ({
-            targetDomain: a.target,
-            inferredProperty: a.property,
-            similarityDescription: a.similarity,
-            similarityScore: 0.7
-        }));
-    }
-    identifyCausalChain(problem) {
-        const causalIndicators = ['causes', 'leads to', 'results in', 'because', 'due to', 'therefore'];
-        const chain = [];
-        causalIndicators.forEach(indicator => {
-            const regex = new RegExp(`(.+?)\\s+${indicator}\\s+(.+?)[.!?]`, 'gi');
-            let match;
-            while ((match = regex.exec(problem)) !== null) {
-                chain.push({
-                    cause: match[1].trim(),
-                    effect: match[2].trim(),
-                    mechanism: `${match[1].trim()} ${indicator} ${match[2].trim()}`,
-                    confidence: 0.75
-                });
-            }
-        });
-        return chain.length > 0 ? chain : [{
-                cause: 'Initial condition',
-                effect: 'Observed outcome',
-                mechanism: 'Causal relationship inferred from context',
-                confidence: 0.5
-            }];
-    }
-    generateCounterfactuals(problem) {
-        return [
-            {
-                actual: problem,
-                condition: 'conditions were different',
-                outcome: 'outcome would change',
-                reasoning: 'Counterfactual analysis based on problem context',
-                plausibility: 0.6,
-                assumptions: ['Minimal change principle', 'Ceteris paribus']
-            }
-        ];
-    }
-    generateConclusion(session, cot) {
-        const stepConclusions = session.steps.map(s => s.inference);
-        if (cot?.finalAnswer) {
-            return `${cot.finalAnswer} Based on ${session.steps.length} reasoning steps.`;
-        }
-        return `After ${session.steps.length} steps of ${session.type} reasoning: ${stepConclusions.slice(-2).join('; ')}.`;
-    }
-    calculateSessionConfidence(session) {
-        if (session.steps.length === 0)
-            return 0;
-        const avgConfidence = session.steps.reduce((sum, s) => sum + s.confidence, 0) / session.steps.length;
-        return Math.min(0.95, avgConfidence);
-    }
-    /**
-     * Get reasoning session
-     */
-    getSession(sessionId) {
-        return this.sessions.get(sessionId);
-    }
-    /**
-     * Add custom logical rule
-     */
-    addRule(rule) {
-        this.rulesEngine.addRule(rule);
-    }
-}
-exports.ReasoningEngine = ReasoningEngine;
-// ============================================================================
-// EXPORT SINGLETON INSTANCE
-// ============================================================================
-exports.reasoningEngine = new ReasoningEngine();
-// ============================================================================
-// EXAMPLE USAGE
-// ============================================================================
-/*
-// Deductive reasoning
-const deductiveResult = await reasoningEngine.reason(
-  "All software requires maintenance. This application is software. Therefore...",
-  { type: ReasoningType.DEDUCTIVE }
-);
-
-// Inductive reasoning
-const inductiveResult = await reasoningEngine.reason(
-  "Every software project I've seen with good documentation succeeded. " +
-  "Projects with poor documentation often failed. Therefore...",
-  { type: ReasoningType.INDUCTIVE }
-);
-
-// Hypothesis testing
-const hypothesis = reasoningEngine.createHypothesis(
-  "Using TypeScript reduces bug count by 30%"
-);
-
-reasoningEngine.addEvidenceToHypothesis(
-  hypothesis.id,
-  {
-    source: 'study',
-    excerpt: 'TypeScript projects had 15% fewer bugs',
-    location: 'research_paper',
-    strength: 0.8
-  },
-  true
-);
-
-// Problem decomposition
-const decomposition = reasoningEngine.decomposeProblem(
-  "Build a scalable e-commerce platform with AI recommendations"
-);
-
-// Chain of Thought
-const cot = reasoningEngine.generateChainOfThought(
-  "How can we improve software development productivity?",
-  5
-);
-*/
-//# sourceMappingURL=reasoning.js.map