gthinking 1.3.0 → 2.1.1

package/dist/creativity.js

@@ -1,828 +0,0 @@
-"use strict";
-/**
- * Creativity Module
- * Out-of-the-box thinking, idea generation, and concept connection
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.creativityEngine = exports.CreativityEngine = void 0;
-const types_1 = require("./types");
-const events_1 = require("events");
-const llm_service_1 = require("./llm-service");
-// ============================================================================
-// BRAINSTORMING ENGINE
-// ============================================================================
-class BrainstormingEngine {
-    constructor() {
-        this.ideaSeeds = new Map([
-            ['technology', ['AI', 'blockchain', 'IoT', 'cloud', 'quantum', 'biotech', 'nanotech']],
-            ['business', ['subscription', 'freemium', 'marketplace', 'platform', 'ecosystem']],
-            ['social', ['community', 'collaboration', 'sharing', 'crowdsourcing', 'network']],
-            ['design', ['minimalist', 'responsive', 'adaptive', 'personalized', 'immersive']]
-        ]);
-    }
-    generateIdeas(prompt, count = 10) {
-        const ideas = [];
-        const domains = this.identifyDomains(prompt);
-        // Generate ideas using different approaches
-        for (let i = 0; i < count; i++) {
-            const technique = this.selectTechnique(i);
-            const idea = this.createIdea(prompt, technique, domains, i);
-            ideas.push(idea);
-        }
-        return ideas;
-    }
-    identifyDomains(prompt) {
-        const domains = [];
-        const promptLower = prompt.toLowerCase();
-        this.ideaSeeds.forEach((_, domain) => {
-            if (promptLower.includes(domain)) {
-                domains.push(domain);
-            }
-        });
-        return domains.length > 0 ? domains : ['general'];
-    }
-    selectTechnique(index) {
-        const techniques = [
-            'brainstorming',
-            'analogy',
-            'reverse_thinking',
-            'random_stimulus',
-            'lateral_thinking'
-        ];
-        return techniques[index % techniques.length];
-    }
-    createIdea(prompt, technique, domains, index) {
-        const content = this.generateIdeaContent(prompt, technique, domains, index);
-        return {
-            id: `idea_${Date.now()}_${index}`,
-            content,
-            technique,
-            novelty: this.calculateNovelity(content),
-            feasibility: this.calculateFeasibility(content),
-            impact: this.calculateImpact(content),
-            relatedIdeas: [],
-            tags: this.extractTags(content),
-            generatedAt: new Date()
-        };
-    }
-    generateIdeaContent(prompt, technique, domains, index) {
-        switch (technique) {
-            case 'brainstorming':
-                return this.brainstorm(prompt, domains, index);
-            case 'analogy':
-                return this.useAnalogy(prompt, domains, index);
-            case 'reverse_thinking':
-                return this.reverseThink(prompt);
-            case 'random_stimulus':
-                return this.randomStimulus(prompt, domains);
-            case 'lateral_thinking':
-                return this.lateralThink(prompt, index);
-            default:
-                return `Idea ${index + 1}: ${prompt}`;
-        }
-    }
-    brainstorm(prompt, domains, index) {
-        const domain = domains[index % domains.length];
-        const seeds = this.ideaSeeds.get(domain) || ['innovation'];
-        const seed = seeds[index % seeds.length];
-        return `Combine ${prompt} with ${seed} to create a ${domain} solution`;
-    }
-    useAnalogy(prompt, domains, index) {
-        const analogies = [
-            'like a nervous system for information flow',
-            'like an immune system for security',
-            'like an ecosystem for sustainability',
-            'like a language for communication',
-            'like a market for resource allocation'
-        ];
-        return `Approach ${prompt} ${analogies[index % analogies.length]}`;
-    }
-    reverseThink(prompt) {
-        return `Instead of ${prompt}, what if we did the opposite? ` +
-            `Consider: How could we achieve the inverse outcome?`;
-    }
-    randomStimulus(prompt, domains) {
-        const stimuli = ['nature', 'art', 'music', 'sports', 'cooking', 'architecture'];
-        const stimulus = stimuli[Math.floor(Math.random() * stimuli.length)];
-        return `Apply principles from ${stimulus} to ${prompt}`;
-    }
-    lateralThink(prompt, index) {
-        const perspectives = [
-            'from a child\'s perspective',
-            'from a future perspective (10 years ahead)',
-            'from a resource-constrained perspective',
-            'from a luxury perspective',
-            'from a minimalist perspective'
-        ];
-        return `View ${prompt} ${perspectives[index % perspectives.length]}`;
-    }
-    calculateNovelity(content) {
-        // Higher novelty for more unique combinations
-        const uniqueTerms = new Set(content.toLowerCase().split(/\s+/)).size;
-        const totalTerms = content.split(/\s+/).length;
-        return Math.min(0.95, uniqueTerms / totalTerms + 0.3);
-    }
-    calculateFeasibility(content) {
-        // Lower feasibility for very abstract ideas
-        const abstractTerms = ['quantum', 'neural', 'blockchain', 'revolutionary', 'paradigm'];
-        const abstractCount = abstractTerms.filter(term => content.toLowerCase().includes(term)).length;
-        return Math.max(0.3, 0.9 - abstractCount * 0.1);
-    }
-    calculateImpact(content) {
-        // Higher impact for ideas addressing broad audiences or major problems
-        const impactIndicators = ['global', 'scalable', 'transform', 'revolutionary', 'fundamental'];
-        const matches = impactIndicators.filter(ind => content.toLowerCase().includes(ind)).length;
-        return Math.min(0.95, 0.5 + matches * 0.1);
-    }
-    extractTags(content) {
-        return content
-            .toLowerCase()
-            .match(/\b\w{5,}\b/g)
-            ?.filter((w, i, arr) => arr.indexOf(w) === i)
-            ?.slice(0, 5) || [];
-    }
-}
-class MindMappingEngine {
-    createMindMap(centerConcept, depth = 3) {
-        const root = {
-            id: 'root',
-            label: centerConcept,
-            children: [],
-            connections: []
-        };
-        this.expandNode(root, depth, 0);
-        return root;
-    }
-    expandNode(node, maxDepth, currentDepth) {
-        if (currentDepth >= maxDepth)
-            return;
-        const branches = this.generateBranches(node.label, currentDepth);
-        branches.forEach(branchLabel => {
-            const child = {
-                id: `node_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`,
-                label: branchLabel,
-                children: [],
-                connections: []
-            };
-            node.children.push(child);
-            this.expandNode(child, maxDepth, currentDepth + 1);
-        });
-    }
-    generateBranches(concept, depth) {
-        const branchTypes = {
-            0: [['What', 'Why', 'How', 'When', 'Where']],
-            1: [['Components', 'Features', 'Benefits', 'Challenges']],
-            2: [['Examples', 'Alternatives', 'Applications', 'Implications']]
-        };
-        const branches = branchTypes[depth] || [['Details', 'Related', 'Future']];
-        const selectedBranch = branches[0];
-        return selectedBranch.map(b => `${b} of ${concept}`);
-    }
-    findConnections(node1, node2) {
-        const connections = [];
-        const concepts1 = this.extractAllConcepts(node1);
-        const concepts2 = this.extractAllConcepts(node2);
-        concepts1.forEach(c1 => {
-            concepts2.forEach(c2 => {
-                const similarity = this.calculateConceptSimilarity(c1, c2);
-                if (similarity > 0.5) {
-                    connections.push(`Connection: ${c1} ↔ ${c2}`);
-                }
-            });
-        });
-        return connections;
-    }
-    extractAllConcepts(node) {
-        const concepts = [node.label];
-        node.children.forEach(child => {
-            concepts.push(...this.extractAllConcepts(child));
-        });
-        return concepts;
-    }
-    calculateConceptSimilarity(c1, c2) {
-        const words1 = c1.toLowerCase().split(/\s+/);
-        const words2 = c2.toLowerCase().split(/\s+/);
-        const intersection = words1.filter(w => words2.includes(w));
-        return intersection.length / Math.max(words1.length, words2.length);
-    }
-}
-class ScamperEngine {
-    constructor() {
-        this.scamperPrompts = [
-            { letter: 'S', action: 'Substitute', prompt: 'What can be substituted?' },
-            { letter: 'C', action: 'Combine', prompt: 'What can be combined?' },
-            { letter: 'A', action: 'Adapt', prompt: 'What can be adapted?' },
-            { letter: 'M', action: 'Modify', prompt: 'What can be modified?' },
-            { letter: 'P', action: 'Put to other uses', prompt: 'What other uses are possible?' },
-            { letter: 'E', action: 'Eliminate', prompt: 'What can be eliminated?' },
-            { letter: 'R', action: 'Reverse/Rearrange', prompt: 'What can be reversed or rearranged?' }
-        ];
-    }
-    apply(problem) {
-        return this.scamperPrompts.map(prompt => ({
-            technique: `${prompt.letter} - ${prompt.action}`,
-            question: prompt.prompt,
-            idea: this.generateScamperIdea(problem, prompt)
-        }));
-    }
-    generateScamperIdea(problem, prompt) {
-        const ideaTemplates = {
-            'Substitute': [
-                `Replace a key component of ${problem} with something unexpected`,
-                `Use alternative materials or methods for ${problem}`
-            ],
-            'Combine': [
-                `Merge ${problem} with a completely different concept`,
-                `Integrate multiple versions of ${problem}`
-            ],
-            'Adapt': [
-                `Apply ${problem} in a different context`,
-                `Borrow ideas from other fields for ${problem}`
-            ],
-            'Modify': [
-                `Change the scale or magnitude of ${problem}`,
-                `Alter the attributes of ${problem}`
-            ],
-            'Put to other uses': [
-                `How else could ${problem} be used?`,
-                `Who else could benefit from ${problem}?`
-            ],
-            'Eliminate': [
-                `Remove unnecessary parts of ${problem}`,
-                `Simplify ${problem} to its essence`
-            ],
-            'Reverse/Rearrange': [
-                `Do the opposite of ${problem}`,
-                `Change the order of steps in ${problem}`
-            ]
-        };
-        const templates = ideaTemplates[prompt.action] || ['Consider a new approach'];
-        return templates[Math.floor(Math.random() * templates.length)];
-    }
-}
-class SixThinkingHatsEngine {
-    constructor() {
-        this.hats = [
-            { color: 'White', perspective: 'Objective', focus: 'facts and data' },
-            { color: 'Red', perspective: 'Emotional', focus: 'feelings and intuition' },
-            { color: 'Black', perspective: 'Critical', focus: 'risks and problems' },
-            { color: 'Yellow', perspective: 'Optimistic', focus: 'benefits and value' },
-            { color: 'Green', perspective: 'Creative', focus: 'new ideas and alternatives' },
-            { color: 'Blue', perspective: 'Process', focus: 'overview and control' }
-        ];
-    }
-    analyze(topic) {
-        return this.hats.map(hat => ({
-            hat: hat.color,
-            perspective: hat.perspective,
-            insights: this.generateInsights(topic, hat)
-        }));
-    }
-    generateInsights(topic, hat) {
-        const insights = [];
-        switch (hat.color) {
-            case 'White':
-                insights.push(`What data do we have about ${topic}?`, `What information is missing about ${topic}?`, `What are the verifiable facts?`);
-                break;
-            case 'Red':
-                insights.push(`What is my gut feeling about ${topic}?`, `What emotions does ${topic} evoke?`, `What is my intuitive reaction?`);
-                break;
-            case 'Black':
-                insights.push(`What are the risks with ${topic}?`, `What could go wrong with ${topic}?`, `What are the potential problems?`);
-                break;
-            case 'Yellow':
-                insights.push(`What are the benefits of ${topic}?`, `What value does ${topic} provide?`, `What are the opportunities?`);
-                break;
-            case 'Green':
-                insights.push(`What creative alternatives exist for ${topic}?`, `What new ideas can we generate?`, `How can we think differently about this?`);
-                break;
-            case 'Blue':
-                insights.push(`What is our process for addressing ${topic}?`, `How should we organize our thinking?`, `What is the big picture?`);
-                break;
-        }
-        return insights;
-    }
-}
-// ============================================================================
-// CONCEPT CONNECTOR
-// ============================================================================
-class ConceptConnector {
-    constructor() {
-        this.conceptDatabase = new Map([
-            ['innovation', ['change', 'progress', 'novelty', 'improvement', 'disruption']],
-            ['technology', ['tools', 'systems', 'automation', 'digital', 'advancement']],
-            ['design', ['aesthetics', 'function', 'user', 'experience', 'form']],
-            ['business', ['value', 'profit', 'market', 'customers', 'growth']],
-            ['sustainability', ['environment', 'future', 'resources', 'balance', 'responsibility']]
-        ]);
-    }
-    findConnections(concepts) {
-        const connections = [];
-        for (let i = 0; i < concepts.length; i++) {
-            for (let j = i + 1; j < concepts.length; j++) {
-                const connection = this.analyzeConnection(concepts[i], concepts[j]);
-                if (connection.strength > 0.3) {
-                    connections.push(connection);
-                }
-            }
-        }
-        return connections.sort((a, b) => b.strength - a.strength);
-    }
-    analyzeConnection(concept1, concept2) {
-        const attributes1 = this.getConceptAttributes(concept1);
-        const attributes2 = this.getConceptAttributes(concept2);
-        // Find common attributes
-        const common = attributes1.filter(a => attributes2.includes(a));
-        const all = [...new Set([...attributes1, ...attributes2])];
-        const strength = common.length / all.length;
-        // Determine connection type
-        let connectionType = 'similarity';
-        if (strength > 0.7) {
-            connectionType = 'similarity';
-        }
-        else if (strength < 0.3) {
-            connectionType = 'contrast';
-        }
-        else {
-            connectionType = 'combination';
-        }
-        return {
-            id: `conn_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`,
-            from: concept1,
-            to: concept2,
-            connectionType,
-            strength,
-            insight: this.generateInsight(concept1, concept2, common, connectionType)
-        };
-    }
-    getConceptAttributes(concept) {
-        const lowerConcept = concept.toLowerCase();
-        for (const [key, attributes] of this.conceptDatabase.entries()) {
-            if (lowerConcept.includes(key) || key.includes(lowerConcept)) {
-                return attributes;
-            }
-        }
-        // Generate attributes from concept itself
-        return concept.toLowerCase().split(/\s+/).filter(w => w.length > 3);
-    }
-    generateInsight(c1, c2, common, type) {
-        switch (type) {
-            case 'similarity':
-                return `${c1} and ${c2} share ${common.length > 0 ? `common ground in ${common.join(', ')}` : 'fundamental similarities'}`;
-            case 'contrast':
-                return `${c1} and ${c2} represent different approaches that could complement each other`;
-            case 'combination':
-                return `Combining ${c1} with ${c2} could create something unique`;
-            default:
-                return `Interesting relationship between ${c1} and ${c2}`;
-        }
-    }
-    generateNovelCombinations(concepts, count = 3) {
-        const combinations = [];
-        for (let i = 0; i < count; i++) {
-            const c1 = concepts[Math.floor(Math.random() * concepts.length)];
-            const c2 = concepts[Math.floor(Math.random() * concepts.length)];
-            if (c1 !== c2) {
-                combinations.push(`Combine ${c1} with ${c2} to create: ${this.generateCombinationName(c1, c2)}`);
-            }
-        }
-        return combinations;
-    }
-    generateCombinationName(c1, c2) {
-        const prefixes = ['Smart', 'Dynamic', 'Integrated', 'Adaptive', 'Holistic'];
-        const prefix = prefixes[Math.floor(Math.random() * prefixes.length)];
-        return `${prefix} ${c1.split(' ')[0]}-${c2.split(' ')[0]} Solution`;
-    }
-}
-// ============================================================================
-// OUT-OF-BOX THINKING ENGINE
-// ============================================================================
-class OutOfBoxEngine {
-    constructor() {
-        this.perspectives = [
-            'Beginner\'s mind - forget what you know',
-            'Child\'s perspective - simple and curious',
-            'Alien perspective - no assumptions',
-            'Future perspective - 50 years ahead',
-            'Resource-constrained - extreme limitations',
-            'Opposite approach - do the reverse',
-            'Nature-inspired - biomimicry',
-            'Artistic perspective - beauty and emotion'
-        ];
-    }
-    reframe(problem) {
-        const reframedProblems = [];
-        this.perspectives.forEach((perspective, index) => {
-            const reframed = this.reframeFromPerspective(problem, perspective);
-            reframedProblems.push({
-                id: `reframe_${Date.now()}_${index}`,
-                perspective,
-                reframedStatement: reframed.statement,
-                assumptionsChallenged: reframed.assumptions,
-                newPossibilities: reframed.possibilities
-            });
-        });
-        const unconventionalApproaches = this.generateUnconventionalApproaches(problem);
-        const breakthroughPotential = this.calculateBreakthroughPotential(reframedProblems);
-        return {
-            id: `ootb_${Date.now()}`,
-            originalProblem: problem,
-            reframedProblems,
-            unconventionalApproaches,
-            breakthroughPotential
-        };
-    }
-    reframeFromPerspective(problem, perspective) {
-        const reframes = {
-            'Beginner\'s mind': {
-                statement: `If you knew nothing about this, how would you approach: ${problem}?`,
-                assumptions: ['Expert knowledge is necessary', 'Current methods are optimal'],
-                possibilities: ['Fresh approaches', 'Questioning fundamentals']
-            },
-            'Child\'s perspective': {
-                statement: `How would a 5-year-old solve: ${problem}?`,
-                assumptions: ['Complexity is required', 'Adult approaches are better'],
-                possibilities: ['Simple solutions', 'Playful approaches']
-            },
-            'Alien perspective': {
-                statement: `How would beings from another planet view: ${problem}?`,
-                assumptions: ['Human perspective is universal', 'Our constraints are absolute'],
-                possibilities: ['Radically different approaches', 'Question all assumptions']
-            },
-            'Future perspective': {
-                statement: `How will people in 2074 solve: ${problem}?`,
-                assumptions: ['Current technology limits', 'Present constraints are permanent'],
-                possibilities: ['Future technologies', 'Long-term thinking']
-            },
-            'Resource-constrained': {
-                statement: `How would you solve ${problem} with 1% of current resources?`,
-                assumptions: ['Adequate resources are needed', 'Scale is important'],
-                possibilities: ['Minimalist solutions', 'Extreme efficiency']
-            },
-            'Opposite approach': {
-                statement: `What if the solution to ${problem} is the exact opposite of what we think?`,
-                assumptions: ['Our direction is correct', 'Conventional wisdom applies'],
-                possibilities: ['Counter-intuitive solutions', 'Paradigm shifts']
-            },
-            'Nature-inspired': {
-                statement: `How does nature solve problems similar to ${problem}?`,
-                assumptions: ['Human-designed solutions are superior', 'Technology is the answer'],
-                possibilities: ['Biomimicry', 'Natural patterns']
-            },
-            'Artistic perspective': {
-                statement: `How would an artist approach ${problem}?`,
-                assumptions: ['Technical solutions only', 'Function over form'],
-                possibilities: ['Aesthetic solutions', 'Emotional design']
-            }
-        };
-        return reframes[perspective] || {
-            statement: `Reframe: ${problem}`,
-            assumptions: ['Standard approach'],
-            possibilities: ['Alternative approaches']
-        };
-    }
-    generateUnconventionalApproaches(problem) {
-        return [
-            `What if ${problem} is actually an opportunity in disguise?`,
-            `How can ${problem} be made worse, then reverse that?`,
-            `What would make ${problem} solve itself?`,
-            `Who benefits from ${problem} existing?`,
-            `What if the problem and solution are the same thing?`
-        ];
-    }
-    calculateBreakthroughPotential(reframedProblems) {
-        const totalAssumptions = reframedProblems.reduce((sum, rp) => sum + rp.assumptionsChallenged.length, 0);
-        const totalPossibilities = reframedProblems.reduce((sum, rp) => sum + rp.newPossibilities.length, 0);
-        return Math.min(0.95, (totalAssumptions * 0.05 + totalPossibilities * 0.1));
-    }
-}
-// ============================================================================
-// MAIN CREATIVITY ENGINE
-// ============================================================================
-class CreativityEngine extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.sessions = new Map();
-        this.brainstormingEngine = new BrainstormingEngine();
-        this.mindMappingEngine = new MindMappingEngine();
-        this.scamperEngine = new ScamperEngine();
-        this.sixHatsEngine = new SixThinkingHatsEngine();
-        this.conceptConnector = new ConceptConnector();
-        this.outOfBoxEngine = new OutOfBoxEngine();
-    }
-    /**
-     * Start a creative session
-     */
-    async startSession(prompt, options = {}) {
-        const { techniques = ['brainstorming', 'analogy', 'scamper'], ideaCount = 15, duration = 30 } = options;
-        const sessionId = this.generateId();
-        const startTime = Date.now();
-        this.emit('creativity_start', {
-            id: sessionId,
-            stage: types_1.ThinkingStage.CREATIVITY,
-            timestamp: new Date(),
-            data: { prompt, techniques }
-        });
-        // Generate ideas
-        let ideas = [];
-        try {
-            ideas = await this.generateIdeasWithLLM(prompt, techniques, ideaCount);
-        }
-        catch (error) {
-            console.warn('LLM creativity failed, falling back to internal engine', error);
-        }
-        if (ideas.length === 0) {
-            techniques.forEach(technique => {
-                const techniqueIdeas = this.generateIdeasWithTechnique(prompt, technique, Math.ceil(ideaCount / techniques.length));
-                ideas.push(...techniqueIdeas);
-            });
-        }
-        // Find connections between ideas
-        const connections = this.findConnections(ideas);
-        // Divergent phase
-        const divergentPhase = {
-            startTime: new Date(startTime),
-            endTime: new Date(),
-            ideaCount: ideas.length,
-            explorationBreadth: techniques.length
-        };
-        // Convergent phase - select best ideas
-        const selectedIdeas = this.selectBestIdeas(ideas, 5);
-        const synthesis = this.synthesizeIdeas(selectedIdeas);
-        const convergentPhase = {
-            startTime: new Date(),
-            endTime: new Date(),
-            selectedIdeas: selectedIdeas.map(i => i.id),
-            synthesis,
-            actionItems: this.generateActionItems(selectedIdeas)
-        };
-        const session = {
-            id: sessionId,
-            prompt,
-            techniques,
-            ideas,
-            connections,
-            sessionDuration: Date.now() - startTime,
-            divergentPhase,
-            convergentPhase
-        };
-        this.sessions.set(sessionId, session);
-        this.emit('creativity_complete', {
-            id: sessionId,
-            stage: types_1.ThinkingStage.CREATIVITY,
-            timestamp: new Date(),
-            data: {
-                ideaCount: ideas.length,
-                connectionCount: connections.length,
-                topIdeas: selectedIdeas.map(i => i.content.substring(0, 50))
-            }
-        });
-        return session;
-    }
-    async generateIdeasWithLLM(prompt, techniques, count) {
-        const promptText = `
-      You are a creativity engine.
-      Prompt: "${prompt}"
-      Techniques to use: ${techniques.join(', ')}
-      Target count: ${count} ideas
-      
-      Return strictly JSON with structure:
-      {
-        "ideas": [
-          {
-            "content": "string (the idea description)",
-            "technique": "string (which technique was used)",
-            "novelty": number (0-1),
-            "feasibility": number (0-1),
-            "impact": number (0-1),
-            "tags": ["string"]
-          }
-        ]
-      }
-    `;
-        const response = await llm_service_1.llmService.generateText({ prompt: promptText });
-        const jsonMatch = response.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-            const result = JSON.parse(jsonMatch[0]);
-            if (Array.isArray(result.ideas)) {
-                return result.ideas.map((item, index) => ({
-                    id: `idea_llm_${Date.now()}_${index}`,
-                    content: item.content,
-                    technique: item.technique,
-                    novelty: item.novelty || 0.7,
-                    feasibility: item.feasibility || 0.7,
-                    impact: item.impact || 0.7,
-                    relatedIdeas: [],
-                    tags: item.tags || [],
-                    generatedAt: new Date()
-                }));
-            }
-        }
-        return [];
-    }
-    /**
-     * Generate ideas using a specific technique
-     */
-    generateIdeasWithTechnique(prompt, technique, count) {
-        switch (technique) {
-            case 'brainstorming':
-            case 'analogy':
-            case 'reverse_thinking':
-            case 'random_stimulus':
-            case 'lateral_thinking':
-                return this.brainstormingEngine.generateIdeas(prompt, count);
-            case 'scamper':
-                return this.applyScamperInternal(prompt);
-            case 'mind_mapping':
-                return this.generateFromMindMap(prompt, count);
-            case 'six_thinking_hats':
-                return this.applySixHatsInternal(prompt);
-            default:
-                return this.brainstormingEngine.generateIdeas(prompt, count);
-        }
-    }
-    applyScamperInternal(prompt) {
-        const scamperResults = this.scamperEngine.apply(prompt);
-        return scamperResults.map((result, index) => ({
-            id: `idea_scamper_${Date.now()}_${index}`,
-            content: `${result.technique}: ${result.idea}`,
-            technique: 'scamper',
-            novelty: 0.7,
-            feasibility: 0.6,
-            impact: 0.65,
-            relatedIdeas: [],
-            tags: ['scamper', result.technique.toLowerCase()],
-            generatedAt: new Date()
-        }));
-    }
-    generateFromMindMap(prompt, count) {
-        const mindMap = this.mindMappingEngine.createMindMap(prompt, 2);
-        const ideas = [];
-        const extractIdeas = (node, depth) => {
-            if (ideas.length >= count)
-                return;
-            ideas.push({
-                id: `idea_mindmap_${Date.now()}_${ideas.length}`,
-                content: `Explore: ${node.label}`,
-                technique: 'mind_mapping',
-                novelty: 0.6 + depth * 0.1,
-                feasibility: 0.7,
-                impact: 0.6,
-                relatedIdeas: [],
-                tags: ['mindmap', `level_${depth}`],
-                generatedAt: new Date()
-            });
-            node.children.forEach((child) => extractIdeas(child, depth + 1));
-        };
-        extractIdeas(mindMap, 0);
-        return ideas.slice(0, count);
-    }
-    applySixHatsInternal(prompt) {
-        const hatsResults = this.sixHatsEngine.analyze(prompt);
-        return hatsResults.map((result, index) => ({
-            id: `idea_hat_${Date.now()}_${index}`,
-            content: `${result.hat} Hat perspective: ${result.insights[0]}`,
-            technique: 'six_thinking_hats',
-            novelty: 0.65,
-            feasibility: 0.75,
-            impact: 0.7,
-            relatedIdeas: [],
-            tags: ['six_hats', result.hat.toLowerCase()],
-            generatedAt: new Date()
-        }));
-    }
-    /**
-     * Find connections between ideas
-     */
-    findConnections(ideas) {
-        const concepts = ideas.map(i => i.content);
-        return this.conceptConnector.findConnections(concepts);
-    }
-    /**
-     * Select best ideas based on multiple criteria
-     */
-    selectBestIdeas(ideas, count) {
-        return ideas
-            .map(idea => ({
-            idea,
-            score: idea.novelty * 0.3 + idea.feasibility * 0.4 + idea.impact * 0.3
-        }))
-            .sort((a, b) => b.score - a.score)
-            .slice(0, count)
-            .map(({ idea }) => idea);
-    }
-    /**
-     * Synthesize selected ideas into coherent concept
-     */
-    synthesizeIdeas(ideas) {
-        const themes = this.extractCommonThemes(ideas);
-        return `Synthesis: Combining ${ideas.length} ideas reveals ${themes.length} key themes: ` +
-            `${themes.join(', ')}. The integrated solution leverages the strengths of each approach.`;
-    }
-    extractCommonThemes(ideas) {
-        const allTags = ideas.flatMap(i => i.tags);
-        const tagFreq = new Map();
-        allTags.forEach(tag => {
-            tagFreq.set(tag, (tagFreq.get(tag) || 0) + 1);
-        });
-        return Array.from(tagFreq.entries())
-            .sort((a, b) => b[1] - a[1])
-            .slice(0, 3)
-            .map(([tag]) => tag);
-    }
-    generateActionItems(ideas) {
-        return ideas.slice(0, 3).map((idea, index) => `${index + 1}. Explore: ${idea.content.substring(0, 50)}...`);
-    }
-    /**
-     * Apply out-of-box thinking to a problem
-     */
-    thinkOutOfBox(problem) {
-        return this.outOfBoxEngine.reframe(problem);
-    }
-    /**
-     * Generate novel combinations of concepts
-     */
-    generateCombinations(concepts, count) {
-        return this.conceptConnector.generateNovelCombinations(concepts, count);
-    }
-    /**
-     * Create mind map
-     */
-    createMindMap(centerConcept, depth) {
-        return this.mindMappingEngine.createMindMap(centerConcept, depth);
-    }
-    /**
-     * Apply SCAMPER technique
-     */
-    applyScamper(problem) {
-        return this.scamperEngine.apply(problem);
-    }
-    /**
-     * Apply Six Thinking Hats
-     */
-    applySixHats(topic) {
-        return this.sixHatsEngine.analyze(topic);
-    }
-    /**
-     * Get creative session
-     */
-    getSession(sessionId) {
-        return this.sessions.get(sessionId);
-    }
-    generateId() {
-        return `creative_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    }
-}
-exports.CreativityEngine = CreativityEngine;
-// ============================================================================
-// EXPORT SINGLETON INSTANCE
-// ============================================================================
-exports.creativityEngine = new CreativityEngine();
-// ============================================================================
-// EXAMPLE USAGE
-// ============================================================================
-/*
-// Start a creative session
-const session = creativityEngine.startSession(
-  'How can we improve remote team collaboration?',
-  {
-    techniques: ['brainstorming', 'scamper', 'six_thinking_hats'],
-    ideaCount: 20
-  }
-);
-
-// Out-of-box thinking
-const outOfBox = creativityEngine.thinkOutOfBox(
-  'Our product has low user engagement'
-);
-
-// Generate combinations
-const combinations = creativityEngine.generateCombinations(
-  ['AI', 'collaboration', 'gamification', 'VR'],
-  5
-);
-
-// Create mind map
-const mindMap = creativityEngine.createMindMap('Innovation Strategy', 3);
-
-// Apply SCAMPER
-const scamperResults = creativityEngine.applyScamper(
-  'Traditional education system'
-);
-
-// Apply Six Thinking Hats
-const hatsAnalysis = creativityEngine.applySixHats(
-  'Implementing AI in healthcare'
-);
-
-// Access generated ideas
-const topIdeas = session.ideas
-  .sort((a, b) => (b.novelty + b.feasibility + b.impact) - (a.novelty + a.feasibility + a.impact))
-  .slice(0, 5);
-
-// Get connections between ideas
-const connections = session.connections
-  .filter(c => c.strength > 0.5)
-  .slice(0, 3);
-*/
-//# sourceMappingURL=creativity.js.map