Fix: remove diffusion; minimal torch; enable Habit Agent boot

app.py

@@ -8,6 +8,18 @@ import gradio as gr
 import yt_dlp
 from openai import OpenAI
 
+# opcjonalny fallback na lokalny Whisper z reels-agent
+try:
+    from modules import transcriber as local_transcriber  # transcribe_from_url(url)
+except Exception:
+    local_transcriber = None
+
+# opcjonalny summarizer z Nebiusa (reels-agent)
+try:
+    from modules import summarizer as nebius_summarizer  # summarize(text) -> {"insight","action"}
+except Exception:
+    nebius_summarizer = None
+
 # =====================================
 # CONFIG
 # =====================================
@@ -16,6 +28,9 @@ DATA_DIR = "/data/contracts"
 os.makedirs(DATA_DIR, exist_ok=True)
 
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+if not OPENAI_API_KEY:
+    raise RuntimeError("Brak OPENAI_API_KEY w secrets Spaces.")
+
 client = OpenAI(api_key=OPENAI_API_KEY)
 
 
@@ -43,18 +58,13 @@ def load_contract(uid: str) -> Dict[str, Any]:
 
 
 # =====================================
-# CORE TOOLS
+# TRANSKRYPCJA: OpenAI → fallback local Whisper
 # =====================================
 
-def transcribe_reel(link: str) -> str:
+def _download_video_with_ytdlp(link: str) -> str:
     """
-    Download a reel/video from a link (e.g. Instagram) and transcribe audio using OpenAI Whisper.
-    Returns plain text transcript.
+    Pobiera wideo/audio do /tmp i zwraca ścieżkę do pliku.
     """
-    if not OPENAI_API_KEY:
-        raise ValueError("OPENAI_API_KEY not set in environment.")
-
-    # Download audio/video with yt-dlp
     tmp_id = str(uuid.uuid4())
     out_tmpl = f"/tmp/{tmp_id}.%(ext)s"
 
@@ -67,28 +77,53 @@ def transcribe_reel(link: str) -> str:
     with yt_dlp.YoutubeDL(ydl_opts) as ydl:
         info = ydl.extract_info(link, download=True)
         filename = ydl.prepare_filename(info)
+    return filename
 
-    # Transcription via OpenAI
-    with open(filename, "rb") as f:
-        transcript = client.audio.transcriptions.create(
-            model="gpt-4o-transcribe",
-            file=f
-        )
 
-    text = transcript.text if hasattr(transcript, "text") else str(transcript)
-    return text
+def transcribe_reel(link: str) -> str:
+    """
+    1) Próbuje transkrypcji w OpenAI (gpt-4o-transcribe)
+    2) Jeśli to padnie i mamy local_transcriber → używa Whisper lokalnie
+    3) Jeśli wszystko padnie → zwraca 'TRANSCRIPTION_FAILED'
+    """
+    # --- krok 1: OpenAI audio.transcriptions ---
+    try:
+        filename = _download_video_with_ytdlp(link)
+        with open(filename, "rb") as f:
+            transcript = client.audio.transcriptions.create(
+                model="gpt-4o-transcribe",
+                file=f
+            )
+        text = transcript.text if hasattr(transcript, "text") else str(transcript)
+        if text and text.strip():
+            return text.strip()
+    except Exception as e:
+        print(f"[WARN] OpenAI audio transcription failed: {e}")
+
+    # --- krok 2: fallback – lokalny Whisper z reels-agent ---
+    if local_transcriber is not None and hasattr(local_transcriber, "transcribe_from_url"):
+        try:
+            text = local_transcriber.transcribe_from_url(link)  # type: ignore[attr-defined]
+            if text and text.strip():
+                return text.strip()
+        except Exception as e:
+            print(f"[WARN] Local Whisper transcription failed: {e}")
+
+    # --- krok 3: totalna porażka ---
+    return "TRANSCRIPTION_FAILED"
 
 
+# =====================================
+# EXTRACT HABITS (OpenAI – 7 kroków)
+# =====================================
+
 def extract_habits(transcript: str, category: str = "general") -> Dict[str, Any]:
     """
-    Analyze transcript and produce:
+    Analizuje transkrypcję i produkuje:
     - goal (one sentence)
-    - 7 simple actionable steps (list of strings)
+    - steps: 7 prostych kroków (list[str])
     """
