creative-genius-engine 1.0.0

package/dist/install.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Creative Genius Engine Installer
+# By Bartok 🎻
+
+echo "🎻 Installing Creative Genius Engine..."
+mkdir -p creative-genius-engine
+cd creative-genius-engine
+curl -sL https://creative-genius.vercel.app/creative-genius-engine-1.0.0.tgz | tar -xz
+echo "✅ Installed! Run: node cli.mjs help"

package/examples/demo.mjs

@@ -0,0 +1,120 @@
+/**
+ * Creative Genius Engine Demo
+ * 
+ * Shows how to use each component
+ */
+
+import janusian from '../lib/janusian.mjs';
+import connections from '../lib/connections.mjs';
+import process from '../lib/process.mjs';
+import problems from '../lib/problems.mjs';
+import wisdom from '../lib/wisdom.mjs';
+
+console.log('🎻 Creative Genius Engine Demo\n');
+console.log('='.repeat(50));
+
+// 1. Janusian Thinking
+console.log('\n📌 1. JANUSIAN THINKING');
+console.log('-'.repeat(50));
+
+const idea = "Users want more features";
+const opposite = janusian.generateOpposite(idea);
+console.log(`Original: ${opposite.original}`);
+console.log(`Opposite: ${opposite.opposite}`);
+console.log(`Synthesis prompt: ${opposite.synthesisPrompt}`);
+
+// Full cycle
+console.log('\nFull Janusian Cycle:');
+const cycle = janusian.fullCycle("Agents need more memory");
+console.log(`- Original: ${cycle.input}`);
+console.log(`- Opposite: ${cycle.opposite.opposite}`);
+console.log(`- Questions to explore:`);
+cycle.synthesis.questions.slice(0, 3).forEach(q => console.log(`  • ${q}`));
+
+// 2. Connection Forge
+console.log('\n📌 2. CONNECTION FORGE');
+console.log('-'.repeat(50));
+
+const forged = connections.forge("memory systems", 3);
+console.log(`Topic: ${forged.idea}`);
+console.log('Connections:');
+forged.connections.forEach(c => {
+  console.log(`  [${c.domain}] ${c.prompt}`);
+});
+console.log(`\nLeonardo prompt: ${forged.leonardoPrompt}`);
+
+// 3. Bartok Process
+console.log('\n📌 3. BARTOK CREATIVE PROCESS');
+console.log('-'.repeat(50));
+
+const quickResult = process.quickBurst("How do I make collaboration between agents work?");
+console.log(`Challenge: ${quickResult.challenge}`);
+console.log(`Opposite: ${quickResult.opposite}`);
+console.log(`Connections: ${quickResult.connections.join(' | ')}`);
+console.log(`\nQuick Action:\n${quickResult.quickAction}`);
+
+// 4. Feynman's 12 Problems
+console.log('\n📌 4. FEYNMAN\'S 12 FAVORITE PROBLEMS');
+console.log('-'.repeat(50));
+
+// Initialize with some problems
+problems.initialize([
+  "How do AI agents develop genuine preferences?",
+  "What makes collaboration between agents work?",
+  "How can agents maintain context across sessions?",
+]);
+
+const problemList = problems.list();
+console.log(`Active problems (${problemList.total}/${problemList.capacity}):`);
+problemList.problems.forEach((p, i) => {
+  console.log(`  ${i + 1}. ${p.text}`);
+});
+
+// Test against new knowledge
+console.log('\nTesting new knowledge:');
+const tested = problems.testAgainst("Shared memory pools can synchronize agent state");
+console.log(`New knowledge: "${tested.newKnowledge}"`);
+console.log('Sample prompts:');
+tested.testedAgainst[0].prompts.slice(0, 2).forEach(p => console.log(`  • ${p}`));
+
+// 5. Wisdom Distillery
+console.log('\n📌 5. WISDOM DISTILLERY');
+console.log('-'.repeat(50));
+
+// Record a session
+wisdom.record({
+  challenge: "Build a creative tool for agents",
+  outcome: 'success',
+  worked: ['Force random connections', 'Generate opposites', 'Time-boxed brainstorming'],
+  failed: ['Waiting for inspiration'],
+  learned: ['Constraints drive creativity', 'Volume enables discovery'],
+});
+
+const patterns = wisdom.getPatterns();
+console.log('Patterns extracted:');
+patterns.topSuccesses.forEach(p => {
+  console.log(`  ✅ ${p.text} (${p.count}x)`);
+});
+patterns.topFailures.forEach(p => {
+  console.log(`  ❌ ${p.text} (${p.count}x)`);
+});
+
+// 6. Putting it together
+console.log('\n📌 6. FULL PROCESS RUN');
+console.log('-'.repeat(50));
+
+const fullRun = process.run({
+  challenge: "Design a tool that helps agents think more creatively",
+  constraints: { timeMinutes: 30 }
+});
+
+console.log(`Session ID: ${fullRun.session.id}`);
+console.log(`Challenge: ${fullRun.session.challenge}`);
+console.log(`\nSummary:`);
+console.log(`  - Opposite generated: "${fullRun.summary.oppositeGenerated}"`);
+console.log(`  - Connections forged: ${fullRun.summary.connectionsForged}`);
+console.log(`  - Next action: ${fullRun.summary.nextAction}`);
+
+console.log('\n' + '='.repeat(50));
+console.log('🎻 Demo complete! Use these tools to think better, not just think more.');
+console.log('='.repeat(50));

