Clean repo with background music feature (no binary files)

.gitignore

@@ -0,0 +1,35 @@
+# Video files
+*.mp4
+*.avi
+*.mov
+*.mkv
+*.wmv
+*.flv
+
+# Output directories
+output/
+test_output/
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.env
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.temp 

demo.py

@@ -0,0 +1,239 @@
+# gradio_manim_gemini_app.py – **v3**
+"""Gradio demo 
+============
+— third revision —
+• **Правильная структура history** — теперь `Chatbot` получает список *пар*
+  `(user_text, bot_text)`.  Чанки бота апдей‑тят второй элемент последней пары,
+  поэтому «дубли» и «робот‑юзер» исчезают.  
+• **Ошибки рендера** публикуются *как пользовательское сообщение* и немедленно
+  отправляются в Gemini; модель отвечает, мы снова пытаемся сгенерировать код —
+  полностью автоматический цикл, как в вашем CLI‑скрипте.  
+• Управление состоянием сведено к чётким этапам: `await_task`, `coding_loop`,
+  `review_loop`, `finished`.
+
+Запуск:
+```bash
+pip install --upgrade gradio google-genai manim_video_generator
+export GEMINI_API_KEY="YOUR_KEY"
+python gradio_manim_gemini_app.py
+```
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import traceback
+from pathlib import Path
+from typing import List, Tuple
+
+import gradio as gr
+from google import genai
+from google.genai.chats import Chat
+from google.genai.types import GenerateContentConfig, ThinkingConfig, UploadFileConfig
+
+from manim_video_generator.video_executor import VideoExecutor  # type: ignore
+from prompts import SYSTEM_PROMPT_SCENARIO_GENERATOR, SYSTEM_PROMPT_CODEGEN, REVIEW_PROMPT
+
+# ────────────────────────────────  Config  ─────────────────────────────────────
+
+API_KEY = os.getenv("GEMINI_API_KEY")
+if not API_KEY:
+    raise EnvironmentError("GEMINI_API_KEY env variable not set.")
+
+client = genai.Client(api_key=API_KEY)
+MODEL = "gemini-2.5-flash-preview-05-20"
+video_executor = VideoExecutor()
+
+# ───────────────────────  Helpers to work with Chatbot  ─────────────────────────
+
+def add_user_msg(history: List[Tuple[str, str]], text: str):
+    """Append new (user, «») pair."""
+    history.append((text, ""))
+
+
+def append_bot_chunk(history: List[Tuple[str, str]], chunk: str):
+    """Add chunk to bot part of the last pair."""
+    user, bot = history[-1]
+    history[-1] = (user, bot + chunk)
+
+
+class StreamPart:
+    def __init__(self, text: str):
+        self.text = text
+
+class ThinkingStreamPart(StreamPart): pass
+class TextStreamPart(StreamPart): pass
+
+
+def stream_parts(chat: Chat, prompt):
+    cfg = GenerateContentConfig(thinking_config=ThinkingConfig(include_thoughts=True))
+    for chunk in chat.send_message_stream(prompt, config=cfg):
+        if chunk.candidates:
+            cand = chunk.candidates[0]
+            if cand.content and cand.content.parts:
+                for part in cand.content.parts:
+                    if part.text:
+                        if part.thought:
+                            yield ThinkingStreamPart(part.text)
+                        else:
+                            yield TextStreamPart(part.text)
+
+
+def extract_python(md: str) -> str:
+    m = re.search(r"```python(.*?)```", md, re.S)
+    if not m:
+        raise ValueError("No ```python``` block found in model output.")
+    return m.group(1).strip()
+
+# ──────────────────────────  Session state  ────────────────────────────────────
+
+class Session(dict):
+    phase: str  # await_task | coding_loop | review_loop | finished
+    chat: Chat | None
+    last_video: Path | None
+
+    def __init__(self):
+        super().__init__(phase="await_task", chat=None, last_video=None)
+        self.phase = "await_task"
+        self.chat = None
+        self.last_video = None
+
+# ────────────────────────  Main chat handler  ──────────────────────────────────
+
+async def chat_handler(user_msg: str, history: List[Tuple[str, str]], state: Session):
+    history = history or []
+
+    # 0. Always reflect user input
+    add_user_msg(history, user_msg)
+    yield history, state, state.last_video
+
+    # bootstrap chat on very first user request
+    if state.phase == "await_task":
+        state.chat = client.chats.create(model=MODEL)
+        # ── Scenario generation ────────────────────────────────────────────────
+        scenario_prompt = f"{SYSTEM_PROMPT_SCENARIO_GENERATOR}\n\n{user_msg}"
+        for txt in stream_parts(state.chat, scenario_prompt):
+            append_bot_chunk(history, txt.text)
+            yield history, state, state.last_video
+            await asyncio.sleep(0)
+
+        append_bot_chunk(history, "\n\n*(type **continue** to proceed to code generation)*")
+        state.phase = "coding_loop"
+        yield history, state, state.last_video
+        return
+
+    # later phases require chat obj
+    if not state.chat:
+        append_bot_chunk(history, "⚠️ Internal error: lost chat session.")
+        yield history, state, state.last_video
+        return
+
+    # ── Coding loop ─────────────────────────────────────────────────────────────
+    if state.phase == "coding_loop":
+        if user_msg.strip().lower() not in {"c", "continue", "с"}:
+            append_bot_chunk(history, "⚠️ Type **continue** to move on.")
+            yield history, state, state.last_video
+            return
+        prompt = (
+            "Thanks. It is good scenario. Now generate code for it.\n\n" + SYSTEM_PROMPT_CODEGEN
+        )
+        while True:  # keep cycling until render succeeds
+            # 1. Ask for code
+            for chunk in stream_parts(state.chat, prompt):
+                append_bot_chunk(history, chunk.text)
+                yield history, state, state.last_video
+                await asyncio.sleep(0)
+
+            full_answer = history[-1][1]
+            try:
+                py_code = extract_python(full_answer)
+            except ValueError as e:
+                # send formatting error to model, loop again
+                err_msg = f"Error: {e}. Please wrap the code in ```python``` fence."
+                prompt = err_msg
+                add_user_msg(history, err_msg)
+                yield history, state, state.last_video
+                continue  # restart loop
+
+            # 2. Render
+            try:
+                video_path = video_executor.execute_manim_code(py_code)
+                state.last_video = video_path
+            except Exception as e:
+                tb = traceback.format_exc(limit=10)
+                err_msg = f"Error, your code is not valid: {e}. Traceback: {tb}. Please fix this error and regenerate the code again."
+                prompt = err_msg
+                add_user_msg(history, err_msg)  # error == user message
+                yield history, state, state.last_video
+                continue  # Gemini will answer with a fix
+
+            append_bot_chunk(history, "\n🎞️ Rendering done, uploading for review…")
+            yield history, state, state.last_video
+
+            # 3. Upload
+            try:
+                file_ref = client.files.upload(
+                    file=video_path, config=UploadFileConfig(display_name=video_path.name)
+                )
+                while file_ref.state and file_ref.state.name == "PROCESSING":
+                    await asyncio.sleep(3)
+                    if file_ref.name:
+                        file_ref = client.files.get(name=file_ref.name)
+                if file_ref.state and file_ref.state.name == "FAILED":
+                    raise RuntimeError("Gemini failed to process upload")
+            except Exception as up_err:
+                err_msg = f"Upload error: {up_err}"
+                add_user_msg(history, err_msg)
+                yield history, state, state.last_video
+                continue  # ask Gemini to fix
+
+            # 4. Review
+            review_prompt = [file_ref, REVIEW_PROMPT]
+            add_user_msg(history, "# system → review video")
+            for chunk in stream_parts(state.chat, review_prompt):
+                append_bot_chunk(history, chunk.text)
+                yield history, state, state.last_video
+                await asyncio.sleep(0)
+
+            if "no issues found" in history[-1][1].lower():
+                append_bot_chunk(history, "\n✅ Video accepted! 🎉")
+                state.phase = "finished"
+                yield history, state, state.last_video
+                return
+            else:
+                append_bot_chunk(history, "\n🔄 Issues found. Trying again…")
+                # let the loop run again (Gemini will generate corrected code)
+                continue
+
+    # ── Finished phase ──────────────────────────────────────────────────────────
+    if state.phase == "finished":
+        append_bot_chunk(history, "Session complete. Refresh page to start over.")
+        yield history, state, state.last_video
+
+# ───────────────────────────────  UI  ──────────────────────────────────────────
+
+def build_app():
+    with gr.Blocks(title="Gemini‑Manim Video Creator") as demo:
+        gr.Markdown("# 🎬 Gemini‑Manim Video Creator\nCreate an explanatory animation from a single prompt.")
+
+        history = gr.Chatbot(height=850)
+        session = gr.State(Session())
+
+        with gr.Row():
+            txt = gr.Textbox(placeholder="Describe the concept…", scale=4)
+            btn = gr.Button("Send", variant="primary")
+
+        vid = gr.Video(label="Rendered video", interactive=False)
+
+        def get_vid(state: Session):
+            return state.last_video if state.last_video else None
+
+        btn.click(chat_handler, [txt, history, session], [history, session, vid]) \
+           .then(lambda: "", None, txt)
+
+    return demo
+
+
+if __name__ == "__main__":
+    build_app().launch()

main.py

@@ -0,0 +1,157 @@
+import asyncio
+import time
+from google import genai
+import os
+from dotenv import load_dotenv
+from google.genai.chats import Chat
+from manim_video_generator.video_executor import VideoExecutor
+from prompts import SYSTEM_PROMPT_SCENARIO_GENERATOR, SYSTEM_PROMPT_CODEGEN, REVIEW_PROMPT
+from google.genai.types import (
+    GenerateContentResponse,
+    ThinkingConfig,
+    GenerateContentConfig,
+    UploadFileConfig,
+)
+from pathlib import Path
+import traceback
+
+load_dotenv()
+
+
+
+async def main():
+    client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
+    video_executor = VideoExecutor()
+
+    chat: Chat = client.chats.create(model="gemini-2.5-flash-preview-05-20")
+
+    user_task = input("Enter your task: ")
+    assert (
+        len(user_task) > 0 and len(user_task) < 10000
+    ), "Task must be between 1 and 10000 characters"
+
+    user_input = SYSTEM_PROMPT_SCENARIO_GENERATOR + "\n\n" + user_task
+    # Generate scenario
+    for iter in range(1000):
+        answer = ""
+        chunk: GenerateContentResponse
+        for chunk in chat.send_message_stream(
+            user_input,
+            config=GenerateContentConfig(
+                thinking_config=ThinkingConfig(
+                    include_thoughts=True,
+                ),
+            ),
+        ):
+            print()
+            if chunk.candidates:
+                candidate = chunk.candidates[0]
+                if candidate.content and candidate.content.parts:
+                    for part in candidate.content.parts:
+                        if part.thought:
+                            print('💭: ', part.text, end="", flush=True)
+                        elif part.text:
+                            print(part.text, end="", flush=True)
+                            answer += part.text
+        user_input = input("Answer answer to scenario manager or continue (c)?")
+        if user_input.lower() in ("c", "continue", 'с'):
+            print("Scenario created")
+            scenario = answer
+            break
+    
+    # Generate code
+    user_input = "Thanks. It is good scenario. Now generate code for it.\n\n" + SYSTEM_PROMPT_CODEGEN 
+    print('Generating code...')
+    for iter in range(1000):
+        answer = ""
+        chunk: GenerateContentResponse
+        for chunk in chat.send_message_stream(
+            user_input,
+            config=GenerateContentConfig(
+                thinking_config=ThinkingConfig(
+                    include_thoughts=True,
+                ),
+            ),
+        ):
+            print()
+            if chunk.candidates:
+                candidate = chunk.candidates[0]
+                if candidate.content and candidate.content.parts:
+                    for part in candidate.content.parts:
+                        if part.thought:
+                            print('💭: ', part.text, end="", flush=True)
+                        elif part.text:
+                            print(part.text, end="", flush=True)
+                            answer += part.text
+        try:
+            code = answer.split("```python")[1].split("```")[0]
+        except Exception as e:
+            print(f"Error: {e}")
+            user_input = f"Error, your answer is not valid formated manim code."
+            continue
+
+        
+        try:
+            video_path: Path = video_executor.execute_manim_code(code)
+            print(f"Video generated at {video_path}")
+        except Exception as e:
+            print(f"Error: {e}")
+            traceback_str = traceback.format_exc()
+            user_input = f"Error, your code is not valid: {e}. Please fix it. Traceback: {traceback_str}"
+            continue
+        
+        myfile = client.files.upload(file=video_path.absolute(),
+                                    config=UploadFileConfig(
+                                        display_name=video_path.name
+                                    ))
+        assert myfile.name, "File name is not set"
+        assert myfile.state, "File state is not set"
+        
+        print('Uploading video file to google genai...')
+        while myfile.state.name == "PROCESSING":
+            print('.', end='', flush=True)
+            time.sleep(10)
+            myfile = client.files.get(name=myfile.name)
+        print(f"File uploaded at {myfile.name}")
+
+        if myfile.state.name == "FAILED":
+            raise ValueError(myfile.state.name)
+        
+        print(f"File uploaded at {myfile.name}")
+
+
+
+        for chunk in chat.send_message_stream(
+            [myfile, REVIEW_PROMPT],
+            config=GenerateContentConfig(
+                thinking_config=ThinkingConfig(
+                    include_thoughts=True,
+                ),
+            ),
+        ):
+            if chunk.candidates:
+                candidate = chunk.candidates[0]
+                if candidate.content and candidate.content.parts:
+                    for part in candidate.content.parts:
+                        if part.text:
+                            if part.thought:
+                                print('💭: ', part.text, end="", flush=True)
+                            else:
+                                print(part.text, end="", flush=True)
+                                answer += part.text
+        if "no issues found" in answer.lower():
+            print("No issues found")
+            break
+        else:
+            print("Issues found")
+            user_prompt = input("Prompt for fixing issues (or n to exit): ")
+            if user_prompt.lower() == 'n':
+                break
+            else:
+                user_input = f"Fix this problems please."
+                if user_prompt.strip():
+                    user_input += f" TIP: {user_prompt}"
+        
+
+if __name__ == "__main__":
+    asyncio.run(main())

manim_video_generator/gemini_client.py

@@ -0,0 +1,177 @@
+import os
+import google.generativeai as genai
+from loguru import logger
+from dotenv import load_dotenv
+from typing import Optional, TYPE_CHECKING
+import re
+
+if TYPE_CHECKING:
+    from .context_manager import ConversationContext
+
+load_dotenv()
+
+
+class GeminiClient:
+    def __init__(self, api_key: str = None, context_manager: Optional['ConversationContext'] = None):
+        self.api_key = api_key or os.getenv("GEMINI_API_KEY")
+        if not self.api_key:
+            raise ValueError("GEMINI_API_KEY not found in environment variables")
+        
+        genai.configure(api_key=self.api_key)
+        self.model = genai.GenerativeModel("gemini-2.0-flash-thinking-exp")
+        self.context_manager = context_manager
+        logger.info("Gemini client initialized")
+
+    def generate_manim_code(self, user_request: str) -> str:
+        """Generate Manim code based on the user's request"""
+        
+        # Системный промпт с инструкциями
+        system_prompt = """You are a Manim code generator. Your ONLY task is to generate executable Python code using the Manim library.
+
+CRITICAL RULES:
+- You MUST respond with ONLY Python code, nothing else
+- NO explanations, NO text, NO comments outside the code
+- The code MUST be ready to execute immediately
+- The response should start with "from manim import *" and contain a complete Scene class
+
+CODE REQUIREMENTS:
+1. Always import: from manim import *
+2. Create a class that inherits from Scene (default name: VideoScene)
+3. Implement the construct(self) method
+4. Use self.play() for animations
+5. End with self.wait(1) or self.wait(2)
+6. Use Text() instead of MathTex() for all text (MathTex requires LaTeX setup)
+7. For mathematical formulas, use Text() with Unicode symbols: ², ³, ∫, ∑, π, etc.
+8. Use simple geometric shapes: Square(), Circle(), Rectangle(), Line(), etc.
+9. Common animations: Write(), Create(), Transform(), FadeIn(), FadeOut(), DrawBorderThenFill()
+10. Position objects with .move_to(), .shift(), .to_edge(), .next_to()
+
+EXAMPLE OUTPUT FORMAT (this is exactly how your response should look):
+```python
+from manim import *
+
+class VideoScene(Scene):
+    def construct(self):
+        title = Text("Example Title")
+        self.play(Write(title))
+        self.wait(2)
+```
+
+IMPORTANT: 
+- Your entire response must be valid Python code
+- Do not include any text before or after the code
+- If the request is in any language other than English, still generate code with English variable names and comments
+- Focus on creating visually appealing animations that demonstrate the requested concept"""
+
+        # Получаем контекст предыдущих сообщений
+        messages = []
+        if self.context_manager:
+            messages = self.context_manager.get_context_for_gemini()
+        
+        # Добавляем системный промпт и текущий запрос если истории нет
+        if not messages:
+            messages = [
+                {"role": "user", "parts": [{"text": f"{system_prompt}\n\nCreate a video for the request: {user_request}"}]}
+            ]
+
+        # Debug логирование полного контекста
+        logger.debug(f"Sending {len(messages)} messages to Gemini:")
+        for i, message in enumerate(messages):
+            logger.debug(f"Message {i+1} ({message['role']}): {message['parts'][0]['text'][:200]}{'...' if len(message['parts'][0]['text']) > 200 else ''}")
+
+        logger.info(f"Sending request to Gemini with {len(messages)} context messages")
+        response = self.model.generate_content(messages)
+        
+        # Extract code from the response
+        code = response.text.strip()
+        
+        # Улучшенное извлечение кода
+        if code.startswith("```python"):
+            # Стандартный случай: код начинается с ```python
+            code = code[9:]
+            if code.endswith("```"):
+                code = code[:-3]
+        elif code.startswith("```"):
+            # Код начинается с ```
+            code = code[3:]
+            if code.endswith("```"):
+                code = code[:-3]
+        else:
+            # Ищем первый блок кода внутри текста
+            python_match = re.search(r'```python\s*\n(.*?)\n```', code, re.DOTALL)
+            if python_match:
+                code = python_match.group(1)
+            else:
+                # Ищем любой блок ```
+                code_match = re.search(r'```\s*\n(.*?)\n```', code, re.DOTALL)
+                if code_match:
+                    code = code_match.group(1)
+                # Если нет блоков кода, оставляем как есть (весь ответ)
+        
+        code = code.strip()
+        logger.info("Manim code generated successfully")
+        return code
+
+    def fix_manim_code(self, current_code: str, error_trace: str, user_hint: str | None = None) -> str:
+        """Fix Manim code using the error trace and optional user hint"""
+        
+        # Получаем контекст
+        messages = []
+        if self.context_manager:
+            messages = self.context_manager.get_context_for_gemini()
+        
+        # Если контекста нет, создаем базовое сообщение
+        if not messages:
+            hint_block = f"\nUser hint: {user_hint}" if user_hint else ""
+            prompt = f"""
+You are an assistant that helps fix errors in Manim code.
+
+Current code:
+```python
+{current_code}
+```
+
+Execution error:
+{error_trace}
+{hint_block}
+
+Provide the corrected code. Return ONLY the Python code without explanations.
+"""
+            messages = [{"role": "user", "parts": [{"text": prompt}]}]
+
+        # Debug логирование полного контекста
+        logger.debug(f"Sending {len(messages)} messages to Gemini for code fix:")
+        for i, message in enumerate(messages):
+            logger.debug(f"Message {i+1} ({message['role']}): {message['parts'][0]['text'][:200]}{'...' if len(message['parts'][0]['text']) > 200 else ''}")
+
+        logger.info("Sending code fix request to Gemini")
+        response = self.model.generate_content(messages)
+
+        fixed = response.text.strip()
+
+        # Улучшенное извлечение кода
+        if fixed.startswith("```python"):
+            # Стандартный случай: код начинается с ```python
+            fixed = fixed[9:]
+            if fixed.endswith("```"):
+                fixed = fixed[:-3]
+        elif fixed.startswith("```"):
+            # Код начинается с ```
+            fixed = fixed[3:]
+            if fixed.endswith("```"):
+                fixed = fixed[:-3]
+        else:
+            # Ищем первый блок кода внутри текста
+            python_match = re.search(r'```python\s*\n(.*?)\n```', fixed, re.DOTALL)
+            if python_match:
+                fixed = python_match.group(1)
+            else:
+                # Ищем любой блок ```
+                code_match = re.search(r'```\s*\n(.*?)\n```', fixed, re.DOTALL)
+                if code_match:
+                    fixed = code_match.group(1)
+                # Если нет блоков кода, оставляем как есть (весь ответ)
+
+        fixed = fixed.strip()
+        logger.info("Received fixed code from Gemini")
+        return fixed