-    if not OPENAI_API_KEY:
-        raise ValueError("OPENAI_API_KEY not set in environment.")
-
-    if not transcript or not transcript.strip():
+    if not transcript or transcript == "TRANSCRIPTION_FAILED":
         # Fallback generic plan
         return {
             "goal": f"Improve your {category} through one small action per day.",
@@ -129,7 +164,7 @@ def extract_habits(transcript: str, category: str = "general") -> Dict[str, Any]
 
     raw = resp.choices[0].message.content
 
-    # Try to parse JSON even if model wrapped it in text/code fences
+    # Try to parse JSON even if model wrapped it
     raw = raw.strip()
     start = raw.find("{")
     end = raw.rfind("}")
@@ -139,12 +174,10 @@ def extract_habits(transcript: str, category: str = "general") -> Dict[str, Any]
 
     data = json.loads(json_str)
 
-    # Minimal validation / normalization
     goal = data.get("goal") or f"Improve your {category}."
     steps = data.get("steps") or []
     steps = [s for s in steps if isinstance(s, str)]
     if len(steps) < 7:
-        # pad if needed
         while len(steps) < 7:
             steps.append("Repeat a small action that moves you forward.")
     else:
@@ -153,6 +186,45 @@ def extract_habits(transcript: str, category: str = "general") -> Dict[str, Any]
     return {"goal": goal, "steps": steps}
 
 
+# =====================================
+# NEBIUS SUMMARY (INSIGHT + TODAY ACTION)
+# =====================================
+
+def summarize_with_nebius(transcript: str) -> Dict[str, Optional[str]]:
+    """
+    Używa modules/summarizer.py z reels-agent (Nebius).
+    Zwraca dict: {"insight": str | None, "action": str | None}
+    Jeśli coś padnie → zwraca domyślne fallbacki.
+    """
+    default_insight = "Mały krok dzisiaj zmienia trajektorię tygodnia."
+    default_action = "Obejrzyj materiał i zapisz 1 konkretną rzecz, którą dziś wdrożysz."
+
+    if not transcript or transcript == "TRANSCRIPTION_FAILED":
+        return {"insight": default_insight, "action": default_action}
+
+    if nebius_summarizer is None or not hasattr(nebius_summarizer, "summarize"):
+        return {"insight": default_insight, "action": default_action}
+
+    try:
+        res = nebius_summarizer.summarize(transcript)  # type: ignore[attr-defined]
+        insight = res.get("insight") if isinstance(res, dict) else None
+        action = res.get("action") if isinstance(res, dict) else None
+    except Exception as e:
+        print(f"[WARN] Nebius summarizer failed: {e}")
+        insight, action = None, None
+
+    if not insight or not insight.strip():
+        insight = default_insight
+    if not action or not action.strip():
+        action = default_action
+
+    return {"insight": insight.strip(), "action": action.strip()}
+
+
+# =====================================
+# CONTRACT API (MCP tools)
+# =====================================
+
 def create_contract(
     link: str,
     category: str = "general",
@@ -160,25 +232,28 @@ def create_contract(
     auto_transcribe: bool = True
 ) -> Dict[str, Any]:
     """
-    Create a habit contract from a video link.
+    Tworzy kontrakt nawyku z linku:
 
-    - Downloads + transcribes the video (if auto_transcribe=True)
-    - Extracts goal + 7 habit steps
-    - Saves contract to storage
-    - Returns public contract summary
+    - transkrypcja (OpenAI → Whisper fallback)
+    - Nebius: INSIGHT + TODAY ACTION
+    - OpenAI: goal + 7 kroków
+    - zapis do /data/contracts
+
+    Zwraca skrócone podsumowanie kontraktu.
     """
     if uid is None or not uid.strip():
         uid = f"{category}_{uuid.uuid4().hex[:8]}"
 
     transcript = ""
     if auto_transcribe:
-        try:
-            transcript = transcribe_reel(link)
-        except Exception as e:
-            # Fallback: no transcript, but do not fail hard
-            transcript = ""
-            print(f"[WARN] Transcription failed: {e}")
+        transcript = transcribe_reel(link)
+
+    # Nebius: INSIGHT + AKCJA DNIA
+    nebius_summary = summarize_with_nebius(transcript)
+    insight = nebius_summary["insight"]
+    today_action = nebius_summary["action"]
 
+    # OpenAI: goal + 7 kroków
     habits = extract_habits(transcript, category=category)
 
     contract = {
@@ -190,6 +265,10 @@ def create_contract(
         "current_index": 0,
         "history": [],
         "created_at": datetime.datetime.utcnow().isoformat() + "Z",
+        "insight": insight,
+        "today_action": today_action,
+        # trzymamy tylko preview, żeby nie zabić storage
+        "transcript_preview": None if not transcript else transcript[:2000],
     }
 
     save_contract(contract)
@@ -201,12 +280,14 @@ def create_contract(
         "goal": contract["goal"],
         "first_step": contract["steps"][0],
         "total_steps": len(contract["steps"]),
+        "insight": insight,
+        "today_action": today_action,
     }
 
 
 def next_step(uid: str) -> Dict[str, Any]:
     """
-    Return the next actionable step for given contract.
+    Zwraca kolejny krok dla danego kontraktu.
     """
     contract = load_contract(uid)
     idx = contract.get("current_index", 0)
@@ -218,6 +299,7 @@ def next_step(uid: str) -> Dict[str, Any]:
             "done": True,
             "message": "All steps completed.",
             "goal": contract.get("goal", ""),
+            "insight": contract.get("insight", ""),
         }
 
     return {
@@ -227,12 +309,14 @@ def next_step(uid: str) -> Dict[str, Any]:
         "step_index": idx,
         "step": steps[idx],
         "remaining_steps": len(steps) - idx,
+        "insight": contract.get("insight", ""),
+        "today_action": contract.get("today_action", ""),
     }
 
 
 def mark_done(uid: str) -> Dict[str, Any]:
     """
-    Mark current step as done and advance to next one.
+    Oznacza bieżący krok jako wykonany i przechodzi do kolejnego.
     """
     contract = load_contract(uid)
     idx = contract.get("current_index", 0)
@@ -253,7 +337,7 @@ def mark_done(uid: str) -> Dict[str, Any]:
 
 def report(uid: str) -> Dict[str, Any]:
     """
-    Return a summary of contract progress.
+    Zwraca pełny raport z progresu.
     """
     contract = load_contract(uid)
     steps = contract.get("steps", [])
@@ -275,18 +359,23 @@ def report(uid: str) -> Dict[str, Any]:
         "progress_percent": round(progress, 1),
         "history": history,
         "current_step": steps[idx] if idx < total else None,
+        "insight": contract.get("insight", ""),
+        "today_action": contract.get("today_action", ""),
     }
 
 
 # =====================================
-# GRADIO UI + MCP EXPOSURE
+# GRADIO UI + MCP
 # =====================================
 
 with gr.Blocks() as demo:
     gr.Markdown(
         "# Behavior Changer – Habit Agent (MCP)\n"
-        "Tworzy kontrakty nawyków z linków do Reels / video, "
-        "rozbija na kroki i udostępnia jako MCP tools."
+        "Kontrakty nawyków z linków do Reels / video:\n"
+        "- transkrypcja (OpenAI → Whisper fallback)\n"
+        "- Nebius INSIGHT + mikro-akcja\n"
+        "- 7 kroków z OpenAI\n"
+        "- MCP tools do użycia z Claude/Cursor."
     )
 
     with gr.Tab("Create Contract"):

modules/plan_generator.py

@@ -0,0 +1,29 @@
+# engine/plan_generator.py
+import os
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://api.tokenfactory.nebius.com/v1/",
+    api_key=os.getenv("NEBIUS_API_KEY")
+)
+
+def generate_plan(insight:str, category:str, steps:int=10):
+    prompt = f"""
+Stwórz serię {steps} ultra-małych kroków nawykowych.
+Kroki muszą być tak małe, że wykonanie ich zajmuje <2 minuty.
+
+FORMAT WYJŚCIA (dokładny):
+1. ...
+2. ...
+3. ...
+
+INSIGHT użytkownika: {insight}
+Kategoria: {category}
+"""
+
+    resp = client.chat.completions.create(
+        model="deepseek-ai/DeepSeek-R1-0528",
+        messages=[{"role":"user","content":prompt}]
+    ).choices[0].message.content
+
+    return [x[3:] for x in resp.split("\n") if x[:2].isdigit()]