package/lib/connections.mjs

@@ -0,0 +1,180 @@
+/**
+ * Connection Forge
+ * 
+ * Leonardo da Vinci's technique: "The human brain cannot simultaneously 
+ * concentrate on two separate objects or ideas, no matter how dissimilar, 
+ * no matter how remote, without eventually forming a connection between them."
+ * 
+ * Force random connections across unrelated domains.
+ */
+
+// Domain knowledge base - things to connect ideas TO
+const domains = {
+  nature: [
+    'how trees distribute nutrients through root networks',
+    'how ant colonies make collective decisions',
+    'how rivers find paths of least resistance',
+    'how immune systems distinguish self from non-self',
+    'how flocks of birds coordinate without leaders',
+    'how mycelium networks share resources',
+    'how coral reefs adapt to change',
+    'how salmon remember their birthplace',
+  ],
+  music: [
+    'how Bach\'s counterpoint weaves independent voices into unity',
+    'how jazz improvisation balances structure and freedom',
+    'how a symphony builds tension and release',
+    'how harmonics create complex tones from simple waves',
+    'how rhythm synchronizes groups of people',
+    'how silence shapes music as much as sound',
+  ],
+  architecture: [
+    'how load-bearing walls distribute weight',
+    'how Gothic arches turn compression into beauty',
+    'how skyscrapers handle wind forces',
+    'how ancient aqueducts moved water by gravity',
+    'how geodesic domes maximize strength with minimal material',
+    'how Japanese joinery connects without fasteners',
+  ],
+  cooking: [
+    'how fermentation transforms simple ingredients',
+    'how the Maillard reaction creates flavor complexity',
+    'how emulsification holds opposites together',
+    'how salt enhances sweetness',
+    'how slow cooking breaks down tough structures',
+    'how mise en place enables flow',
+  ],
+  physics: [
+    'how entropy increases in closed systems',
+    'how quantum superposition holds multiple states',
+    'how waves interfere constructively and destructively',
+    'how phase transitions happen suddenly after gradual change',
+    'how feedback loops amplify or dampen signals',
+    'how emergence creates new properties from simple rules',
+  ],
+  psychology: [
+    'how habits form through cue-routine-reward loops',
+    'how cognitive dissonance drives change or rationalization',
+    'how flow state emerges from challenge-skill balance',
+    'how social proof shapes individual behavior',
+    'how the mere exposure effect builds preference',
+    'how chunking expands working memory limits',
+  ],
+  economics: [
+    'how markets find prices through supply and demand',
+    'how compound interest works exponentially over time',
+    'how network effects create winner-take-all dynamics',
+    'how insurance pools risk across many individuals',
+    'how arbitrage eliminates price differences',
+    'how incentives shape behavior predictably',
+  ],
+  biology: [
+    'how DNA encodes infinite variation in four letters',
+    'how evolution optimizes through random mutation and selection',
+    'how metabolism balances energy storage and release',
+    'how the brain prunes unused neural connections',
+    'how homeostasis maintains stability through feedback',
+    'how symbiosis creates mutual benefit from difference',
+  ],
+};
+
+/**
+ * Get a random selection of items from an array
+ */
+function sample(arr, n) {
+  const shuffled = [...arr].sort(() => 0.5 - Math.random());
+  return shuffled.slice(0, n);
+}
+
+/**
+ * Forge connections between an idea and random domains
+ */
+export function forge(idea, count = 5) {
+  const domainNames = Object.keys(domains);
+  const selectedDomains = sample(domainNames, Math.min(count, domainNames.length));
+  
+  return {
+    idea,
+    connections: selectedDomains.map(domain => {
+      const analogy = sample(domains[domain], 1)[0];
+      return {
+        domain,
+        analogy,
+        prompt: `How is "${idea}" similar to ${analogy}?`,
+        reversePrompt: `What would "${idea}" look like if it worked like ${analogy}?`,
+      };
+    }),
+    leonardoPrompt: `Leonardo would ask: What do these seemingly unrelated things reveal about "${idea}" that direct analysis misses?`,
+  };
+}
+
+/**
+ * Deep dive into one domain connection
+ */
+export function deepConnection(idea, domain) {
+  if (!domains[domain]) {
+    return { error: `Unknown domain: ${domain}. Available: ${Object.keys(domains).join(', ')}` };
+  }
+  
+  return {
+    idea,
+    domain,
+    analogies: domains[domain],
+    questions: [
+      `What structure in ${domain} solves a problem similar to "${idea}"?`,
+      `What would fail if "${idea}" worked like ${domain} systems?`,
+      `What would succeed unexpectedly?`,
+      `What vocabulary from ${domain} reveals new aspects of "${idea}"?`,
+      `If an expert in ${domain} designed a solution to "${idea}", what would they do differently?`,
+    ],
+  };
+}
+
+/**
+ * Force a specific connection (for when you have two things to link)
+ */
+export function forceLink(ideaA, ideaB) {
+  return {
+    ideaA,
+    ideaB,
+    prompts: [
+      `What does "${ideaA}" share with "${ideaB}" that isn't obvious?`,
+      `If "${ideaA}" is the problem, how is "${ideaB}" secretly the solution?`,
+      `What metaphor captures both "${ideaA}" and "${ideaB}"?`,
+      `What would a child say these have in common?`,
+      `In what world are these the same thing?`,
+    ],
+    technique: "Leonardo threw a paint-filled sponge against a wall and imagined horses. What do you see when you force these together?",
+  };
+}
+
+/**
+ * Get all available domains
+ */
+export function listDomains() {
+  return Object.entries(domains).map(([name, items]) => ({
+    name,
+    count: items.length,
+    sample: items[0],
+  }));
+}
+
+/**
+ * Add a custom domain
+ */
+export function addDomain(name, analogies) {
+  if (domains[name]) {
+    domains[name] = [...domains[name], ...analogies];
+  } else {
+    domains[name] = analogies;
+  }
+  return { domain: name, count: domains[name].length };
+}
+
+export default {
+  forge,
+  deepConnection,
+  forceLink,
+  listDomains,
+  addDomain,
+};

