gthinking 1.0.0

package/dist/reasoning.js

@@ -0,0 +1,792 @@
+"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");
+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
+            let cot;
+            if (generateCOT) {
+                cot = this.cotGenerator.generate(problem, maxSteps);
+            }
+            // Execute reasoning based on type
+            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
+            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 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