@gotza02/seq-thinking 1.1.4 → 1.1.6

package/src/sequential-thinking.ts

@@ -1,614 +0,0 @@
-/**
- * Sequential Thinking Engine
- */
-import { ThoughtType, Thought, ThoughtBranch, ConfidenceScore, MetaNote, ThinkingSession, SessionStatus, BranchStatus } from './types/index.js';
-import { calculateSimilarity } from './utils/index.js';
-import { LLMAdapter } from './utils/llm-adapter.js';
-import { Logger } from './utils/logger.js';
-
-export class ConfidenceCalibrator {
-    createInitialConfidence(): ConfidenceScore {
-        return {
-            overall: 0.5,
-            components: {
-                logicalConsistency: 0.5,
-                factualAccuracy: 0.5,
-                reasoningQuality: 0.5,
-                evidenceStrength: 0.5
-            },
-            uncertaintyBounds: [0.3, 0.7],
-            calibrationHistory: []
-        };
-    }
-    calculateOverall(components: any) {
-        const weights: Record<string, number> = {
-            logicalConsistency: 0.3,
-            factualAccuracy: 0.25,
-            reasoningQuality: 0.25,
-            evidenceStrength: 0.2
-        };
-        let weightedSum = 0;
-        for (const [key, value] of Object.entries(components)) {
-            weightedSum += (value as number) * weights[key];
-        }
-        return Math.min(1, Math.max(0, weightedSum));
-    }
-}
-
-export class ThoughtGraph {
-    thoughts = new Map<string, Thought>();
-    branches = new Map<string, ThoughtBranch>();
-    calibrator: ConfidenceCalibrator;
-    constructor() {
-        this.calibrator = new ConfidenceCalibrator();
-    }
-    createThought(sessionId: string, content: string, options: any = {}): Thought {
-        const id = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-        const now = new Date();
-        const branchId = options.branchId || 'main';
-        const thought: Thought = {
-            id,
-            sessionId,
-            content,
-            stepNumber: this.calculateStepNumber(sessionId, branchId, options.parentThoughtId),
-            thoughtType: options.thoughtType || ThoughtType.ANALYSIS,
-            confidence: this.createConfidence(options.confidence),
-            parentThoughtId: options.parentThoughtId || null,
-            childThoughtIds: [],
-            branchId,
-            revisionOf: null,
-            revisionHistory: [],
-            metadata: {
-                createdAt: now,
-                modifiedAt: now,
-                agentId: options.agentId,
-                processingTimeMs: 0,
-                tokensUsed: 0
-            },
-            tags: options.tags || [],
-            assumptions: options.assumptions || [],
-            dependencies: options.dependencies || []
-        };
-        this.thoughts.set(id, thought);
-        if (options.parentThoughtId) {
-            const parent = this.thoughts.get(options.parentThoughtId);
-            if (parent) {
-                parent.childThoughtIds.push(id);
-            }
-        }
-        return thought;
-    }
-    reviseThought(thoughtId: string, newContent: string, revisionReason: string): Thought {
-        const original = this.thoughts.get(thoughtId);
-        if (!original) {
-            throw new Error(`Thought not found: ${thoughtId}`);
-        }
-        const revisionId = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-        const now = new Date();
-        const record = {
-            previousContent: original.content,
-            revisedAt: now,
-            revisionReason
-        };
-        original.revisionHistory.push(record);
-        original.metadata.modifiedAt = now;
-
-        const revision: Thought = {
-            ...original,
-            id: revisionId,
-            content: newContent,
-            thoughtType: ThoughtType.REVISION,
-            revisionOf: thoughtId,
-            revisionHistory: [...original.revisionHistory],
-            metadata: {
-                ...original.metadata,
-                createdAt: now,
-                modifiedAt: now
-            }
-        };
-        this.thoughts.set(revisionId, revision);
-        return revision;
-    }
-    createBranch(sessionId: string, parentThoughtId: string, name: string, description: string, initialContent: string) {
-        const branchId = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-        const now = new Date();
-        const parentBranchId = this.getBranchIdForThought(parentThoughtId);
-        const branch: ThoughtBranch = {
-            id: branchId,
-            sessionId,
-            name,
-            description,
-            rootThoughtId: '',
-            thoughtIds: [],
-            parentBranchId: parentBranchId ?? null,
-            childBranchIds: [],
-            status: BranchStatus.ACTIVE,
-            confidence: 0.5,
-            metadata: { createdAt: now }
-        };
-        const thought = this.createThought(sessionId, initialContent, {
-            thoughtType: ThoughtType.BRANCH_POINT,
-            parentThoughtId,
-            branchId
-        });
-        branch.rootThoughtId = thought.id;
-        branch.thoughtIds.push(thought.id);
-        this.branches.set(branchId, branch);
-        const parentBranch = this.getBranchForThought(parentThoughtId);
-        if (parentBranch) {
-            parentBranch.childBranchIds.push(branchId);
-        }
-        return { branch, thought };
-    }
-    mergeBranches(targetBranchId: string, sourceBranchId: string, mergeContent: string) {
-        const target = this.branches.get(targetBranchId);
-        const source = this.branches.get(sourceBranchId);
-        if (!target || !source) {
-            throw new Error('Branch not found');
-        }
-        const mergeThought = this.createThought(target.sessionId, mergeContent, {
-            thoughtType: ThoughtType.MERGE_POINT,
-            branchId: targetBranchId
-        });
-        (source.status as any) = BranchStatus.MERGED;
-        source.metadata.completedAt = new Date();
-        return mergeThought;
-    }
-    pruneBranch(branchId: string, reason: string) {
-        const branch = this.branches.get(branchId);
-        if (!branch) {
-            throw new Error(`Branch not found: ${branchId}`);
-        }
-        (branch.status as any) = BranchStatus.PRUNED;
-        branch.metadata.prunedAt = new Date();
-        branch.metadata.pruneReason = reason;
-    }
-    getThinkingPath(thoughtId: string) {
-        const path: Thought[] = [];
-        let current = this.thoughts.get(thoughtId);
-        while (current) {
-            path.unshift(current);
-            current = current.parentThoughtId
-                ? this.thoughts.get(current.parentThoughtId)
-                : undefined;
-        }
-        return path;
-    }
-    getBranchComparison(branchIds: string[]) {
-        return branchIds.map(id => {
-            const branch = this.branches.get(id);
-            if (!branch)
-                return null;
-            const thoughts = branch.thoughtIds
-                .map(tid => this.thoughts.get(tid))
-                .filter((t): t is Thought => t !== undefined);
-            const avgConfidence = thoughts.length > 0
-                ? thoughts.reduce((sum, t) => sum + t.confidence.overall, 0) / thoughts.length
-                : 0;
-            const conclusion = thoughts.find(t => t.thoughtType === ThoughtType.CONCLUSION);
-            return {
-                branchId: id,
-                thoughtCount: thoughts.length,
-                averageConfidence: avgConfidence,
-                conclusion: conclusion?.content || null
-            };
-        }).filter((b): b is any => b !== null);
-    }
-    calculateStepNumber(sessionId: string, branchId: string, parentThoughtId: string | null | undefined): number {
-        if (!parentThoughtId) {
-            const branchThoughts = Array.from(this.thoughts.values())
-                .filter(t => t.sessionId === sessionId && t.branchId === branchId);
-            return branchThoughts.length + 1;
-        }
-        const parent = this.thoughts.get(parentThoughtId);
-        return parent ? parent.stepNumber + 1 : 1;
-    }
-    createConfidence(override: number | undefined): ConfidenceScore {
-        const confidence = this.calibrator.createInitialConfidence();
-        if (override !== undefined) {
-            confidence.overall = override;
-        }
-        return confidence;
-    }
-    getBranchIdForThought(thoughtId: string) {
-        const thought = this.thoughts.get(thoughtId);
-        return thought?.branchId;
-    }
-    getBranchForThought(thoughtId: string) {
-        const branchId = this.getBranchIdForThought(thoughtId);
-        return branchId ? this.branches.get(branchId) : undefined;
-    }
-    getThoughts() {
-        return this.thoughts;
-    }
-    getBranches() {
-        return this.branches;
-    }
-}
-
-export class MetaReasoningEngine {
-    metaNotes = new Map<string, MetaNote>();
-    
-    async reflect(session: ThinkingSession) {
-        const thoughts = Array.from(session.thoughts.values());
-        
-        // Basic analysis
-        const insights: string[] = [];
-        const recommendations: string[] = [];
-        
-        const analysisCount = thoughts.filter(t => t.thoughtType === ThoughtType.ANALYSIS).length;
-        const hypothesisCount = thoughts.filter(t => t.thoughtType === ThoughtType.HYPOTHESIS).length;
-        
-        if (analysisCount > hypothesisCount * 2) {
-            insights.push('Heavy focus on analysis with limited hypothesis generation');
-            recommendations.push('Consider exploring more alternative hypotheses');
-        }
-
-        const avgConfidence = thoughts.length > 0
-            ? thoughts.reduce((sum, t) => sum + t.confidence.overall, 0) / thoughts.length
-            : 0;
-            
-        if (avgConfidence < 0.5) {
-            insights.push('Overall confidence is low');
-            recommendations.push('Review assumptions and gather more evidence');
-        }
-
-        // Advanced LLM-powered reflection
-        try {
-            const prompt = `Reflect on the following thinking session and provide 3 key insights and 3 specific recommendations for improvement.\nTopic: ${session.topic}\nThoughts:\n${thoughts.map(t => `- [${t.thoughtType}] ${t.content.substring(0, 100)}...`).join('\n')}`;
-            const response = await LLMAdapter.call(prompt, "You are a meta-reasoning engine that analyzes thinking processes.");
-            
-            if (!response.error) {
-                insights.push(`LLM Insight: ${response.content}`);
-            }
-        } catch (e) {
-            Logger.warn('LLM Reflection failed', { error: String(e) });
-        }
-
-        return {
-            reflectionType: 'session_review',
-            content: `Analyzed ${thoughts.length} thoughts across ${session.branches.size} branches`,
-            insights,
-            recommendations
-        };
-    }
-
-    generateMetaObservation(thoughtId: string, thoughtGraph: ThoughtGraph) {
-        const thought = thoughtGraph.getThoughts().get(thoughtId);
-        if (!thought)
-            return null;
-        const observations: string[] = [];
-        if (thought.confidence.uncertaintyBounds[1] - thought.confidence.uncertaintyBounds[0] > 0.4) {
-            observations.push('High uncertainty detected');
-        }
-        const similarThoughts = Array.from(thoughtGraph.getThoughts().values())
-            .filter(t => t.id !== thought.id && calculateSimilarity(t.content, thought.content) > 0.7);
-        if (similarThoughts.length > 0) {
-            observations.push(`Similar to ${similarThoughts.length} previous thoughts`);
-        }
-        if (observations.length === 0)
-            return null;
-        const note: MetaNote = {
-            id: `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
-            thoughtId,
-            content: observations.join('\n'),
-            observationType: 'pattern',
-            timestamp: new Date(),
-            triggeredActions: []
-        };
-        this.metaNotes.set(note.id, note);
-        return note;
-    }
-}
-
-export class SelfCorrectionEngine {
-    async detectIssues(thought: Thought, graph: ThoughtGraph) {
-        const issues: any[] = [];
-        
-        // Fast heuristics
-        if (thought.confidence.overall < 0.3) {
-            issues.push({
-                type: 'calibration',
-                severity: 'medium',
-                description: 'Very low confidence',
-                suggestion: 'Re-examine reasoning'
-            });
-        }
-        if (thought.assumptions.length === 0 && thought.thoughtType !== ThoughtType.CONCLUSION) {
-            issues.push({
-                type: 'assumption',
-                severity: 'low',
-                description: 'No explicit assumptions',
-                suggestion: 'Document assumptions'
-            });
-        }
-
-        // Deeper LLM analysis for potential fallacies
-        if (thought.content.length > 100) {
-            try {
-                const prompt = `Analyze this thought for logical fallacies or inconsistencies. If any are found, describe them briefly and suggest a correction.\nThought: ${thought.content}`;
-                const response = await LLMAdapter.call(prompt, "You are a critical thinking assistant. Be concise.");
-                
-                if (!response.error && response.content.toLowerCase().includes('fallacy') || response.content.toLowerCase().includes('inconsistency')) {
-                    issues.push({
-                        type: 'logic',
-                        severity: 'medium',
-                        description: `Potential logical issue: ${response.content.substring(0, 100)}...`,
-                        suggestion: 'Review the reasoning for potential fallacies.'
-                    });
-                }
-            } catch (e) {
-                Logger.warn('LLM Self-Correction analysis failed', { error: String(e) });
-            }
-        }
-
-        return issues;
-    }
-    checkSessionHealth(session: ThinkingSession) {
-        const issues: string[] = [];
-        const suggestions: string[] = [];
-        const thoughts = Array.from(session.thoughts.values());
-        // Check for low confidence thoughts
-        const lowConfidenceCount = thoughts.filter(t => (t as any).confidence.overall < 0.4).length;
-        if (lowConfidenceCount > thoughts.length * 0.5) {
-            issues.push('More than 50% of thoughts have low confidence');
-            suggestions.push('Review and strengthen reasoning for low-confidence thoughts');
-        }
-        // Check for abandoned branches
-        const abandonedBranches = Array.from(session.branches.values())
-            .filter(b => (b as any).status === BranchStatus.ACTIVE && (b as any).thoughtIds.length === 0);
-        if (abandonedBranches.length > 0) {
-            issues.push(`${abandonedBranches.length} branches are empty`);
-            suggestions.push('Either develop abandoned branches or mark them as pruned`');
-        }
-        // Calculate overall confidence
-        const avgConfidence = thoughts.length > 0
-            ? thoughts.reduce((sum, t) => sum + (t as any).confidence.overall, 0) / thoughts.length
-            : 0.5;
-        const isHealthy = issues.length === 0 && avgConfidence >= 0.5;
-        return {
-            isHealthy,
-            issues,
-            suggestions,
-            confidence: avgConfidence
-        };
-    }
-}
-
-export class AdaptiveGranularityEngine {
-    async calculateGranularity(topic: string, context: any, currentDepth: number) {
-        // Basic heuristic
-        let detail = 0.5;
-        let reasoning = 'Standard granularity';
-
-        const hasComplexTerms = /\b(system|architecture|framework|optimization|deep learning|quantum)\b/i.test(topic);
-        if (hasComplexTerms) {
-            detail = 0.8;
-            reasoning = 'Complex topic keywords detected';
-        }
-
-        // LLM evaluation of complexity
-        try {
-            const prompt = `On a scale of 0.1 to 1.0, how complex is this topic? Provide only the number and a short reason.\nTopic: ${topic}`;
-            const response = await LLMAdapter.call(prompt, "You are an expert at assessing problem complexity.");
-            
-            if (!response.error) {
-                const match = response.content.match(/0?\.\d+|1\.0/);
-                if (match) {
-                    detail = parseFloat(match[0]);
-                    reasoning = `LLM Complexity Assessment: ${response.content}`;
-                }
-            }
-        } catch (e) {
-            Logger.warn('LLM Granularity calculation failed', { error: String(e) });
-        }
-
-        return { detail, reasoning };
-    }
-
-    getRecommendation(session: ThinkingSession) {
-        const hasComplexTerms = /\b(system|architecture|framework|optimization|deep learning|quantum)\b/i.test(session.topic);
-        const detail = hasComplexTerms ? 0.8 : 0.5;
-        
-        return {
-            suggestedAction: detail > 0.7 ? 'increase_granularity' : 'maintain_granularity',
-            detail,
-            reasoning: hasComplexTerms ? 'Complex topic detected' : 'Standard complexity'
-        };
-    }
-}
-
-import { PersistenceManager } from './utils/persistence.js';
-
-export class SessionManager {
-    sessions = new Map<string, ThinkingSession>();
-    graph: ThoughtGraph;
-    metaEngine: MetaReasoningEngine;
-    correctionEngine: SelfCorrectionEngine;
-    granularityEngine: AdaptiveGranularityEngine;
-    persistence: PersistenceManager | null = null;
-
-    constructor(persistenceDir?: string) {
-        this.graph = new ThoughtGraph();
-        this.metaEngine = new MetaReasoningEngine();
-        this.correctionEngine = new SelfCorrectionEngine();
-        this.granularityEngine = new AdaptiveGranularityEngine();
-        if (persistenceDir) {
-            this.persistence = new PersistenceManager(persistenceDir);
-        }
-    }
-
-    async initialize() {
-        if (this.persistence) {
-            await this.persistence.initialize(['sessions']);
-            await this.loadSessions();
-        }
-    }
-
-    async loadSessions() {
-        if (!this.persistence) return;
-        const ids = await this.persistence.list('sessions');
-        for (const id of ids) {
-            const session = await this.persistence.load<ThinkingSession>('sessions', id);
-            if (session) {
-                // Restore Maps from serialized format
-                if ((session.thoughts as any)._type === 'Map') {
-                    session.thoughts = new Map((session.thoughts as any).data);
-                } else if (!(session.thoughts instanceof Map)) {
-                    session.thoughts = new Map(Object.entries(session.thoughts));
-                }
-
-                if ((session.branches as any)._type === 'Map') {
-                    session.branches = new Map((session.branches as any).data);
-                } else if (!(session.branches instanceof Map)) {
-                    session.branches = new Map(Object.entries(session.branches));
-                }
-
-                if ((session.metaNotes as any)._type === 'Map') {
-                    session.metaNotes = new Map((session.metaNotes as any).data);
-                } else if (!(session.metaNotes instanceof Map)) {
-                    session.metaNotes = new Map(Object.entries(session.metaNotes));
-                }
-                
-                this.sessions.set(id, session);
-            }
-        }
-    }
-
-    async createSession(topic: string, options: any = {}) {
-        const id = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-        const now = new Date();
-        const session: ThinkingSession = {
-            id,
-            topic,
-            status: SessionStatus.INITIALIZING,
-            currentBranchId: 'main',
-            branches: new Map(),
-            thoughts: new Map(),
-            metaNotes: new Map(),
-            context: {
-                originalProblem: topic,
-                constraints: [],
-                relevantInformation: [],
-                workingMemory: new Map(),
-                longTermReferences: []
-            },
-            settings: {
-                maxBranches: 5,
-                maxDepth: 20,
-                confidenceThreshold: 0.6,
-                enableSelfCorrection: true,
-                enableMetaReasoning: true,
-                enableParallelHypotheses: true,
-                adaptiveGranularity: true,
-                granularitySettings: {
-                    minStepDetail: 0.1,
-                    maxStepDetail: 1.0,
-                    complexityThreshold: 0.7
-                },
-                ...options
-            },
-            metadata: {
-                createdAt: now,
-                lastActivityAt: now,
-                totalThoughts: 0,
-                totalBranches: 1
-            }
-        };
-        const mainBranch: ThoughtBranch = {
-            id: 'main',
-            sessionId: id,
-            name: 'Main',
-            description: 'Primary reasoning path',
-            rootThoughtId: '',
-            thoughtIds: [],
-            parentBranchId: null,
-            childBranchIds: [],
-            status: BranchStatus.ACTIVE,
-            confidence: 0.5,
-            metadata: { createdAt: now }
-        };
-        session.branches.set('main', mainBranch);
-        this.sessions.set(id, session);
-        
-        if (this.persistence) {
-            await this.persistence.save('sessions', id, session);
-        }
-        
-        return session;
-    }
-
-    async addThought(sessionId: string, content: string, options: any = {}) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${sessionId}`);
-        }
-        const thought = this.graph.createThought(sessionId, content, options);
-        session.thoughts.set(thought.id, thought);
-        session.metadata.totalThoughts++;
-        session.metadata.lastActivityAt = new Date();
-        let metaNote = undefined;
-        let issues = undefined;
-        if (session.settings.enableMetaReasoning) {
-            const generatedMetaNote = this.metaEngine.generateMetaObservation(thought.id, this.graph);
-            if (generatedMetaNote) {
-                metaNote = generatedMetaNote;
-                session.metaNotes.set(metaNote.id, metaNote);
-            }
-        }
-        if (session.settings.enableSelfCorrection) {
-            issues = await this.correctionEngine.detectIssues(thought, this.graph);
-        }
-        
-        if (this.persistence) {
-            await this.persistence.save('sessions', sessionId, session);
-        }
-        
-        return { thought, metaNote, issues };
-    }
-
-    getSession(sessionId: string) {
-        return this.sessions.get(sessionId);
-    }
-
-    getThoughtGraph() {
-        return this.graph;
-    }
-
-    getMetaEngine() {
-        return this.metaEngine;
-    }
-
-    async completeSession(sessionId: string) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${sessionId}`);
-        }
-        (session.status as any) = SessionStatus.COMPLETED;
-        session.metadata.completedAt = new Date();
-        
-        if (this.persistence) {
-            await this.persistence.save('sessions', sessionId, session);
-        }
-    }
-    getSessionStatus(sessionId: string) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${sessionId}`);
-        }
-        const thoughts = Array.from(session.thoughts.values());
-        const avgConfidence = thoughts.length > 0
-            ? thoughts.reduce((sum, t) => sum + (t as any).confidence.overall, 0) / thoughts.length
-            : 0;
-        return {
-            id: session.id,
-            status: session.status,
-            totalThoughts: session.metadata.totalThoughts,
-            branches: Array.from(session.branches.keys()),
-            averageConfidence: avgConfidence,
-            lastActivity: session.metadata.lastActivityAt
-        };
-    }
-}
-
-//# sourceMappingURL=sequential-thinking.js.map