@gotza02/seq-thinking 1.1.0

package/src/sequential-thinking.ts

@@ -0,0 +1,560 @@
+/**
+ * Sequential Thinking Engine
+ */
+import { ThoughtType, Thought, ThoughtBranch, ConfidenceScore, MetaNote, ThinkingSession, SessionStatus, BranchStatus } from './types/index.js';
+import { calculateSimilarity } from './utils/index.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>();
+    reflect(session: ThinkingSession) {
+        const thoughts = Array.from(session.thoughts.values());
+        const insights: string[] = [];
+        const recommendations: string[] = [];
+        // Analyze thinking patterns
+        const analysisCount = thoughts.filter(t => (t as any).thoughtType === 'analysis').length;
+        const hypothesisCount = thoughts.filter(t => (t as any).thoughtType === 'hypothesis').length;
+        if (analysisCount > hypothesisCount * 2) {
+            insights.push('Heavy focus on analysis with limited hypothesis generation');
+            recommendations.push('Consider exploring more alternative hypotheses');
+        }
+        // Check confidence trends
+        const avgConfidence = thoughts.length > 0
+            ? thoughts.reduce((sum, t) => sum + (t as any).confidence.overall, 0) / thoughts.length
+            : 0;
+        if (avgConfidence < 0.5) {
+            insights.push('Overall confidence is low');
+            recommendations.push('Review assumptions and gather more evidence');
+        }
+        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 {
+    detectIssues(thought: Thought, graph: ThoughtGraph) {
+        const issues: any[] = [];
+        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'
+            });
+        }
+        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 {
+    calculateGranularity(topic: string, context: any, currentDepth: number) {
+        const hasComplexTerms = /\b(system|architecture|framework)\b/i.test(topic);
+        const detail = hasComplexTerms ? 0.8 : 0.5;
+        return { detail, reasoning: hasComplexTerms ? 'Complex topic detected' : 'Standard granularity' };
+    }
+    getRecommendation(session: ThinkingSession) {
+        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.5;
+        if (avgConfidence < 0.4) {
+            return {
+                suggestedAction: 'increase_detail',
+                detail: 0.9,
+                reasoning: 'Low confidence detected - need more detailed analysis'
+            };
+        }
+        if (thoughts.length > 10 && avgConfidence > 0.8) {
+            return {
+                suggestedAction: 'decrease_detail',
+                detail: 0.4,
+                reasoning: 'High confidence with many thoughts - can summarize'
+            };
+        }
+        return {
+            suggestedAction: 'maintain',
+            detail: 0.6,
+            reasoning: 'Current granularity is appropriate'
+        };
+    }
+}
+
+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 = 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