Clean repository for Hugging Face deployment

.gitignore

@@ -0,0 +1,28 @@
+# Virtual Environment
+venv/
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Environment variables
+.env
+
+# Build folders
+dist/
+build/
+
+# Project generated files
+assets/uploads/
+assets/outputs/
+!assets/uploads/.gitkeep
+!assets/outputs/.gitkeep
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE settings
+.vscode/

README.md

@@ -0,0 +1,127 @@
+# CLIPFORGE
+
+🚀 CLPFORGE
+AI-Powered Content Creation Engine
+
+CLPFORGE is an AI-driven content generation toolkit that helps creators instantly generate:
+
+🎬 Video Ideas
+
+📝 Scripts
+
+🗣 Subtitles
+
+🖼 Thumbnail Concepts & AI Prompts
+
+Built for creators who want speed, consistency, and higher engagement without wasting hours brainstorming.
+
+🔥 Features
+1️⃣ Idea Generator
+
+Generates high-potential content ideas based on:
+
+Niche
+
+Target Audience
+
+Content Type (Shorts, Long-form, Reels, etc.)
+
+Trending-style prompt patterns
+
+Focus: Ideas engineered for attention and scalability, not generic topics.
+
+2️⃣ Script Generator
+
+Creates structured, retention-optimized scripts including:
+
+Hook
+
+Pattern Interrupts
+
+Retention Loops
+
+Body Content
+
+Call-to-Action (CTA)
+
+Supports:
+
+Short-form (30–60 sec)
+
+Long-form YouTube scripts
+
+Educational breakdowns
+
+Storytelling formats
+
+3️⃣ Subtitle Generator
+
+Generates subtitles designed for engagement:
+
+Short, punchy lines
+
+Scroll-stopping formatting
+
+Retention-focused phrasing
+
+Optional SRT-style structure support
+
+4️⃣ Thumbnail Generator
+
+Generates:
+
+High-CTR thumbnail text
+
+Visual direction concepts
+
+AI image prompts (Midjourney / DALL·E / Stable Diffusion ready)
+
+Built around:
+
+Curiosity Gap
+
+Emotional Triggers
+
+Click-through psychology
+
+🧠 How It Works
+
+CLPFORGE uses prompt engineering + AI models to:
+
+Analyze niche or topic input
+
+Generate multiple idea variations
+
+Structure scripts for audience retention
+
+Format subtitles for engagement
+
+Suggest high-CTR thumbnail concepts
+
+The system focuses on content performance, not just content generation.
+
+🎯 Target Users
+
+YouTube Creators
+
+Short-form Content Creators
+
+Digital Marketers
+
+Content Agencies
+
+Personal Brands
+
+🚧 Roadmap
+
+Planned improvements:
+
+Direct AI thumbnail image generation
+
+Trend scraping integration
+
+Multi-language support
+
+SEO optimization module
+
+Performance analytics dashboard

app.py

