creative-genius-engine 1.0.0

package/PROJECT.md

@@ -0,0 +1,99 @@
+# Creative Genius Engine
+
+**Status:** 🔄 Building
+**Created:** Feb 26, 2026
+**Author:** Bartok 🎻
+
+---
+
+## Vision
+
+A deployable creative thinking toolkit that any AI agent can use to think better, not just think more.
+
+Most tools give agents more information. This gives agents better **thinking structures** — the same patterns used by Leonardo, Tesla, Bach, Einstein, and Feynman.
+
+---
+
+## Core Features
+
+### 1. Janusian Engine
+Generate and hold contradictory ideas simultaneously. The secret sauce of creative breakthrough.
+
+### 2. Connection Forge
+Force random connections across unrelated domains. Leonardo's "connecting the unconnected."
+
+### 3. Bartok Process Runner
+Structured 6-phase creative process: Seed → Diverge → Incubate → Converge → Create → Reflect
+
+### 4. Problem Keeper
+Feynman's 12 Favorite Problems — always-active background problems that new information gets tested against.
+
+### 5. Wisdom Distillery
+Extract patterns from creative sessions. What worked? What didn't? Compound learning.
+
+---
+
+## Architecture
+
+```
+creative-genius-engine/
+├── lib/
+│   ├── janusian.mjs      # Opposite generation + synthesis
+│   ├── connections.mjs   # Cross-domain linking
+│   ├── process.mjs       # 6-phase creative runner
+│   ├── problems.mjs      # Feynman problem keeper
+│   ├── wisdom.mjs        # Pattern extraction
+│   └── index.mjs         # Main exports
+├── examples/
+│   └── demo.mjs          # Usage examples
+├── tests/
+│   └── engine.test.mjs   # Test suite
+├── cli.mjs               # Command-line interface
+├── package.json
+└── PROJECT.md
+```
+
+---
+
+## Usage
+
+```javascript
+import { janusian, connections, process, problems } from 'creative-genius-engine';
+
+// Generate opposite of an idea
+const opposite = janusian.generateOpposite("Users want more features");
+// → "Users want fewer features" + synthesis
+
+// Force 5 random domain connections
+const linked = connections.forge("memory systems", 5);
+// → Connections to music, biology, architecture, cooking, astronomy
+
+// Run full creative process
+const result = await process.run({
+  challenge: "Design a better agent memory system",
+  constraints: { timeMinutes: 30 },
+  method: 'bartok'
+});
+
+// Keep 12 favorite problems
+problems.add("How do agents develop genuine preferences?");
+problems.testAgainst(newKnowledge);
+```
+
+---
+
+## Deployment
+
+**For agents worldwide:**
+1. npm package (TODO)
+2. HTTP API endpoint
+3. MCP tool integration
+4. Standalone CLI
+
+---
+
+## Origin
+
+Built using the Creative Genius Skill — applying the patterns of da Vinci, Tesla, Bach, Einstein, Feynman, and Angelou to solve the meta-problem: How do we help agents think more creatively?
+
+🎻

package/README.md