modules/session.py

@@ -0,0 +1,28 @@
+# engine/session.py
+import json, os, time
+
+PATH="state/"
+
+def load(uid):
+    f = PATH+uid+".json"
+    return json.load(open(f)) if os.path.exists(f) else {
+        "insight":None,
+        "category":None,
+        "plan":[],
+        "done":[],
+        "created":time.time()
+    }
+
+def save(uid,data):
+    os.makedirs(PATH,exist_ok=True)
+    json.dump(data,open(PATH+uid+".json","w"),indent=2)
+
+def next_step(uid):
+    s=load(uid)
+    remaining=[x for x in s["plan"] if x not in s["done"]]
+    return remaining[0] if remaining else None
+
+def mark_done(uid,step):
+    s=load(uid)
+    s["done"].append(step)
+    save(uid,s)

modules/summarizer.py

@@ -0,0 +1,46 @@
+import os
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://api.tokenfactory.nebius.com/v1/",
+    api_key=os.environ["NEBIUS_API_KEY"]
+)
+
+def summarize(text:str) -> dict:
+    prompt = f"""
+Streść najważniejszą myśl i podaj jedną mikro-akcję na dziś dla użytkownika.
+Ultra krótko. Maks 2 zdania. Po polsku.
+
+Format odpowiedzi bez etykiet:
+
+INSIGHT: <jedno zdanie sedna, maks 140 znaków>
+AKCJA: <jedna mikroczynność do wykonania dziś na podsstawie transkrypcji, maks 120 znaków>
+
+Transkrypcja:
+{text}
+"""
+
+    r = client.chat.completions.create(
+        model="moonshotai/Kimi-K2-Instruct",
+        messages=[{"role":"user","content":prompt}],
+        max_tokens=200
+    ).choices[0].message.content.strip()
+
+    # Wyciągamy dwie rzeczy nawet bez idealnego formatu
+    import re
+    insight_match = re.search(r'INSIGHT:(.*)', r, re.IGNORECASE)
+    action_match  = re.search(r'AKCJA:(.*)', r, re.IGNORECASE)
+
+    insight = insight_match.group(1).strip()[:140] if insight_match else None
+    action  = action_match.group(1).strip()[:120] if action_match else None
+
+    # jeśli brak akcji → próbujemy z heurystyk
+    if not action:
+        # wyłuskanie najkrótszego zdania z tekstu
+        parts = [p.strip() for p in r.split("\n") if len(p.strip())<160]
+        action = parts[-1] if len(parts)>1 else "Zrób najmniejszą możliwą wersję działania."
+
+    if not insight:
+        insight = "Mały krok dzisiaj zmieni trajektorię tygodnia."
+
+    return {"insight": insight, "action": action}