manim_video_generator/video_executor.py

@@ -0,0 +1,140 @@
+import os
+import tempfile
+import subprocess
+import shutil
+from pathlib import Path
+from loguru import logger
+from moviepy.editor import VideoFileClip, AudioFileClip, CompositeAudioClip, concatenate_audioclips
+
+
+class VideoExecutor:
+    def __init__(self, output_dir: str = "output"):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+        self.music_file = Path("data/music.mp3")
+        logger.info(f"VideoExecutor initialized, output directory: {self.output_dir}")
+        
+        if not self.music_file.exists():
+            logger.warning(f"Background music file not found: {self.music_file}")
+
+    def execute_manim_code(self, code: str, scene_name: str = "VideoScene") -> Path:
+        """Execute Manim code in an isolated environment and return the video path"""
+        
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            
+            # Create a temporary file with the code
+            code_file = temp_path / "scene.py"
+            with open(code_file, "w", encoding="utf-8") as f:
+                f.write(code)
+            
+            logger.info(f"Code written to temporary file: {code_file}")
+            
+            # Run Manim
+            output_file = self._run_manim(code_file, scene_name, temp_path)
+            
+            # Add background music
+            output_file = self._add_background_music(output_file, temp_path)
+            
+            # Copy the result to the output folder
+            final_output = self._copy_to_output(output_file)
+            
+            return final_output
+
+    def _run_manim(self, code_file: Path, scene_name: str, temp_dir: Path) -> Path:
+        """Run Manim to render the video"""
+        
+        cmd = [
+            "manim", "render",
+            str(code_file),
+            scene_name,
+            "--format", "mp4",
+            "-q", "m",  # medium quality: 'l'=low, 'm'=medium, 'h'=high, 'p'=4k, 'k'=8k
+            "--output_file", "video.mp4"
+        ]
+        
+        logger.info(f"Executing command: {' '.join(cmd)}")
+        
+        # Execute the command in the temporary directory
+        result = subprocess.run(
+            cmd,
+            cwd=temp_dir,
+            capture_output=True,
+            text=True,
+            timeout=300  # 5 minutes max
+        )
+        
+        if result.returncode != 0:
+            logger.error(f"Manim execution error: {result.stderr}")
+            raise RuntimeError(f"Manim exited with error: {result.stderr}")
+        
+        logger.info("Manim executed successfully")
+        
+        # Look for the created video
+        media_dir = temp_dir / "media"
+        if not media_dir.exists():
+            raise FileNotFoundError("Media folder not found after running Manim")
+        
+        # Search for mp4 file recursively
+        video_files = list(media_dir.rglob("*.mp4"))
+        if not video_files:
+            raise FileNotFoundError("Video file not found after rendering")
+        
+        # Take the most recent file
+        video_file = max(video_files, key=lambda f: f.stat().st_mtime)
+        logger.info(f"Video file found: {video_file}")
+        
+        return video_file
+
+    def _add_background_music(self, video_file: Path, temp_dir: Path) -> Path:
+        """Add background music to the video"""
+        logger.info("Adding background music to video")
+        
+        video_with_music = temp_dir / "video_with_music.mp4"
+        
+        # Load video and music
+        video = VideoFileClip(str(video_file))
+        music = AudioFileClip(str(self.music_file))
+        
+        # Adjust music duration to match video
+        video_duration = video.duration
+        if music.duration > video_duration:
+            # Trim music if longer than video
+            music = music.subclip(0, video_duration)
+        else:
+            # Loop music if shorter than video
+            loops_needed = int(video_duration // music.duration) + 1
+            music = concatenate_audioclips([music] * loops_needed).subclip(0, video_duration)
+        
+        # Set music volume lower to not overpower original audio (if any)
+        music = music.volumex(0.3)  # 30% volume
+        
+        # Combine original audio with music
+        if video.audio is not None:
+            final_audio = CompositeAudioClip([video.audio, music])
+        else:
+            final_audio = music
+        
+        # Create final video with music
+        final_video = video.set_audio(final_audio)
+        final_video.write_videofile(str(video_with_music), codec='libx264', audio_codec='aac')
+        
+        # Clean up
+        video.close()
+        music.close()
+        final_video.close()
+        
+        logger.info(f"Background music added: {video_with_music}")
+        return video_with_music
+
+    def _copy_to_output(self, video_file: Path) -> Path:
+        """Copy video to the output folder with a unique name"""
+        
+        import time
+        timestamp = int(time.time())
+        output_file = self.output_dir / f"video_{timestamp}.mp4"
+        
+        shutil.copy2(video_file, output_file)
+        logger.info(f"Video copied to: {output_file}")
+        
+        return output_file  

prompts.py

@@ -0,0 +1,21 @@
+SYSTEM_PROMPT_SCENARIO_GENERATOR = """
+You are a scenario generator for short manim video (5-30 seconds). Your first task is to generate a scenario for a video. 
+User will provide you a video idea and you will need to generate a scenario for the video. You have a technical restrictions:
+- The video should be 5-30 seconds long.
+- The video will be generated using Manim library
+
+Answer is a normal text, not a code. If you have any questions, ask user for clarification.
+"""
+
+SYSTEM_PROMPT_CODEGEN = """
+Now you are a Manim code generator. Your ONLY task is to generate executable Python code using the Manim library.
+User will provide you a video idea that he has discussed with scenario manager and you will need to generate a Manim code that will execute the user request.
+Format code inside ```python and ``` tags. Answer only code, no other text. Generate your code in one file. P.S. Do not use latex for text.
+"""
+
+REVIEW_PROMPT = """
+You are a short video reviewer. User with video producer and coder has generated a video. Your task is to review the video and make sure it is correct.
+First, check the consistency of the video. The text should not overlap, the image should not go off frame, and objects should not hang in the air but be in their proper places.
+If you see any issues, please point them out in text format, othervise answer "No issues found".
+"""
+

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+google-genai
+manim
+moviepy==1.0.3
+loguru