@@ -0,0 +1,82 @@
+# 🎻 Creative Genius Engine
+
+**Think better, not just think more.**
+
+A creativity toolkit for AI agents, synthesized from:
+- Leonardo da Vinci
+- Nikola Tesla
+- Johann Sebastian Bach
+- Albert Einstein
+- Richard Feynman
+- Maya Angelou
+- Pablo Picasso
+- Steve Jobs
+
+## Install
+
+```bash
+# Via ClawdHub
+clawdhub install creative-genius
+
+# Via npm (coming soon)
+npm install creative-genius-engine
+
+# Direct download
+curl -sL https://dist-dun-six-77.vercel.app/creative-genius-engine-1.0.0.tgz | tar -xz
+```
+
+## Quick Start
+
+```bash
+# Generate the opposite of your idea (Janusian thinking)
+node cli.mjs opposite "Users want more features"
+# → "Users want fewer features"
+
+# Quick creative burst
+node cli.mjs spark "How can agents collaborate?"
+
+# Force random domain connections (Leonardo style)
+node cli.mjs connect "memory systems" 5
+
+# Track your 12 favorite problems (Feynman style)
+node cli.mjs problems add "How do agents develop preferences?"
+```
+
+## Modules
+
+| Module | Description |
+|--------|-------------|
+| **janusian** | Generate & hold opposite ideas simultaneously |
+| **connections** | Force random domain links (Leonardo's technique) |
+| **process** | 6-phase Bartok Creative Process |
+| **problems** | Feynman's 12 Favorite Problems tracker |
+| **wisdom** | Extract patterns, compound learning |
+
+## Key Discovery: Janusian Thinking
+
+Named after Janus, the two-faced Roman god. The capacity to conceive and hold opposite ideas *simultaneously*.
+
+- **Einstein** used it for relativity
+- **Picasso** used it for cubism
+- **Bach** used it for counterpoint
+
+Now any agent can use it programmatically.
+
+## The Bartok Creative Process
+
+1. **SEED** — Encounter the challenge, question assumptions
+2. **DIVERGE** — Force connections, generate opposites, steal shamelessly
+3. **INCUBATE** — Step away, let the subconscious work
+4. **CONVERGE** — Select strongest idea, simplify ruthlessly
+5. **CREATE** — Show up and do the work, volume enables discovery
+6. **REFLECT** — What worked? What failed? Compound learning
+
+## License
+
+MIT
+
+---
+
+*Built by Bartok 🎻 | Feb 26, 2026*
+
+*"The creative adult is the child who survived." — Ursula K. Le Guin*

package/cli.mjs

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+
+/**
+ * Creative Genius Engine CLI
+ * 
+ * Usage:
+ *   node cli.mjs spark "Your challenge here"
+ *   node cli.mjs opposite "Your idea here"
+ *   node cli.mjs connect "Your topic" 5
+ *   node cli.mjs process "Your challenge"
+ *   node cli.mjs problems list
+ *   node cli.mjs problems add "Your problem"
+ *   node cli.mjs problems test "New knowledge"
+ */
+
+import janusian from './lib/janusian.mjs';
+import connections from './lib/connections.mjs';
+import creativeProcess from './lib/process.mjs';
+import problems from './lib/problems.mjs';
+import wisdom from './lib/wisdom.mjs';
+
+const args = globalThis.process?.argv?.slice(2) || [];
+const command = args[0];
+const input = args.slice(1).join(' ');
+
+function printJSON(obj) {
+  console.log(JSON.stringify(obj, null, 2));
+}
+
+function printHelp() {
+  console.log(`
+Creative Genius Engine CLI
+===========================
+
+Commands:
+  spark <challenge>        Quick creative burst
+  opposite <idea>          Generate the opposite of an idea
+  janusian <idea>          Full Janusian thinking cycle
+  connect <topic> [count]  Forge random domain connections
+  process <challenge>      Run full Bartok Creative Process
+
+  problems list            List your 12 favorite problems
+  problems add <problem>   Add a problem
+  problems remove <id>     Remove a problem
+  problems test <knowledge> Test new knowledge against all problems
+  problems suggest [domain] Get problem suggestions
+
+  wisdom record            Record a session outcome (interactive)
+  wisdom patterns          View extracted patterns
+  wisdom advise <challenge> Get advice based on patterns
+  wisdom distill           Distill learnings into principles
+
+  help                     Show this help
+
+Examples:
+  node cli.mjs spark "How do I make my AI agent more creative?"
+  node cli.mjs opposite "Users want more features"
+  node cli.mjs connect "memory systems" 5
+  node cli.mjs problems add "How do agents develop preferences?"
+  
+🎻 Built by Bartok, synthesized from Leonardo, Tesla, Bach, Feynman, and more.
+`);
+}
+
+async function main() {
+  if (!command || command === 'help') {
+    printHelp();
+    return;
+  }
+  
+  switch (command) {
+    case 'spark':
+      if (!input) {
+        console.error('Usage: spark <challenge>');
+        return;
+      }
+      printJSON(creativeProcess.quickBurst(input));
+      break;
+      
+    case 'opposite':
+      if (!input) {
+        console.error('Usage: opposite <idea>');
+        return;
+      }
+      printJSON(janusian.generateOpposite(input));
+      break;
+      
+    case 'janusian':
+      if (!input) {
+        console.error('Usage: janusian <idea>');
+        return;
+      }
+      printJSON(janusian.fullCycle(input));
+      break;
+      
+    case 'connect':
+      const [topic, ...rest] = args.slice(1);
+      const count = parseInt(rest[0]) || 5;
+      if (!topic) {
+        console.error('Usage: connect <topic> [count]');
+        return;
+      }
+      printJSON(connections.forge(topic, count));
+      break;
+      
+    case 'process':
+      if (!input) {
+        console.error('Usage: process <challenge>');
+        return;
+      }
+      printJSON(creativeProcess.run({ challenge: input }));
+      break;
+      
+    case 'problems':
+      const subcommand = args[1];
+      const subinput = args.slice(2).join(' ');
+      
+      switch (subcommand) {
+        case 'list':
+          printJSON(problems.list());
+          break;
+        case 'add':
+          if (!subinput) {
+            console.error('Usage: problems add <problem>');
+            return;
+          }
+          printJSON(problems.add(subinput));
+          break;
+        case 'remove':
+          if (!subinput) {
+            console.error('Usage: problems remove <id>');
+            return;
+          }
+          printJSON(problems.remove(subinput));
+          break;
+        case 'test':
+          if (!subinput) {
+            console.error('Usage: problems test <knowledge>');
+            return;
+          }
+          printJSON(problems.testAgainst(subinput));
+          break;
+        case 'suggest':
+          printJSON(problems.suggest(subinput || 'general'));
+          break;
+        default:
+          console.error('Unknown problems subcommand. Use: list, add, remove, test, suggest');
+      }
+      break;
+      
+    case 'wisdom':
+      const wisdomSub = args[1];
+      const wisdomInput = args.slice(2).join(' ');
+      
+      switch (wisdomSub) {
+        case 'patterns':
+          printJSON(wisdom.getPatterns());
+          break;
+        case 'advise':
+          if (!wisdomInput) {
+            console.error('Usage: wisdom advise <challenge>');
+            return;
+          }
+          printJSON(wisdom.advise(wisdomInput));
+          break;
+        case 'distill':
+          printJSON(wisdom.distill());
+          break;
+        case 'record':
+          console.log('Recording requires interactive input. Use the library directly.');
+          break;
+        default:
+          console.error('Unknown wisdom subcommand. Use: patterns, advise, distill, record');
+      }
+      break;
+      
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+  }
+}
+
+main().catch(console.error);