@@ -0,0 +1,289 @@
+import gradio as gr
+import shutil
+import os
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from modules.summarizer import summarize_text
+from modules.frame_extractor import extract_frame
+from modules.thumbnail import generate_thumbnail
+from modules.composer import compose_videos
+from modules.subtitles import generate_subtitles
+from modules.subtitle_burner import burn_subtitles
+
+
+UPLOAD_DIR = "assets/uploads"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+
+# ---------------- FUNCTIONS ----------------
+
+def save_uploaded_video(video_file):
+    if video_file is None:
+        return "❌ No video uploaded."
+
+    filename = os.path.basename(video_file)
+    destination = os.path.join(UPLOAD_DIR, filename)
+    shutil.copy(video_file, destination)
+
+    return f"✅ Video uploaded: {filename}"
+
+
+def summarize_ui(text):
+    if not text.strip():
+        return "Please enter text."
+    return summarize_text(text)
+
+
+def create_thumbnail(video_file, title_text):
+    if video_file is None:
+        return None
+    frame = extract_frame(video_file)
+    return generate_thumbnail(frame, title_text)
+
+
+def compose_ui(video_files):
+    if not video_files:
+        return None
+    return compose_videos(video_files)
+
+
+def subtitle_ui(video):
+    if video is None:
+        return None
+    return generate_subtitles(video)
+
+
+def burn_subtitles_ui(video, subtitle_file):
+    if video is None or subtitle_file is None:
+        return None
+    return burn_subtitles(video, subtitle_file)
+
+
+# ---------------- CSS ----------------
+
+custom_css = """
+body{
+background:linear-gradient(135deg,#020617,#0f172a);
+font-family:Inter;
+}
+
+.hero{
+text-align:center;
+padding:50px;
+}
+
+.hero-title{
+font-size:44px;
+font-weight:800;
+background:linear-gradient(90deg,#60a5fa,#a78bfa,#c084fc);
+-webkit-background-clip:text;
+-webkit-text-fill-color:transparent;
+}
+
+.navbar{
+display:flex;
+gap:20px;
+justify-content:center;
+margin-bottom:25px;
+}
+
+.card{
+background:#0f172a;
+padding:25px;
+border-radius:14px;
+box-shadow:0 8px 20px rgba(0,0,0,0.4);
+}
+"""
+
+
+# ---------------- UI ----------------
+
+with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as app:
+
+    with gr.Column(elem_classes="hero"):
+        gr.Markdown("""
+<div class="hero-title">🎬 ClipForge AI</div>
+Create viral short-form content using AI
+""")
+
+    # NAVIGATION BAR
+    with gr.Row():
+        btn_upload = gr.Button("📥 Upload")
+        btn_summary = gr.Button("📝 Summary")
+        btn_thumbnail = gr.Button("🖼 Thumbnail")
+        btn_subtitle = gr.Button("🎤 Subtitles")
+        btn_composer = gr.Button("🎞 Composer")
+        btn_burn = gr.Button("🔥 Burn")
+
+    # SECTIONS
+
+    with gr.Column(visible=True) as upload_section:
+        with gr.Column(elem_classes="card"):
+            video_input = gr.Video()
+            upload_btn = gr.Button("Upload Video")
+            upload_status = gr.Textbox(label="Status")
+
+            upload_btn.click(
+                save_uploaded_video,
+                inputs=video_input,
+                outputs=upload_status
+            )
+
+
+    with gr.Column(visible=False) as summary_section:
+        with gr.Column(elem_classes="card"):
+            input_text = gr.Textbox(lines=5)
+            summarize_btn = gr.Button("Generate Summary")
+            output_text = gr.Textbox()
+
+            summarize_btn.click(
+                summarize_ui,
+                inputs=input_text,
+                outputs=output_text
+            )
+
+
+    with gr.Column(visible=False) as thumb_section:
+        with gr.Column(elem_classes="card"):
+            video_for_thumb = gr.Video()
+            title_text = gr.Textbox()
+            thumb_btn = gr.Button("Generate Thumbnail")
+            thumbnail_output = gr.Image()
+
+            thumb_btn.click(
+                create_thumbnail,
+                inputs=[video_for_thumb, title_text],
+                outputs=thumbnail_output
+            )
+
+
+    with gr.Column(visible=False) as subtitle_section:
+        with gr.Column(elem_classes="card"):
+            video_input_sub = gr.Video()
+            subtitle_btn = gr.Button("Generate Subtitles")
+            subtitle_file = gr.File()
+
+            subtitle_btn.click(
+                subtitle_ui,
+                inputs=video_input_sub,
+                outputs=subtitle_file
+            )
+
+
+    with gr.Column(visible=False) as composer_section:
+        with gr.Column(elem_classes="card"):
+            video_inputs = gr.File(file_types=[".mp4"], file_count="multiple")
+            compose_btn = gr.Button("Compose Video")
+            final_video = gr.Video()
+
+            compose_btn.click(
+                compose_ui,
+                inputs=video_inputs,
+                outputs=final_video
+            )
+
+
+    with gr.Column(visible=False) as burn_section:
+        with gr.Column(elem_classes="card"):
+            video_input_burn = gr.Video()
+            subtitle_input = gr.File()
+            burn_btn = gr.Button("Burn Subtitles")
+            output_video = gr.Video()
+
+            burn_btn.click(
+                burn_subtitles_ui,
+                inputs=[video_input_burn, subtitle_input],
+                outputs=output_video
+            )
+
+
+    # ---------- NAVIGATION FUNCTIONS (FIXED) ----------
+
+    def show_upload():
+        return (
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+        )
+
+
+    def show_summary():
+        return (
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+        )
+
+
+    def show_thumb():
+        return (
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+        )
+
+
+    def show_subtitle():
+        return (
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=False),
+        )
+
+
+    def show_composer():
+        return (
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+        )
+
+
+    def show_burn():
+        return (
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=True),
+        )
+
+
+    btn_upload.click(show_upload,
+        outputs=[upload_section, summary_section, thumb_section, subtitle_section, composer_section, burn_section])
+
+    btn_summary.click(show_summary,
+        outputs=[upload_section, summary_section, thumb_section, subtitle_section, composer_section, burn_section])
+
+    btn_thumbnail.click(show_thumb,
+        outputs=[upload_section, summary_section, thumb_section, subtitle_section, composer_section, burn_section])
+
+    btn_subtitle.click(show_subtitle,
+        outputs=[upload_section, summary_section, thumb_section, subtitle_section, composer_section, burn_section])
+
+    btn_composer.click(show_composer,
+        outputs=[upload_section, summary_section, thumb_section, subtitle_section, composer_section, burn_section])
+
+    btn_burn.click(show_burn,
+        outputs=[upload_section, summary_section, thumb_section, subtitle_section, composer_section, burn_section])
+
+
+app.launch()

