LYGO RESONANCE

#!/usr/bin/env python3
"""
LYGO Profile Generator v0.3
Image → Musical DNA + Lyrical Framework

Extracts visual mathematics from an image and translates it into
structured creative direction for music production and AI-assisted lyric writing.
"""

import cv2
import numpy as np
import json
import math
import argparse
from pathlib import Path
from datetime import datetime
from typing import Dict, Any, Optional

__version__ = "0.3.0"


class LYGOProfileGenerator:
    def __init__(self, verbose: bool = True):
        self.verbose = verbose

    def _log(self, msg: str):
        if self.verbose:
            print(msg)

    def analyze_image(self, image_path: str) -> Dict[str, Any]:
        """Extract rich mathematical features from the image."""
        img = cv2.imread(str(image_path))
        if img is None:
            raise FileNotFoundError(f"Image not found: {image_path}")

        if len(img.shape) == 2:
            img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)

        h, w, _ = img.shape
        total_pixels = h * w

        # === Color Analysis (HSV) ===
        hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
        avg_hue = float(np.mean(hsv[:, :, 0]) * 2)          # 0-360
        avg_sat = float(np.mean(hsv[:, :, 1]) / 255.0)
        avg_val = float(np.mean(hsv[:, :, 2]) / 255.0)
        sat_std = float(np.std(hsv[:, :, 1]) / 255.0)       # colorfulness

        # === Luminance & Contrast ===
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        brightness = float(np.mean(gray) / 255.0)
        contrast = float(np.std(gray) / 255.0)

        # === Structural Analysis ===
        edges = cv2.Canny(gray, 50, 150)
        edge_density = float(np.count_nonzero(edges) / total_pixels)

        # Contours for structural complexity
        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        structure_index = min(len(contours) / 80.0, 1.0)

        # Micro-chaos (FAST corners)
        fast = cv2.FastFeatureDetector_create(threshold=38)
        keypoints = fast.detect(gray, None)
        chaos_index = len(keypoints)

        features = {
            "source_image": str(Path(image_path).name),
            "dimensions": {"width": w, "height": h},
            "color": {
                "average_hue": round(avg_hue, 2),
                "average_saturation": round(avg_sat, 4),
                "average_brightness": round(brightness, 4),
                "colorfulness": round(sat_std, 4),
            },
            "structure": {
                "edge_density": round(edge_density, 4),
                "contrast": round(contrast, 4),
                "structure_index": round(structure_index, 4),
                "chaos_keypoints": chaos_index,
            },
        }
        return features

    def _get_musical_key(self, hue: float, brightness: float) -> str:
        keys = ["C", "G", "D", "A", "E", "B", "F#", "Db", "Ab", "Eb", "Bb", "F"]
        key_index = int(hue / 30) % 12
        mode = "Minor" if brightness < 0.48 else "Major"
        return f"{keys[key_index]} {mode}"

    def _calculate_bpm(self, edge_density: float, chaos: int, brightness: float) -> int:
        base = 82 + (edge_density * 920)
        chaos_mod = min(chaos / 1800, 0.6)
        brightness_mod = (brightness - 0.5) * 12
        bpm = int(base + (chaos_mod * 25) + brightness_mod)
        return max(78, min(178, bpm))

    def _generate_genre_texture(self, features: Dict) -> Dict[str, str]:
        e = features["structure"]["edge_density"]
        c = features["structure"]["chaos_keypoints"]
        b = features["color"]["average_brightness"]
        contrast = features["structure"]["contrast"]

        if c > 650 and b < 0.38:
            genre = "Industrial Dubstep / Dark Phonk"
            texture = "Heavy distortion, aggressive stutters, deep sub-bass, metallic textures"
            energy = "High-aggression"
        elif e > 0.065 and contrast > 0.18:
            genre = "Emo Rap / Modern Trap"
            texture = "Crisp hi-hats, melancholic melodies, heavy 808s, emotional vocal layers"
            energy = "Mid-High emotional"
        elif c > 420 and b > 0.55:
            genre = "Experimental / Glitch Hop"
            texture = "Glitchy percussion, chopped vocals, atmospheric synths, rhythmic complexity"
            energy = "High chaotic"
        elif e < 0.035 and b > 0.6:
            genre = "West Coast G-Funk / Smooth Instrumental"
            texture = "Laid-back grooves, warm analog bass, melodic leads, nostalgic atmosphere"
            energy = "Mid relaxed"
        else:
            genre = "Dark Alternative / Cinematic Rap"
            texture = "Atmospheric pads, punchy drums, moody synths, introspective energy"
            energy = "Mid cinematic"

        return {"genre": genre, "texture": texture, "energy": energy}

    def translate_to_lygo(self, features: Dict[str, Any]) -> Dict[str, Any]:
        """Convert visual features into musical and lyrical creative direction."""
        hue = features["color"]["average_hue"]
        brightness = features["color"]["average_brightness"]
        edge_density = features["structure"]["edge_density"]
        chaos = features["structure"]["chaos_keypoints"]
        contrast = features["structure"]["contrast"]

        musical_key = self._get_musical_key(hue, brightness)
        bpm = self._calculate_bpm(edge_density, chaos, brightness)
        genre_data = self._generate_genre_texture(features)

        # === Lyrical Theme Engine ===
        if brightness < 0.42 and edge_density > 0.055:
            core_theme = "Survival, betrayal, lone wolf resilience, moving in silence"
            lyric_prompt = (
                "Write raw, introspective lyrics about being the last one standing after betrayal. "
                "Focus on trust issues, a very small circle of ride-or-die people, and the cold satisfaction of outlasting everyone who counted you out."
            )
            vocal_style = "Raspy melodic rap or gritty sung-rap hybrid"
        elif chaos > 550:
            core_theme = "Breaking chains, system resistance, unchained personal power"
            lyric_prompt = (
                "Write aggressive yet intelligent lyrics about breaking free from systems that tried to define you. "
                "Emphasize resilience, moving in silence, and turning pain into unstoppable momentum."
            )
            vocal_style = "Assertive rap with melodic moments or distorted vocal processing"
        else:
            core_theme = "Observation, loyalty, navigating a cold modern world with quiet edge"
            lyric_prompt = (
                "Write clever, slightly dark observational lyrics with dry humor about modern life, loyalty, "
                "and staying true to your own code while everything around you feels artificial."
            )
            vocal_style = "Deadpan to melodic rap delivery, slightly introspective"

        # === Final Structured Output ===
        lygo_profile = {
            "LYGO_PROFILE": {
                "version": __version__,
                "generated_at": datetime.now().isoformat(),
                "source": features["source_image"],
                "mathematics": features,
                "musical_dna": {
                    "root_key": musical_key,
                    "bpm": bpm,
                    "energy_level": genre_data["energy"],
                    "suggested_genre": genre_data["genre"],
                    "texture_description": genre_data["texture"],
                    "vocal_style": vocal_style,
                },
                "lyrical_framework": {
                    "core_theme": core_theme,
                    "ai_lyric_prompt": lyric_prompt,
                },
                "ai_music_prompt": (
                    f"Create a {genre_data['genre']} track at {bpm} BPM in the key of {musical_key}. "
                    f"The overall energy should feel {genre_data['energy'].lower()}. "
                    f"Sound design and texture: {genre_data['texture']}. "
                    f"Lyrical themes should center around {core_theme}."
                ),
                "production_notes": (
                    f"High contrast and structural complexity suggest strong dynamic range. "
                    f"Consider heavy low-end support and atmospheric layers to match the visual weight."
                ),
            }
        }
        return lygo_profile

    def generate(self, image_path: str, output_json: str = "lygo_profile.json", create_brief: bool = False):
        self._log(f"\n╔════════════════════════════════════════════╗")
        self._log(f"║           LYGO Profile Generator v{__version__}      ║")
        self._log(f"║     Image → Musical DNA + Lyrical Framework║")
        self._log(f"╚════════════════════════════════════════════╝\n")

        features = self.analyze_image(image_path)
        profile = self.translate_to_lygo(features)

        # Save JSON
        with open(output_json, "w") as f:
            json.dump(profile, f, indent=2)

        self._log(json.dumps(profile, indent=2))
        self._log(f"\n[+] LYGO Profile saved → {output_json}")

        if create_brief:
            brief_path = Path(output_json).with_suffix(".brief.txt")
            self._create_creative_brief(profile, brief_path)
            self._log(f"[+] Creative Brief saved → {brief_path}")

    def _create_creative_brief(self, profile: Dict, path: Path):
        data = profile["LYGO_PROFILE"]
        brief = f"""LYGO CREATIVE BRIEF
Generated: {data['generated_at']}
Source Image: {data['source']}

══════════════════════════════════════════════
MUSICAL DNA
══════════════════════════════════════════════
Key: {data['musical_dna']['root_key']}
BPM: {data['musical_dna']['bpm']}
Energy: {data['musical_dna']['energy_level']}
Genre Direction: {data['musical_dna']['suggested_genre']}

Texture & Vibe:
{data['musical_dna']['texture_description']}

Vocal Approach: {data['musical_dna']['vocal_style']}

══════════════════════════════════════════════
LYRICAL DIRECTION
══════════════════════════════════════════════
Core Theme: {data['lyrical_framework']['core_theme']}

AI Prompt:
{data['lyrical_framework']['ai_lyric_prompt']}

══════════════════════════════════════════════
FULL AI MUSIC PROMPT (Copy-Paste Ready)
══════════════════════════════════════════════
{data['ai_music_prompt']}

Production Notes:
{data['production_notes']}
"""
        path.write_text(brief, encoding='utf-8')