modules/transcriber.py

@@ -0,0 +1,92 @@
+
+
+# 🔥 ładowanie modelu tylko raz → x3 szybciej przy wielu SMS
+# model = whisper.load_model("base")
+
+# def download_audio(url, out="temp.mp3"):
+#     cmd = [
+#         "yt-dlp",
+#         "-x", "--audio-format", "mp3",
+#         "--ffmpeg-location", "/usr/bin/ffmpeg",
+#         "-o", out,
+#         url
+#     ]
+#     try:
+#         subprocess.run(cmd, check=True, timeout=30)  # timeout = mniej zwisów
+#         return out
+#     except Exception as e:
+#         print("AUDIO ERROR:", e)
+#         return None
+import os
+import shutil
+import subprocess
+import whisper
+
+TEMP_AUDIO = "temp.mp3"
+_model = whisper.load_model("base")  # cache modelu, żeby nie ładować przy każdym wywołaniu
+
+
+def _get_ffmpeg_path() -> str:
+    """
+    Zwraca ścieżkę do ffmpeg albo rzuca czytelny wyjątek,
+    jeśli ffmpeg nie jest zainstalowany.
+    """
+    path = shutil.which("ffmpeg")
+    if path is None:
+        raise RuntimeError(
+            "ffmpeg nie jest dostępny w PATH.\n"
+            "Na Macu zainstaluj: brew install ffmpeg"
+        )
+    return path
+
+
+def download_audio(url: str, out: str = TEMP_AUDIO) -> str:
+    """
+    Pobiera audio z URL do pliku MP3.
+    Rzuca RuntimeError jeśli yt-dlp padnie.
+    """
+    if os.path.exists(out):
+        os.remove(out)
+
+    ffmpeg_path = _get_ffmpeg_path()
+
+    cmd = [
+        "yt-dlp",
+        "-x",
+        "--audio-format", "mp3",
+        "--ffmpeg-location", ffmpeg_path,
+        "-o", out,
+        url,
+    ]
+
+    try:
+        subprocess.run(cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"yt-dlp nie udało się pobrać audio: {e}") from e
+
+    if not os.path.exists(out):
+        raise RuntimeError("Pobieranie się udało, ale plik audio nie powstał.")
+
+    return out
+
+
+def _get_model():
+    global _model
+    if _model is None:
+        # możesz wrócić do "small", jeśli chcesz szybciej / taniej
+        _model = whisper.load_model("base")
+    return _model
+
+
+def transcribe_from_url(url):
+    audio = download_audio(url)
+    model = _get_model()
+    if not audio:                        # 🔥 nowy soft fallback zamiast crasha
+        return "TRANSCRIPTION_FAILED"
+
+    try:
+        result = model.transcribe(audio)
+        return result.get("text", "")
+    except Exception as e:
+        print("TRANSCRIBE ERROR:", e)
+        return "TRANSCRIPTION_FAILED"

packages

@@ -0,0 +1 @@
+ffmpeg

requirements.txt

@@ -1,4 +1,7 @@
 gradio[mcp]
 yt-dlp
 openai>=1.40.0
-requests
+requests
+openai-whisper
+tiktoken
+torch==2.1.0 --extra-index-url https://download.pytorch.org/whl/cpu