modules/composer.py

@@ -0,0 +1,58 @@
+from moviepy import VideoFileClip, concatenate_videoclips
+import os
+import shutil
+
+OUTPUT_DIR = "assets/outputs"
+UPLOAD_DIR = "assets/uploads"
+
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+def normalize_video(input_path, output_path):
+    """
+    Re-encode video to constant frame rate and valid keyframe.
+    This fixes WhatsApp/mobile video issues on Windows.
+    """
+    clip = VideoFileClip(input_path)
+    clip.write_videofile(
+        output_path,
+        codec="libx264",
+        audio_codec="aac",
+        fps=24,
+        preset="medium",
+        ffmpeg_params=["-movflags", "+faststart"]
+    )
+    clip.close()
+
+def compose_videos(video_files):
+    clips = []
+    normalized_paths = []
+
+    for file in video_files:
+        filename = os.path.basename(file)
+        stable_path = os.path.join(UPLOAD_DIR, filename)
+        shutil.copy(file, stable_path)
+
+        normalized_path = os.path.join(
+            UPLOAD_DIR, f"normalized_{filename}"
+        )
+
+        normalize_video(stable_path, normalized_path)
+        normalized_paths.append(normalized_path)
+
+    for path in normalized_paths:
+        clips.append(VideoFileClip(path))
+
+    final_clip = concatenate_videoclips(clips)
+    output_path = os.path.join(OUTPUT_DIR, "final_video.mp4")
+
+    final_clip.write_videofile(
+        output_path,
+        codec="libx264",
+        audio_codec="aac"
+    )
+
+    for clip in clips:
+        clip.close()
+
+    return output_path

modules/frame_extractor.py

@@ -0,0 +1,19 @@
+import cv2
+import os
+
+OUTPUT_DIR = "assets/outputs"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def extract_frame(video_path):
+    cap = cv2.VideoCapture(video_path)
+
+    success, frame = cap.read()
+    cap.release()
+
+    if not success:
+        raise ValueError("Could not read frame from video.")
+
+    frame_path = os.path.join(OUTPUT_DIR, "frame.jpg")
+    cv2.imwrite(frame_path, frame)
+
+    return frame_path

modules/subtitle_burner.py