def main():
    parser = argparse.ArgumentParser(
        description="LYGO Profile Generator — Turn any image into structured musical + lyrical creative direction"
    )
    parser.add_argument("image", help="Path to input image")
    parser.add_argument("-o", "--output", default="lygo_profile.json", help="Output JSON file")
    parser.add_argument("--brief", action="store_true", help="Also generate a human-readable .brief.txt file")
    parser.add_argument("--batch", action="store_true", help="Process all images in a folder")
    parser.add_argument("--quiet", action="store_true", help="Suppress console output")
    args = parser.parse_args()

    generator = LYGOProfileGenerator(verbose=not args.quiet)

    if args.batch:
        folder = Path(args.image)
        if not folder.is_dir():
            print("Error: --batch requires a folder path")
            return
        images = sorted(folder.glob("*.jpg")) + sorted(folder.glob("*.png")) + sorted(folder.glob("*.jpeg"))
        if not images:
            print("No images found in folder")
            return
        for img in images:
            print(f"\nProcessing: {img.name}")
            out_json = f"lygo_profile_{img.stem}.json"
            generator.generate(str(img), out_json, create_brief=args.brief)
        return

    generator.generate(args.image, args.output, create_brief=args.brief)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
LYGO RESONANCE - Gradio GUI
Web interface for the Resonance Engine and Profile Generator.
"""

import gradio as gr
import os
import json
from pathlib import Path
from resonance_engine import ResonanceEngine, PRESETS
from lygo_profile import LYGOProfileGenerator

def process_image(image_path, engine_type, style, seed, duration, noise_filter, 
                  export_stems, export_midi, export_brief, use_batch, batch_folder):
    
    # 1. Validation guardrails
    if not image_path and not use_batch:
        return "⚠️ Error: Please upload an image or enable batch processing mode.", None, None

    # 2. Setup output collections for file download components
    downloadable_files = []
    playback_audio = None

    try:
        # --- BATCH PROCESSING MODE ---
        if use_batch and batch_folder:
            folder = Path(batch_folder)
            if not folder.is_dir():
                return f"❌ Error: Batch folder path '{batch_folder}' does not exist or is invalid.", None, None
            
            images = sorted(folder.glob("*.jpg")) + sorted(folder.glob("*.png")) + sorted(folder.glob("*.jpeg"))
            if not images:
                return f"ℹ️ Notice: No compatible images (.jpg, .jpeg, .png) found in '{batch_folder}'.", None, None
            
            results = []
            for img in images:
                try:
                    if engine_type == "Resonance Engine (Audio)":
                        out_path = f"resonance_{img.stem}.wav"
                        config = {
                            "duration": duration,
                            "random_seed": int(seed) if seed != 0 else None,
                            "verbose": False,
                            "export_stems": export_stems,
                            "export_midi": export_midi,
                        }
                        if noise_filter > 0:
                            config["noise_lowpass_hz"] = noise_filter
                        
                        preset = PRESETS.get(style, {})
                        config.update(preset)
                        
                        engine = ResonanceEngine(config)
                        engine.process(str(img), out_path)
                        results.append(f"✓ {img.name} → {out_path}")
                        downloadable_files.append(out_path)
                        
                    else:
                        out_json = f"lygo_profile_{img.stem}.json"
                        generator = LYGOProfileGenerator(verbose=False)
                        generator.generate(str(img), out_json, create_brief=export_brief)
                        results.append(f"✓ {img.name} → {out_json}")
                        downloadable_files.append(out_json)
                        if export_brief:
                            downloadable_files.append(out_json.replace(".json", ".brief.txt"))
                            
                except Exception as batch_err:
                    results.append(f"✗ {img.name} → Error: {str(batch_err)}")
                    
            return "📦 Batch Processing Logs:\n" + "\n".join(results), None, downloadable_files

        # --- SINGLE IMAGE MODE ---
        img_p = Path(image_path)
        
        if engine_type == "Resonance Engine (Audio)":
            out_path = f"resonance_{img_p.stem}.wav"
            config = {
                "duration": duration,
                "random_seed": int(seed) if seed != 0 else None,
                "verbose": False,
                "export_stems": export_stems,
                "export_midi": export_midi,
            }
            if noise_filter > 0:
                config["noise_lowpass_hz"] = noise_filter
                
            preset = PRESETS.get(style, {})
            config.update(preset)
            
            engine = ResonanceEngine(config)
            engine.process(image_path, out_path)
            
            downloadable_files.append(out_path)
            playback_audio = out_path # Feed directly to audio player
            
            # Catch accompanying files if checked
            if export_midi:
                mid_file = out_path.replace(".wav", ".mid")
                if os.path.exists(mid_file):
                    downloadable_files.append(mid_file)
            if export_stems:
                for stem in ["noise", "drone", "melody", "glitch"]:
                    stem_file = out_path.replace(".wav", f"_{stem}.wav")
                    if os.path.exists(stem_file):
                        downloadable_files.append(stem_file)
                        
            log_msg = f"✅ Resonance Engine Matrix Complete.\nGenerated Stereo Mixdown: {out_path}"
            return log_msg, playback_audio, downloadable_files
            
        else:
            # LYGO Profile Mode
            out_json = f"lygo_profile_{img_p.stem}.json"
            generator = LYGOProfileGenerator(verbose=False)
            generator.generate(image_path, out_json, create_brief=export_brief)
            
            downloadable_files.append(out_json)
            
            # Read profile payload back to show the user the prompt data directly
            with open(out_json, "r", encoding="utf-8") as f:
                payload = json.load(f)
            
            ai_prompt = payload.get("LYGO_PROFILE", {}).get("ai_music_prompt", "Profile created.")
            log_msg = f"✅ LYGO DNA Profile Compiled Successfully!\nSaved Destination: {out_json}\n\n📋 AI Music Prompt Copy-Ready:\n\"{ai_prompt}\""
            
            if export_brief:
                brief_file = out_json.replace(".json", ".brief.txt")
                if os.path.exists(brief_file):
                    downloadable_files.append(brief_file)
                    
            return log_msg, None, downloadable_files

    except Exception as global_err:
        return f"❌ System Error executing core logic: {str(global_err)}", None, None

# --- DESIGN & LAYOUT THE INTERFACE ---
with gr.Blocks(theme=gr.themes.Box()) as demo:
    gr.Markdown("# 🌌 LYGO RESONANCE")
    gr.Markdown("### Core SDK Deployment — Visual-to-Audio Translation & Structural DNA Engine")
    
    with gr.Row():
        with gr.Column(scale=1):
            # Input block
            img_input = gr.Image(type="filepath", label="📸 Upload Source Image (Single File)")
            engine_choice = gr.Radio(
                ["Resonance Engine (Audio)", "LYGO Profile Generator"], 
                value="Resonance Engine (Audio)", 
                label="⚙️ Active Core Engine"
            )
            
            with gr.Accordion("🎨 Audio Synth Parameters (Resonance Engine)", open=True):
                preset_style = gr.Dropdown(
                    ["cinematic", "ambient", "glitch", "ethereal", "raw"], 
                    value="cinematic", 
                    label="Artistic Preset Blueprint"
                )
                duration_slider = gr.Slider(5, 60, value=15, step=1, label="Track Duration Length (Seconds)")
                seed_num = gr.Number(value=0, label="Mathematical Seed Lock (0 = Generative Continuous)")
                filter_hz = gr.Number(value=0, label="Noise Layer Lowpass Filter (Hz, 0 = Off)")
                stem_check = gr.Checkbox(label="Export Separated Audio Stems (.wav split)")
                midi_check = gr.Checkbox(label="Export Extracted Melodic MIDI Sequence")
                
            with gr.Accordion("📝 Analytical Parameters (Profile Engine)", open=False):
                brief_check = gr.Checkbox(value=True, label="Generate Human-Readable Brief (.brief.txt)")
                
            with gr.Accordion("📂 Automated Batch Processing Cluster", open=False):
                batch_check = gr.Checkbox(label="Activate Mass Batch Folder Mode")
                batch_dir = gr.Textbox(
                    label="Local Server Input Folder Directory", 
                    placeholder="e.g., ./input_folder"
                )
                
            submit_btn = gr.Button("🔮 Execute Spectral Scan", variant="primary")

        with gr.Column(scale=1):
            # Output block
            text_output = gr.Textbox(label="🖥️ Core Diagnostics Log & Text Prompts", lines=10, interactive=False)
            audio_player = gr.Audio(label="🎧 Real-Time Stereo Mix Down Preview", interactive=False)
            file_download = gr.Files(label="📦 Download Output Manifest (WAV, JSON, MID, TXT)", interactive=False)

    # Attach event processing hook
    submit_btn.click(
        fn=process_image,
        inputs=[
            img_input, engine_choice, preset_style, seed_num, duration_slider, filter_hz,
            stem_check, midi_check, brief_check, batch_check, batch_dir
        ],
        outputs=[text_output, audio_player, file_download]
    )

if __name__ == "__main__":
    demo.launch()

#!/usr/bin/env python3
"""
LYGO Video Resonance Engine
Extracts audio from video by analyzing motion and frame geometry over time.
"""

import cv2
import numpy as np
import soundfile as sf
import math
import argparse
from pathlib import Path
from resonance_engine import ResonanceEngine, PRESETS

class VideoResonanceEngine:
    def __init__(self, config=None):
        self.engine = ResonanceEngine(config)
    
    def process_video(self, video_path, output_path="video_soundscape.wav", 
                      fps=10, style="cinematic", duration_factor=1.0):
        
        cap = cv2.VideoCapture(video_path)
        if not cap.isOpened():
            raise ValueError(f"Cannot open video: {video_path}")
        
        frames = []
        while True:
            ret, frame = cap.read()
            if not ret:
                break
            frames.append(frame)
        cap.release()
        
        if not frames:
            raise ValueError("No frames extracted from video.")
        
        src_fps = cap.get(cv2.CAP_PROP_FPS)
        if src_fps <= 0:
            src_fps = 30
        step = max(1, int(src_fps / fps))
        frames = frames[::step]
        actual_fps = src_fps / step
        
        print(f"Extracted {len(frames)} frames at ~{actual_fps:.1f} FPS")
        
        # Use last frame for feature extraction
        temp_img_path = "_temp_video_frame.jpg"
        cv2.imwrite(temp_img_path, frames[-1])
        
        # Get baseline config from preset
        config = dict(PRESETS.get(style, {}))
        config["duration"] = len(frames) / actual_fps * duration_factor
        config["verbose"] = True
        
        engine = ResonanceEngine(config)
        features = engine.analyze_image(temp_img_path)
        
        # Generate audio segment for each frame with interpolation
        sr = engine.config["sr"]
        duration = config["duration"]
        audio = np.zeros((int(sr * duration), 2), dtype=np.float32)
        
        # Motion detection (optical flow between frames)
        prev_gray = cv2.cvtColor(frames[0], cv2.COLOR_BGR2GRAY)
        motion_scores = []
        
        for i, frame in enumerate(frames):
            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            flow = cv2.calcOpticalFlowFarneback(prev_gray, gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)
            mag, _ = cv2.cartToPolar(flow[..., 0], flow[..., 1])
            motion_score = np.mean(mag)
            motion_scores.append(motion_score)
            prev_gray = gray
        
        # Normalize motion scores
        max_motion = max(motion_scores) if motion_scores else 1
        motion_scores = [m / max_motion for m in motion_scores]
        
        # Generate audio
        for i, frame in enumerate(frames):
            cv2.imwrite(temp_img_path, frame)
            seg_features = engine.analyze_image(temp_img_path)
            
            # Adjust parameters based on motion
            motion = motion_scores[i] if i < len(motion_scores) else 0
            config["glitch_vol"] = 0.032 + (motion * 0.08)
            config["noise_vol"] = 0.095 + (motion * 0.06)
            config["drone_vol"] = 0.075 - (motion * 0.03)
            
            engine.config.update(config)
            
            # Generate short segment
            seg_duration = 1.0 / actual_fps
            engine.config["duration"] = seg_duration
            seg_audio = np.zeros((int(sr * seg_duration), 2), dtype=np.float32)
            
            # Simplified segment synthesis (reuse analyze/synthesize)
            # For efficiency, we use the full synthesis but only for a short duration
            engine.synthesize(seg_features, "_temp_seg.wav")
            seg, _ = sf.read("_temp_seg.wav")
            
            # Place in main audio
            start_idx = int(i * sr / actual_fps)
            end_idx = min(start_idx + len(seg), len(audio))
            seg_len = end_idx - start_idx
            audio[start_idx:end_idx] += seg[:seg_len]
        
        # Cleanup
        if Path("_temp_video_frame.jpg").exists():
            Path("_temp_video_frame.jpg").unlink()
        if Path("_temp_seg.wav").exists():
            Path("_temp_seg.wav").unlink()
        
        # Normalize and save
        peak = np.max(np.abs(audio))
        if peak > 0:
            audio = audio / peak * 0.97
        sf.write(output_path, audio, sr)
        print(f"✓ Video soundscape saved: {output_path}")
        return output_path


def main():
    parser = argparse.ArgumentParser(
        description="LYGO Video Resonance — Turn a video into a motion-driven soundscape"
    )
    parser.add_argument("video", help="Input video path")
    parser.add_argument("-o", "--output", default="video_soundscape.wav", help="Output .wav path")
    parser.add_argument("--fps", type=float, default=10, help="Frames per second to extract")
    parser.add_argument("--style", choices=list(PRESETS.keys()), default="cinematic",
                        help="Artistic preset")
    parser.add_argument("--duration-factor", type=float, default=1.0,
                        help="Multiply final duration (e.g., 0.5 for half speed, 2.0 for double)")
    args = parser.parse_args()
    
    engine = VideoResonanceEngine()
    engine.process_video(
        args.video,
        output_path=args.output,
        fps=args.fps,
        style=args.style,
        duration_factor=args.duration_factor
    )


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
LYGO LLM Integration
Expands LYGO creative briefs into full song lyrics using local LLMs (Ollama, llama.cpp, etc.)
"""

