gthinking 1.0.0

package/dist/creativity.js

@@ -0,0 +1,778 @@
+"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");
+// ============================================================================
+// 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
+     */
+    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 using specified techniques
+        const ideas = [];
+        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;
+    }
+    /**
+     * 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