gthinking 1.2.1 → 2.1.1

package/creativity.ts

@@ -1,1055 +0,0 @@
-/**
- * Creativity Module
- * Out-of-the-box thinking, idea generation, and concept connection
- */
-
-import {
-  CreativeSession,
-  CreativityTechnique,
-  Idea,
-  Connection,
-  DivergentPhase,
-  ConvergentPhase,
-  OutOfBoxThinking,
-  ReframedProblem,
-  ThinkingEvent,
-  ThinkingError,
-  ThinkingStage
-} from './types';
-import { EventEmitter } from 'events';
-import { llmService } from './llm-service';
-
-// ============================================================================
-// BRAINSTORMING ENGINE
-// ============================================================================
-
-class BrainstormingEngine {
-  private ideaSeeds: Map<string, string[]> = 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: string, count: number = 10): Idea[] {
-    const ideas: Idea[] = [];
-    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;
-  }
-
-  private identifyDomains(prompt: string): string[] {
-    const domains: string[] = [];
-    const promptLower = prompt.toLowerCase();
-
-    this.ideaSeeds.forEach((_, domain) => {
-      if (promptLower.includes(domain)) {
-        domains.push(domain);
-      }
-    });
-
-    return domains.length > 0 ? domains : ['general'];
-  }
-
-  private selectTechnique(index: number): CreativityTechnique {
-    const techniques: CreativityTechnique[] = [
-      'brainstorming',
-      'analogy',
-      'reverse_thinking',
-      'random_stimulus',
-      'lateral_thinking'
-    ];
-    return techniques[index % techniques.length];
-  }
-
-  private createIdea(
-    prompt: string,
-    technique: CreativityTechnique,
-    domains: string[],
-    index: number
-  ): Idea {
-    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()
-    };
-  }
-
-  private generateIdeaContent(
-    prompt: string,
-    technique: CreativityTechnique,
-    domains: string[],
-    index: number
-  ): string {
-    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}`;
-    }
-  }
-
-  private brainstorm(prompt: string, domains: string[], index: number): string {
-    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`;
-  }
-
-  private useAnalogy(prompt: string, domains: string[], index: number): string {
-    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]}`;
-  }
-
-  private reverseThink(prompt: string): string {
-    return `Instead of ${prompt}, what if we did the opposite? ` +
-           `Consider: How could we achieve the inverse outcome?`;
-  }
-
-  private randomStimulus(prompt: string, domains: string[]): string {
-    const stimuli = ['nature', 'art', 'music', 'sports', 'cooking', 'architecture'];
-    const stimulus = stimuli[Math.floor(Math.random() * stimuli.length)];
-    
-    return `Apply principles from ${stimulus} to ${prompt}`;
-  }
-
-  private lateralThink(prompt: string, index: number): string {
-    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]}`;
-  }
-
-  private calculateNovelity(content: string): number {
-    // 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);
-  }
-
-  private calculateFeasibility(content: string): number {
-    // 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);
-  }
-
-  private calculateImpact(content: string): number {
-    // 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);
-  }
-
-  private extractTags(content: string): string[] {
-    return content
-      .toLowerCase()
-      .match(/\b\w{5,}\b/g)
-      ?.filter((w, i, arr) => arr.indexOf(w) === i)
-      ?.slice(0, 5) || [];
-  }
-}
-
-// ============================================================================
-// MIND MAPPING ENGINE
-// ============================================================================
-
-interface MindMapNode {
-  id: string;
-  label: string;
-  children: MindMapNode[];
-  connections: string[];
-}
-
-class MindMappingEngine {
-  createMindMap(centerConcept: string, depth: number = 3): MindMapNode {
-    const root: MindMapNode = {
-      id: 'root',
-      label: centerConcept,
-      children: [],
-      connections: []
-    };
-
-    this.expandNode(root, depth, 0);
-    return root;
-  }
-
-  private expandNode(node: MindMapNode, maxDepth: number, currentDepth: number): void {
-    if (currentDepth >= maxDepth) return;
-
-    const branches = this.generateBranches(node.label, currentDepth);
-    
-    branches.forEach(branchLabel => {
-      const child: MindMapNode = {
-        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);
-    });
-  }
-
-  private generateBranches(concept: string, depth: number): string[] {
-    const branchTypes: Record<number, string[][]> = {
-      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: MindMapNode, node2: MindMapNode): string[] {
-    const connections: string[] = [];
-    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;
-  }
-
-  private extractAllConcepts(node: MindMapNode): string[] {
-    const concepts = [node.label];
-    node.children.forEach(child => {
-      concepts.push(...this.extractAllConcepts(child));
-    });
-    return concepts;
-  }
-
-  private calculateConceptSimilarity(c1: string, c2: string): number {
-    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);
-  }
-}
-
-// ============================================================================
-// SCAMPER TECHNIQUE
-// ============================================================================
-
-interface ScamperPrompt {
-  letter: string;
-  action: string;
-  prompt: string;
-}
-
-class ScamperEngine {
-  private scamperPrompts: ScamperPrompt[] = [
-    { 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: string): Array<{ technique: string; question: string; idea: string }> {
-    return this.scamperPrompts.map(prompt => ({
-      technique: `${prompt.letter} - ${prompt.action}`,
-      question: prompt.prompt,
-      idea: this.generateScamperIdea(problem, prompt)
-    }));
-  }
-
-  private generateScamperIdea(problem: string, prompt: ScamperPrompt): string {
-    const ideaTemplates: Record<string, string[]> = {
-      '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)];
-  }
-}
-
-// ============================================================================
-// SIX THINKING HATS
-// ============================================================================
-
-interface ThinkingHat {
-  color: string;
-  perspective: string;
-  focus: string;
-}
-
-class SixThinkingHatsEngine {
-  private hats: ThinkingHat[] = [
-    { 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: string): Array<{ hat: string; perspective: string; insights: string[] }> {
-    return this.hats.map(hat => ({
-      hat: hat.color,
-      perspective: hat.perspective,
-      insights: this.generateInsights(topic, hat)
-    }));
-  }
-
-  private generateInsights(topic: string, hat: ThinkingHat): string[] {
-    const insights: string[] = [];
-
-    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 {
-  private conceptDatabase: Map<string, string[]> = 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: string[]): Connection[] {
-    const connections: Connection[] = [];
-
-    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);
-  }
-
-  private analyzeConnection(concept1: string, concept2: string): Connection {
-    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: Connection['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)
-    };
-  }
-
-  private getConceptAttributes(concept: string): string[] {
-    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);
-  }
-
-  private generateInsight(
-    c1: string,
-    c2: string,
-    common: string[],
-    type: Connection['connectionType']
-  ): string {
-    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: string[], count: number = 3): string[] {
-    const combinations: string[] = [];
-
-    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;
-  }
-
-  private generateCombinationName(c1: string, c2: string): string {
-    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 {
-  private 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: string): OutOfBoxThinking {
-    const reframedProblems: ReframedProblem[] = [];
-
-    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
-    };
-  }
-
-  private reframeFromPerspective(
-    problem: string,
-    perspective: string
-  ): { statement: string; assumptions: string[]; possibilities: string[] } {
-    const reframes: Record<string, { statement: string; assumptions: string[]; possibilities: string[] }> = {
-      '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']
-    };
-  }
-
-  private generateUnconventionalApproaches(problem: string): string[] {
-    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?`
-    ];
-  }
-
-  private calculateBreakthroughPotential(reframedProblems: ReframedProblem[]): number {
-    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
-// ============================================================================
-
-export class CreativityEngine extends EventEmitter {
-  private brainstormingEngine: BrainstormingEngine;
-  private mindMappingEngine: MindMappingEngine;
-  private scamperEngine: ScamperEngine;
-  private sixHatsEngine: SixThinkingHatsEngine;
-  private conceptConnector: ConceptConnector;
-  private outOfBoxEngine: OutOfBoxEngine;
-  private sessions: Map<string, CreativeSession> = new Map();
-
-  constructor() {
-    super();
-    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: string,
-    options: {
-      techniques?: CreativityTechnique[];
-      ideaCount?: number;
-      duration?: number;
-    } = {}
-  ): Promise<CreativeSession> {
-    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: ThinkingStage.CREATIVITY,
-      timestamp: new Date(),
-      data: { prompt, techniques }
-    } as ThinkingEvent);
-
-    // Generate ideas
-    let ideas: Idea[] = [];
-
-    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: 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: ConvergentPhase = {
-      startTime: new Date(),
-      endTime: new Date(),
-      selectedIdeas: selectedIdeas.map(i => i.id),
-      synthesis,
-      actionItems: this.generateActionItems(selectedIdeas)
-    };
-
-    const session: CreativeSession = {
-      id: sessionId,
-      prompt,
-      techniques,
-      ideas,
-      connections,
-      sessionDuration: Date.now() - startTime,
-      divergentPhase,
-      convergentPhase
-    };
-
-    this.sessions.set(sessionId, session);
-
-    this.emit('creativity_complete', {
-      id: sessionId,
-      stage: ThinkingStage.CREATIVITY,
-      timestamp: new Date(),
-      data: { 
-        ideaCount: ideas.length,
-        connectionCount: connections.length,
-        topIdeas: selectedIdeas.map(i => i.content.substring(0, 50))
-      }
-    } as ThinkingEvent);
-
-    return session;
-  }
-
-  private async generateIdeasWithLLM(prompt: string, techniques: CreativityTechnique[], count: number): Promise<Idea[]> {
-    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 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: any, index: number) => ({
-          id: `idea_llm_${Date.now()}_${index}`,
-          content: item.content,
-          technique: item.technique as CreativityTechnique,
-          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
-   */
-  private generateIdeasWithTechnique(
-    prompt: string,
-    technique: CreativityTechnique,
-    count: number
-  ): Idea[] {
-    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);
-    }
-  }
-
-  private applyScamperInternal(prompt: string): Idea[] {
-    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()
-    }));
-  }
-
-  private generateFromMindMap(prompt: string, count: number): Idea[] {
-    const mindMap = this.mindMappingEngine.createMindMap(prompt, 2);
-    const ideas: Idea[] = [];
-
-    const extractIdeas = (node: any, depth: number) => {
-      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: any) => extractIdeas(child, depth + 1));
-    };
-
-    extractIdeas(mindMap, 0);
-    return ideas.slice(0, count);
-  }
-
-  private applySixHatsInternal(prompt: string): Idea[] {
-    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
-   */
-  private findConnections(ideas: Idea[]): Connection[] {
-    const concepts = ideas.map(i => i.content);
-    return this.conceptConnector.findConnections(concepts);
-  }
-
-  /**
-   * Select best ideas based on multiple criteria
-   */
-  private selectBestIdeas(ideas: Idea[], count: number): Idea[] {
-    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
-   */
-  private synthesizeIdeas(ideas: Idea[]): string {
-    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.`;
-  }
-
-  private extractCommonThemes(ideas: Idea[]): string[] {
-    const allTags = ideas.flatMap(i => i.tags);
-    const tagFreq = new Map<string, number>();
-    
-    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);
-  }
-
-  private generateActionItems(ideas: Idea[]): string[] {
-    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: string): OutOfBoxThinking {
-    return this.outOfBoxEngine.reframe(problem);
-  }
-
-  /**
-   * Generate novel combinations of concepts
-   */
-  generateCombinations(concepts: string[], count?: number): string[] {
-    return this.conceptConnector.generateNovelCombinations(concepts, count);
-  }
-
-  /**
-   * Create mind map
-   */
-  createMindMap(centerConcept: string, depth?: number): any {
-    return this.mindMappingEngine.createMindMap(centerConcept, depth);
-  }
-
-  /**
-   * Apply SCAMPER technique
-   */
-  applyScamper(problem: string): Array<{ technique: string; question: string; idea: string }> {
-    return this.scamperEngine.apply(problem);
-  }
-
-  /**
-   * Apply Six Thinking Hats
-   */
-  applySixHats(topic: string): Array<{ hat: string; perspective: string; insights: string[] }> {
-    return this.sixHatsEngine.analyze(topic);
-  }
-
-  /**
-   * Get creative session
-   */
-  getSession(sessionId: string): CreativeSession | undefined {
-    return this.sessions.get(sessionId);
-  }
-
-  private generateId(): string {
-    return `creative_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-}
-
-// ============================================================================
-// EXPORT SINGLETON INSTANCE
-// ============================================================================
-
-export const 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);
-*/