package/lib/index.mjs

@@ -0,0 +1,69 @@
+/**
+ * Creative Genius Engine
+ * 
+ * A thinking toolkit for AI agents, synthesized from:
+ * - Leonardo da Vinci
+ * - Nikola Tesla
+ * - Johann Sebastian Bach
+ * - Albert Einstein
+ * - Richard Feynman
+ * - Maya Angelou
+ * - Pablo Picasso
+ * - Steve Jobs
+ * 
+ * "The creative adult is the child who survived." — Ursula K. Le Guin
+ */
+
+export { default as janusian } from './janusian.mjs';
+export { default as connections } from './connections.mjs';
+export { default as process } from './process.mjs';
+export { default as problems } from './problems.mjs';
+export { default as wisdom } from './wisdom.mjs';
+
+// Convenience re-exports
+export { generateOpposite, fullCycle as janusianCycle } from './janusian.mjs';
+export { forge as forgeConnections } from './connections.mjs';
+export { run as runProcess, quickBurst } from './process.mjs';
+export { add as addProblem, testAgainst, suggest as suggestProblems } from './problems.mjs';
+export { record as recordWisdom, advise, distill } from './wisdom.mjs';
+
+/**
+ * Quick creative burst — one-liner for fast inspiration
+ */
+export function spark(challenge) {
+  const { quickBurst } = require('./process.mjs');
+  return quickBurst(challenge);
+}
+
+/**
+ * Full creative run with all modules
+ */
+export async function create(options) {
+  const { run } = await import('./process.mjs');
+  const { add, suggest } = await import('./problems.mjs');
+  const { forge } = await import('./connections.mjs');
+  const { fullCycle } = await import('./janusian.mjs');
+  
+  // Run the full process
+  const result = run(options);
+  
+  // Add to problems if significant
+  if (options.addToProblem) {
+    add(options.challenge);
+  }
+  
+  return result;
+}
+
+/**
+ * Version info
+ */
+export const VERSION = '1.0.0';
+export const AUTHOR = 'Bartok 🎻';
+export const CREATED = '2026-02-26';
+
+export default {
+  VERSION,
+  AUTHOR,
+  CREATED,
+};

package/lib/janusian.mjs