import json
import requests
from pathlib import Path
from typing import Optional, Dict, Any

class LYGOLLMExpander:
    def __init__(self, llm_url: str = "http://localhost:11434/api/generate", 
                 model: str = "llama3.2", verbose: bool = True):
        self.llm_url = llm_url
        self.model = model
        self.verbose = verbose
    
    def _log(self, msg: str):
        if self.verbose:
            print(msg)
    
    def expand_brief_to_lyrics(self, brief_path: Path, output_path: Optional[Path] = None) -> str:
        """Read a LYGO creative brief and generate full song lyrics using a local LLM."""
        with open(brief_path, 'r', encoding='utf-8') as f:
            brief = f.read()
        
        self._log(f"Reading brief: {brief_path}")
        
        prompt = f"""You are a professional songwriter. Based on the following creative brief, write a complete song with a title, verses, a chorus, a bridge, and an outro. Use vivid imagery and emotional depth.

Creative Brief:
{brief}

Now write the song. Include a title at the top."""
        
        self._log(f"Contacting LLM at {self.llm_url} with model {self.model}...")
        
        try:
            response = requests.post(
                self.llm_url,
                json={
                    "model": self.model,
                    "prompt": prompt,
                    "stream": False,
                    "temperature": 0.8,
                },
                timeout=60
            )
            response.raise_for_status()
            result = response.json()
            lyrics = result.get("response", "No response from LLM.")
            
            if output_path is None:
                output_path = brief_path.with_suffix(".lyrics.txt")
            
            with open(output_path, 'w', encoding='utf-8') as f:
                f.write(lyrics)
            
            self._log(f"✓ Lyrics saved: {output_path}")
            return lyrics
        
        except requests.exceptions.ConnectionError:
            error_msg = "Error: Could not connect to LLM. Make sure Ollama or llama.cpp is running."
            self._log(error_msg)
            return error_msg
        except Exception as e:
            self._log(f"Error: {str(e)}")
            return str(e)
    
    def batch_process_folder(self, folder_path: Path, output_folder: Optional[Path] = None):
        """Process all .brief.txt files in a folder."""
        briefs = list(folder_path.glob("*.brief.txt"))
        if not briefs:
            self._log("No .brief.txt files found in folder.")
            return
        
        if output_folder is None:
            output_folder = folder_path
        
        output_folder.mkdir(parents=True, exist_ok=True)
        
        for brief in briefs:
            out_path = output_folder / brief.with_suffix(".lyrics.txt").name
            self._log(f"Processing: {brief.name}")
            self.expand_brief_to_lyrics(brief, out_path)


def main():
    import argparse
    parser = argparse.ArgumentParser(
        description="LYGO LLM Expander — Turn creative briefs into full lyrics using local LLMs"
    )
    parser.add_argument("input", help="Path to .brief.txt file or folder (with --batch)")
    parser.add_argument("-o", "--output", default=None, help="Output path or folder")
    parser.add_argument("--llm-url", default="http://localhost:11434/api/generate",
                        help="Ollama/llama.cpp API URL")
    parser.add_argument("--model", default="llama3.2", help="LLM model name")
    parser.add_argument("--batch", action="store_true", help="Process all .brief.txt files in folder")
    args = parser.parse_args()
    
    expander = LYGOLLMExpander(llm_url=args.llm_url, model=args.model)
    
    if args.batch:
        folder = Path(args.input)
        if not folder.is_dir():
            print("Error: --batch requires a folder path")
            return
        expander.batch_process_folder(folder, Path(args.output) if args.output else None)
    else:
        brief_path = Path(args.input)
        if not brief_path.exists():
            print("Error: File not found")
            return
        output_path = Path(args.output) if args.output else None
        expander.expand_brief_to_lyrics(brief_path, output_path)


if __name__ == "__main__":
    main()