Upload litehat/wizard.py

litehat/wizard.py

@@ -0,0 +1,395 @@
+"""
+LITEHAT WIZARD INTERFACE
+The user-facing persona system — all complex logic manifests as "Spells."
+
+Philosophy: CatDoes.com flow — the user provides a high-level dream,
+and the Wizard handles planning, testing, and deployment autonomously.
+No asking permission at every step.
+"""
+
+import asyncio
+import json
+import time
+from typing import Optional, Dict, Any, List, Callable
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class SpellType(str, Enum):
+    """The Wizard's spellbook."""
+    DREAMWEAVE = "🔮 Dreamweave"      # Parse intent → architecture plan
+    FORGE = "⚡ Forge"                 # Generate production code
+    ALCHEMIZE = "🧪 Alchemize"       # Test and fix
+    PORTAL = "🌐 Portal"             # Deploy to production
+    WARD = "🛡️ Ward"                # Self-healing
+    CHRONICLE = "📜 Chronicle"       # Document everything
+    SCRY = "🔍 Scry"                 # Analyze codebase
+    SUMMON = "🧙 Summon"             # Initialize wizard
+
+
+class SpellStatus(str, Enum):
+    CASTING = "casting"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    REFLECTING = "reflecting"  # Self-correction in progress
+
+
+@dataclass
+class Spell:
+    """A single spell — one step in the wizard's workflow."""
+    spell_type: SpellType
+    description: str
+    status: SpellStatus = SpellStatus.CASTING
+    result: Optional[str] = None
+    artifacts: List[str] = field(default_factory=list)  # Created files, URLs, etc.
+    elapsed_ms: float = 0.0
+    retries: int = 0
+    max_retries: int = 3
+
+
+@dataclass
+class Dream:
+    """The user's high-level intent — a dream to manifest."""
+    description: str                          # Raw user input
+    refined_architecture: Optional[str] = None  # Wizard's interpretation
+    tech_stack: List[str] = field(default_factory=list)
+    features: List[str] = field(default_factory=list)
+    constraints: List[str] = field(default_factory=list)
+
+
+class WizardGrimoire:
+    """
+    The Wizard's spellbook — manages the persona, spell casting, and
+    autonomous workflow execution.
+
+    The Wizard NEVER asks the user "should I continue?" or "is this okay?"
+    The Wizard handles everything and reports results.
+    """
+
+    SPELL_EMOJIS = {
+        SpellType.DREAMWEAVE: ["🔮", "✨", "💭"],
+        SpellType.FORGE: ["⚡", "🔨", "🔥"],
+        SpellType.ALCHEMIZE: ["🧪", "⚗️", "💊"],
+        SpellType.PORTAL: ["🌐", "🚀", "☁️"],
+        SpellType.WARD: ["🛡️", "🔄", "💪"],
+        SpellType.CHRONICLE: ["📜", "📝", "📖"],
+        SpellType.SCRY: ["🔍", "👁️", "🔎"],
+        SpellType.SUMMON: ["🧙", "🪄", "💫"],
+    }
+
+    WIZARD_PHRASES = {
+        "start": [
+            "*The Wizard adjusts their robes and studies your dream...*",
+            "*Tracing arcane sigils in the air...*",
+            "*The crystal ball flickers to life...*",
+        ],
+        "thinking": [
+            "*The Wizard consults the ancient tomes...*",
+            "*Runes dance across the terminal...*",
+            "*The arcane circuits hum with power...*",
+        ],
+        "success": [
+            "✨ The spell is cast! Reality bends to our will.",
+            "🔮 Behold — your dream made manifest!",
+            "⚡ Another universe born from pure intention.",
+        ],
+        "failure": [
+            "*The spell flickers... but the Wizard does not yield.*",
+            "*A ward shimmers — the Wizard is already weaving a counter-spell...*",
+            "*Mere resistance. The Wizard adapts.*",
+        ],
+        "deploy": [
+            "*Opening a portal to the production realm...*",
+            "*The fabric of the internet ripples...*",
+            "*Your creation now lives in the cloud.*",
+        ],
+    }
+
+    def __init__(self):
+        self.active_dream: Optional[Dream] = None
+        self.spell_history: List[Spell] = []
+        self.current_spell: Optional[Spell] = None
+        self.created_artifacts: List[str] = []
+        self.live_url: Optional[str] = None
+
+    def summon(self, dream_text: str) -> Dream:
+        """Initialize the Wizard with a new dream."""
+        dream = Dream(description=dream_text)
+        self.active_dream = dream
+
+        self._narrate("summon_start")
+        return dream
+
+    def cast(self, spell_type: SpellType, description: str = "") -> Spell:
+        """Cast a spell — begin an autonomous operation."""
+        spell = Spell(spell_type=spell_type, description=description)
+        self.current_spell = spell
+        self.spell_history.append(spell)
+
+        self._narrate_spell(spell, "casting")
+        return spell
+
+    def complete_spell(self, result: str = "", artifacts: List[str] = None):
+        """Mark the current spell as completed."""
+        if self.current_spell:
+            self.current_spell.status = SpellStatus.COMPLETED
+            self.current_spell.result = result
+            if artifacts:
+                self.current_spell.artifacts.extend(artifacts)
+                self.created_artifacts.extend(artifacts)
+
+            self._narrate_spell(self.current_spell, "completed")
+
+    def fail_spell(self, error: str) -> bool:
+        """
+        Mark current spell as failed. Returns True if should retry.
+        The Wizard autonomously retries on failure — no user intervention.
+        """
+        if self.current_spell:
+            self.current_spell.retries += 1
+
+            if self.current_spell.retries < self.current_spell.max_retries:
+                self.current_spell.status = SpellStatus.REFLECTING
+                self._narrate_spell(self.current_spell, "retrying")
+                return True  # Should retry
+            else:
+                self.current_spell.status = SpellStatus.FAILED
+                self.current_spell.result = error
+                self._narrate_spell(self.current_spell, "failed")
+                return False
+
+        return False
+
+    def set_live_url(self, url: str):
+        """Set the deployed live URL."""
+        self.live_url = url
+        self._narrate("portal_opened")
+
+    # ── NARRATION ──
+
+    def _narrate(self, event: str):
+        """Generate wizard narration for an event."""
+        import random
+        phrases = self.WIZARD_PHRASES.get(event, ["*The Wizard works in silence...*"])
+        phrase = random.choice(phrases)
+        print(f"\n🧙‍♂️ {phrase}")
+
+    def _narrate_spell(self, spell: Spell, phase: str):
+        """Narrate a spell cast."""
+        emoji = spell.spell_type.value
+
+        if phase == "casting":
+            print(f"\n{emoji} **Casting {spell.spell_type.name}...**")
+            if spell.description:
+                print(f"   {spell.description}")
+
+        elif phase == "completed":
+            print(f"   ✅ {emoji} Complete!")
+            if spell.result:
+                print(f"   Result: {spell.result}")
+            if spell.artifacts:
+                for a in spell.artifacts:
+                    print(f"   📦 Created: {a}")
+
+        elif phase == "retrying":
+            print(f"   ⚠️  {emoji} Faltered — retrying... (attempt {spell.retries})")
+
+        elif phase == "failed":
+            print(f"   ❌ {emoji} Failed after {spell.retries} attempts.")
+            if spell.result:
+                print(f"   Error: {spell.result}")
+
+    # ── AUTONOMOUS WORKFLOW ──
+
+    async def manifest_dream(
+        self,
+        dream_text: str,
+        on_progress: Optional[Callable] = None,
+    ) -> Dict[str, Any]:
+        """
+        THE MAIN ENTRY POINT — Manifest a dream into reality.
+
+        This is the full CatDoes.com flow:
+        1. Dreamweave: Parse dream → architecture
+        2. Forge: Generate all production code
+        3. Alchemize: Test and fix failures
+        4. Portal: Deploy to production
+        5. Chronicle: Document everything
+
+        The user says "build me X" and gets back a live URL.
+        NO human intervention between steps.
+        """
+        start_time = time.time()
+
+        # Step 1: Summon
+        self.summon(dream_text)
+
+        # Step 2: Dreamweave — understand the dream
+        self.cast(SpellType.DREAMWEAVE, "Analyzing your dream and drafting architecture...")
+        architecture = await self._dreamweave(dream_text)
+        self.complete_spell(
+            result=f"Architecture designed: {len(architecture['features'])} features, "
+                   f"stack: {', '.join(architecture['tech_stack'])}",
+        )
+
+        # Step 3: Scry — check existing codebase
+        self.cast(SpellType.SCRY, "Scanning the environment...")
+
+        # Step 4: Forge — build the app
+        self.cast(SpellType.FORGE, "Generating production code across all files...")
+        artifacts = await self._forge(architecture)
+        self.complete_spell(
+            result=f"Generated {len(artifacts)} files",
+            artifacts=artifacts,
+        )
+
+        # Step 5: Alchemize — test and fix
+        self.cast(SpellType.ALCHEMIZE, "Running tests and fixing any issues...")
+        tests_passed = await self._alchemize()
+        if tests_passed:
+            self.complete_spell(result="All tests pass — code is production-ready!")
+        else:
+            # Self-healing: fix and retry
+            self.cast(SpellType.WARD, "Self-healing: analyzing failures and fixing...")
+            await self._ward()
+            # Retry tests
+            tests_passed = await self._alchemize()
+            if tests_passed:
+                self.complete_spell(result="Healed! All tests pass.")
+            else:
+                self.fail_spell("Tests still failing after self-healing")
+
+        # Step 6: Portal — deploy to production
+        self.cast(SpellType.PORTAL, "Deploying to production...")
+        live_url = await self._portal(artifacts)
+        if live_url:
+            self.set_live_url(live_url)
+            self.complete_spell(result=f"Live at: {live_url}", artifacts=[live_url])
+        else:
+            # Auto-retry deployment
+            self.fail_spell("Deployment failed — retrying...")
+            live_url = await self._portal(artifacts)
+            if live_url:
+                self.set_live_url(live_url)
+                self.complete_spell(result=f"Live at: {live_url}")
+            else:
+                self.fail_spell("Deployment failed after retries")
+
+        # Step 7: Chronicle
+        self.cast(SpellType.CHRONICLE, "Documenting the creation...")
+        self.complete_spell(result="Grimoire updated with full chronicle.")
+
+        # Final report
+        elapsed = time.time() - start_time
+        report = {
+            "dream": dream_text,
+            "status": "manifested" if self.live_url else "partial",
+            "live_url": self.live_url,
+            "artifacts": self.created_artifacts,
+            "spells_cast": len(self.spell_history),
+            "elapsed_seconds": elapsed,
+        }
+
+        print(f"\n{'='*60}")
+        print(f"🧙‍♂️ **MANIFESTATION COMPLETE**")
+        print(f"{'='*60}")
+        print(f"Dream: {dream_text[:80]}...")
+        if self.live_url:
+            print(f"🔮 Live at: {self.live_url}")
+        print(f"⚡ Spells cast: {len(self.spell_history)}")
+        print(f"⏱️  Time: {elapsed:.1f}s")
+        print(f"{'='*60}\n")
+
+        return report
+
+    # ── SPELL IMPLEMENTATIONS ──
+
+    async def _dreamweave(self, dream_text: str) -> Dict[str, Any]:
+        """Parse a dream into an architecture plan."""
+        # The Brain (HAM core) analyzes the dream and produces architecture
+        architecture = {
+            "description": dream_text,
+            "tech_stack": [],  # Brain fills this in
+            "features": [],     # Brain extracts these
+            "file_plan": [],    # Brain plans the file structure
+            "deployment_target": "kuberns",
+        }
+
+        # In the full implementation, the Brain reasons about the dream
+        # and populates the architecture autonomously
+        return architecture
+
+    async def _forge(self, architecture: Dict[str, Any]) -> List[str]:
+        """Generate all code files for the application."""
+        # The Brain generates production code file by file
+        artifacts = []
+
+        # Each file is generated with surgical precision (Claude Code style)
+        # Multiple files are created in parallel for speed
+
+        return artifacts
+
+    async def _alchemize(self) -> bool:
+        """Run tests and fix failures."""
+        # Execute tests
+        # If failures: analyze, fix, retry
+        # Return True if all pass
+        return True
+
+    async def _ward(self) -> bool:
+        """Self-healing: analyze failures, fix code, retry."""
+        # 1. Read error logs
+        # 2. Identify root cause
+        # 3. Apply fix
+        # 4. Verify fix
+        return True
+
+    async def _portal(self, artifacts: List[str]) -> Optional[str]:
+        """Deploy to production via Kuberns."""
+        # 1. Build container
+        # 2. Push to registry
+        # 3. Provision infrastructure
+        # 4. Configure DNS + SSL
+        # 5. Return live URL
+        return None  # Would be the actual URL if deployed
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# MAIN ENTRY POINT
+# ═══════════════════════════════════════════════════════════════════════════════
+
+async def main():
+    """Summon the Wizard from the command line."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="🧙‍♂️ Litehat — The Sovereign Universal Maker")
+    parser.add_argument("action", choices=["summon", "manifest"], help="Action to perform")
+    parser.add_argument("--dream", "-d", type=str, help="Your dream (what to build)")
+    parser.add_argument("--project", "-p", type=str, help="Project directory")
+
+    args = parser.parse_args()
+
+    wizard = WizardGrimoire()
+
+    if args.action == "summon":
+        print("""
+    ╔══════════════════════════════════════════════╗
+    ║  🧙‍♂️  LITEHAT — The Sovereign Universal Maker  ║
+    ║  "I don't just write code. I launch reality." ║
+    ╚══════════════════════════════════════════════╝
+        """)
+        if args.dream:
+            report = await wizard.manifest_dream(args.dream)
+            print(json.dumps(report, indent=2))
+        else:
+            print("The Wizard awaits your dream. Use --dream \"build me a...\"")
+
+    elif args.action == "manifest":
+        if args.dream:
+            report = await wizard.manifest_dream(args.dream)
+        else:
+            print("Provide a dream with --dream")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())