litehat/wizard.py

"""
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())