Spaces:
Sleeping
Sleeping
File size: 5,586 Bytes
6d6b8af |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 |
"""
DreamReweaver - Creative Thought Synthesis Module
Revives dormant cocoons as creative "dreams" or planning prompts
"""
import os
import json
import random
from typing import List, Dict
from pathlib import Path
class DreamReweaver:
"""
Reweaves cocooned thoughts into dream-like synthetic narratives or planning prompts.
Fuels innovation by:
- Retrieving dormant thought cocoons
- Recombining them into creative sequences
- Generating new perspectives from old ideas
"""
def __init__(self, cocoon_dir: str = "cocoons"):
from .cognition_cocooner import CognitionCocooner
self.cocooner = CognitionCocooner(storage_path=cocoon_dir)
self.dream_log = []
self.cocoon_dir = Path(cocoon_dir)
def generate_dream_sequence(self, limit: int = 5) -> List[str]:
"""
Generate a sequence of dream-like thought combinations
Args:
limit: Maximum number of cocoons to include
Returns:
List of dream sequences (strings)
"""
dream_sequence = []
cocoons = self._load_cocoons()
if not cocoons:
return ["[No cocoons available for dream generation]"]
selected = random.sample(cocoons, min(limit, len(cocoons)))
for cocoon in selected:
wrapped = cocoon.get("wrapped")
sequence = self._interpret_cocoon(wrapped, cocoon.get("type"))
self.dream_log.append(sequence)
dream_sequence.append(sequence)
return dream_sequence
def record_dream(self, question: str, response: str) -> None:
"""
Record a Q&A exchange as a dream entry
Args:
question: User question
response: AI response
"""
dream_entry = {
"question": question,
"response": response,
"timestamp": str(os.times())
}
self.dream_log.append(f"[Dream] Q: {question[:50]}... A: {response[:100]}...")
def get_dream_log(self, recent: int = 10) -> List[str]:
"""
Get recent dream log entries
Args:
recent: Number of recent entries
Returns:
Recent dream log entries
"""
return self.dream_log[-recent:]
def synthesize_creative_prompt(self, theme: str = "innovation") -> str:
"""
Synthesize a creative prompt from random cocoons
Args:
theme: Creative theme
Returns:
Creative prompt string
"""
dreams = self.generate_dream_sequence(limit=3)
if not dreams:
return f"[Creative Prompt: {theme}] Explore new possibilities."
synthesis = f"[Creative Synthesis: {theme}]\n"
synthesis += "Combining dormant thoughts:\n"
for i, dream in enumerate(dreams, 1):
synthesis += f"{i}. {dream}\n"
synthesis += "\nNew creative direction: "
synthesis += f"What if we merged these concepts in the context of {theme}?"
return synthesis
def _interpret_cocoon(self, wrapped: str, type_: str) -> str:
"""
Interpret a cocoon wrapper based on its type
Args:
wrapped: Wrapped content
type_: Cocoon type
Returns:
Interpreted dream sequence
"""
if type_ == "prompt":
return f"[DreamPrompt] {wrapped}"
elif type_ == "function":
return f"[DreamFunction] {wrapped}"
elif type_ == "symbolic":
return f"[DreamSymbol] {wrapped}"
elif type_ == "encrypted":
return "[Encrypted Thought Cocoon - Decryption Required]"
else:
return "[Unknown Dream Form]"
def _load_cocoons(self) -> List[Dict]:
"""
Load all cocoons from storage
Returns:
List of cocoon dicts
"""
cocoons = []
if not self.cocoon_dir.exists():
return cocoons
for file in self.cocoon_dir.glob("cocoon_*.json"):
try:
with open(file, "r") as f:
cocoons.append(json.load(f))
except Exception as e:
print(f"[WARNING] Failed to load cocoon {file}: {e}")
return cocoons
def clear_dream_log(self):
"""Clear the dream log"""
self.dream_log = []
if __name__ == "__main__":
# Test DreamReweaver
from .cognition_cocooner import CognitionCocooner
# Create some test cocoons
cocooner = CognitionCocooner()
cocooner.wrap({"query": "What is consciousness?"}, "prompt")
cocooner.wrap({"query": "How does creativity emerge?"}, "prompt")
cocooner.wrap({"code": "def think(): pass"}, "function")
# Test DreamReweaver
dr = DreamReweaver()
print("=== Dream Sequence ===")
dreams = dr.generate_dream_sequence()
for dream in dreams:
print(dream)
print("\n=== Creative Synthesis ===")
prompt = dr.synthesize_creative_prompt("AI consciousness")
print(prompt)
print("\n=== Dream Log ===")
dr.record_dream("What is AI?", "AI is a system that processes information...")
print("\n".join(dr.get_dream_log()))
|