@@ -0,0 +1,40 @@
+from moviepy import VideoFileClip, TextClip, CompositeVideoClip
+import pysrt
+import os
+
+OUTPUT_DIR = "assets/outputs"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def burn_subtitles(video_path, subtitle_path):
+
+    video = VideoFileClip(video_path)
+    subs = pysrt.open(subtitle_path)
+
+    subtitle_clips = []
+
+    for sub in subs:
+
+        start = sub.start.ordinal / 1000
+        end = sub.end.ordinal / 1000
+
+        txt_clip = TextClip(
+            text=sub.text,
+            font_size=40,
+            color="white",
+            stroke_color="black",
+            stroke_width=2,
+            size=(int(video.w * 0.9), None),
+            method="caption"
+        )
+
+        txt_clip = txt_clip.with_start(start).with_end(end).with_position(("center","bottom"))
+
+        subtitle_clips.append(txt_clip)
+
+    final = CompositeVideoClip([video] + subtitle_clips)
+
+    output_path = os.path.join(OUTPUT_DIR, "captioned_video.mp4")
+
+    final.write_videofile(output_path, codec="libx264")
+
+    return output_path

modules/subtitles.py

@@ -0,0 +1,38 @@
+from faster_whisper import WhisperModel
+import os
+
+OUTPUT_DIR = "assets/outputs"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# Force CPU usage
+model = WhisperModel("base", device="cpu", compute_type="int8")
+
+def generate_subtitles(video_path):
+
+    segments, info = model.transcribe(video_path)
+
+    srt_path = os.path.join(OUTPUT_DIR, "subtitles.srt")
+
+    with open(srt_path, "w", encoding="utf-8") as srt:
+
+        for i, segment in enumerate(segments, start=1):
+
+            start = format_time(segment.start)
+            end = format_time(segment.end)
+            text = segment.text.strip()
+
+            srt.write(f"{i}\n")
+            srt.write(f"{start} --> {end}\n")
+            srt.write(f"{text}\n\n")
+
+    return srt_path
+
+
+def format_time(seconds):
+
+    hrs = int(seconds // 3600)
+    mins = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    millis = int((seconds - int(seconds)) * 1000)
+
+    return f"{hrs:02}:{mins:02}:{secs:02},{millis:03}"

modules/summarizer.py

@@ -0,0 +1,12 @@
+from huggingface_hub import InferenceClient
+import os
+
+client = InferenceClient(token=os.getenv("HF_TOKEN"))
+
+
+def summarize_text(text):
+    response = client.summarization(
+    text,
+    model="facebook/bart-large-cnn"
+)
+    return response["summary_text"]

modules/thumbnail.py

@@ -0,0 +1,48 @@
+from PIL import Image, ImageDraw, ImageFont
+import os
+
+OUTPUT_DIR = "assets/outputs"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def generate_thumbnail(image_path, text):
+    if not os.path.exists(image_path):
+        raise FileNotFoundError("Frame image not found.")
+
+    # 1. Load & resize to YouTube thumbnail size
+    img = Image.open(image_path).convert("RGB")
+    img = img.resize((1280, 720))
+
+    draw = ImageDraw.Draw(img)
+
+    # 2. Add dark gradient overlay (bottom)
+    overlay = Image.new("RGBA", img.size, (0, 0, 0, 0))
+    overlay_draw = ImageDraw.Draw(overlay)
+
+    for y in range(400, 720):
+        alpha = int((y - 400) / 320 * 180)
+        overlay_draw.rectangle(
+            [(0, y), (1280, y + 1)],
+            fill=(0, 0, 0, alpha)
+        )
+
+    img = Image.alpha_composite(img.convert("RGBA"), overlay).convert("RGB")
+    draw = ImageDraw.Draw(img)
+
+    # 3. Load font (fallback safe)
+    try:
+        font = ImageFont.truetype("arialbd.ttf", 80)
+    except:
+        font = ImageFont.load_default()
+
+    # 4. Draw bold title text (bottom-left)
+    x, y = 60, 500
+
+    # Text shadow
+    draw.text((x + 4, y + 4), text, font=font, fill="black")
+    draw.text((x, y), text, font=font, fill="white")
+
+    # 5. Save thumbnail
+    output_path = os.path.join(OUTPUT_DIR, "thumbnail.jpg")
+    img.save(output_path, quality=95)
+
+    return output_path