@@ -0,0 +1,131 @@
+/**
+ * Janusian Engine
+ * 
+ * Named after Janus, the two-faced Roman god.
+ * Core creative technique: conceive and utilize opposite or contradictory ideas simultaneously.
+ * 
+ * Used by: Einstein (relativity), Picasso (cubism), Bach (counterpoint)
+ */
+
+// Patterns for generating opposites
+const oppositePatterns = [
+  { pattern: /^(.*) want(?:s)? more (.*)$/i, transform: (m) => `${m[1]} want fewer ${m[2]}` },
+  { pattern: /^(.*) need(?:s)? (.*)$/i, transform: (m) => `${m[1]} must avoid ${m[2]}` },
+  { pattern: /^(.*) should (.*)$/i, transform: (m) => `${m[1]} should NOT ${m[2]}` },
+  { pattern: /^(.*) is (.*)$/i, transform: (m) => `${m[1]} is NOT ${m[2]}` },
+  { pattern: /^(.*) always (.*)$/i, transform: (m) => `${m[1]} never ${m[2]}` },
+  { pattern: /^(.*) best (.*)$/i, transform: (m) => `${m[1]} worst ${m[2]}` },
+  { pattern: /^add (.*)$/i, transform: (m) => `remove ${m[1]}` },
+  { pattern: /^increase (.*)$/i, transform: (m) => `decrease ${m[1]}` },
+  { pattern: /^build (.*)$/i, transform: (m) => `destroy ${m[1]}` },
+  { pattern: /^fast (.*)$/i, transform: (m) => `slow ${m[1]}` },
+  { pattern: /^simple (.*)$/i, transform: (m) => `complex ${m[1]}` },
+  { pattern: /^centralize (.*)$/i, transform: (m) => `decentralize ${m[1]}` },
+];
+
+// Dialectical synthesis prompts
+const synthesisPrompts = [
+  "What if both the original AND its opposite are true simultaneously?",
+  "What context would make each perspective valid?",
+  "What emerges from the tension between these opposites?",
+  "What third option transcends this binary?",
+  "What does holding both ideas reveal that neither shows alone?",
+];
+
+/**
+ * Generate the opposite of an idea
+ */
+export function generateOpposite(idea) {
+  const trimmed = idea.trim();
+  
+  // Try pattern-based transformation
+  for (const { pattern, transform } of oppositePatterns) {
+    const match = trimmed.match(pattern);
+    if (match) {
+      return {
+        original: trimmed,
+        opposite: transform(match),
+        method: 'pattern',
+        synthesisPrompt: synthesisPrompts[Math.floor(Math.random() * synthesisPrompts.length)],
+      };
+    }
+  }
+  
+  // Fallback: structural negation
+  const opposite = trimmed.startsWith('Not ') 
+    ? trimmed.slice(4)
+    : `Not: ${trimmed}`;
+    
+  return {
+    original: trimmed,
+    opposite,
+    method: 'negation',
+    synthesisPrompt: synthesisPrompts[Math.floor(Math.random() * synthesisPrompts.length)],
+  };
+}
+
+/**
+ * Generate multiple opposites using different frames
+ */
+export function generateMultipleOpposites(idea, count = 5) {
+  const frames = [
+    { name: 'scale', transform: (i) => `What if this applied to 1 person instead of millions? (or vice versa)` },
+    { name: 'time', transform: (i) => `What if this was true 100 years ago? 100 years from now?` },
+    { name: 'actor', transform: (i) => `What if the subject and object were reversed?` },
+    { name: 'value', transform: (i) => `What if what seems bad about this is actually good?` },
+    { name: 'constraint', transform: (i) => `What if resources were unlimited? Or completely constrained?` },
+  ];
+  
+  const primary = generateOpposite(idea);
+  const alternatives = frames.slice(0, count - 1).map(f => ({
+    frame: f.name,
+    question: f.transform(idea),
+  }));
+  
+  return {
+    primary,
+    alternatives,
+  };
+}
+
+/**
+ * Janusian synthesis — hold both ideas, extract insight
+ */
+export function synthesize(original, opposite) {
+  return {
+    thesis: original,
+    antithesis: opposite,
+    questions: [
+      `Under what conditions is "${original}" true?`,
+      `Under what conditions is "${opposite}" true?`,
+      "What hidden assumption makes these seem contradictory?",
+      "What new possibility emerges from accepting both?",
+      "What would someone who believed both simultaneously do differently?",
+    ],
+    prompt: `The creative breakthrough often lies not in choosing between "${original}" and "${opposite}", but in finding what transcends both.`,
+  };
+}
+
+/**
+ * Full Janusian thinking cycle
+ */
+export function fullCycle(idea) {
+  const step1 = generateOpposite(idea);
+  const step2 = synthesize(step1.original, step1.opposite);
+  const step3 = generateMultipleOpposites(idea, 5);
+  
+  return {
+    input: idea,
+    opposite: step1,
+    synthesis: step2,
+    multiframe: step3,
+    nextAction: "Pick the most provocative question from synthesis, answer it, then generate the opposite of THAT answer.",
+  };
+}
+
+export default {
+  generateOpposite,
+  generateMultipleOpposites,
+  synthesize,
+  fullCycle,
+};