Stable MCP version - no torch, no whisper

app.py

@@ -3,339 +3,99 @@ import json
 import uuid
 import datetime
 from typing import Optional, Dict, Any
-
 import gradio as gr
-import yt_dlp
-from openai import OpenAI
-
-# =====================================
-# CONFIG
-# =====================================
 
-# Zamiast /data (read-only lokalnie) używamy katalogu w repo
-BASE_DIR = os.path.dirname(__file__)
-DATA_DIR = os.path.join(BASE_DIR, "storage", "contracts")
+# -------- STORAGE --------
+DATA_DIR = "storage/contracts"
 os.makedirs(DATA_DIR, exist_ok=True)
 
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-if not OPENAI_API_KEY:
-    raise RuntimeError(
-        "OPENAI_API_KEY nie jest ustawiony.\n"
-        "Lokalnie: export OPENAI_API_KEY='...'\n"
-        "HuggingFace: Settings → Repository secrets → OPENAI_API_KEY"
-    )
-
-client = OpenAI(api_key=OPENAI_API_KEY)
-
-
-# =====================================
-# STORAGE UTILS
-# =====================================
-
-def _contract_path(uid: str) -> str:
-    return os.path.join(DATA_DIR, f"{uid}.json")
-
-
-def save_contract(contract: Dict[str, Any]) -> None:
-    uid = contract["uid"]
-    path = _contract_path(uid)
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(contract, f, ensure_ascii=False, indent=2)
-
-
-def load_contract(uid: str) -> Dict[str, Any]:
-    path = _contract_path(uid)
-    if not os.path.exists(path):
-        raise ValueError(f"Contract with uid={uid} not found.")
-    with open(path, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-
-# =====================================
-# CORE: TRANSCRIBE
-# =====================================
-
-def transcribe_reel(link: str) -> str:
-    """
-    Download a reel/video from a link (e.g. Instagram/YouTube/TikTok)
-    and transcribe audio using OpenAI Whisper (gpt-4o-transcribe).
-
-    Zwraca czysty tekst (string).
-    """
-    # 1) pobranie pliku przez yt-dlp
-    tmp_id = str(uuid.uuid4())
-    out_tmpl = f"/tmp/{tmp_id}.%(ext)s"
-
-    ydl_opts = {
-        "format": "mp4/bestaudio/best",
-        "outtmpl": out_tmpl,
-        "quiet": True,
-    }
-
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-        info = ydl.extract_info(link, download=True)
-        filename = ydl.prepare_filename(info)
-
-    # 2) transkrypcja przez 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
-
-
-# =====================================
-# CORE: EXTRACT HABITS (goal + 7 kroków)
-# =====================================
-
-def extract_habits(transcript: str, category: str = "general") -> Dict[str, Any]:
-    """
-    Z transkryptu robi:
-    - goal (jedno zdanie)
-    - steps: dokładnie 7 krótkich, wykonalnych kroków (lista stringów)
-    """
-    if not transcript or not transcript.strip():
-        # Fallback gdy nie ma transkrypcji / błąd pobierania
-        return {
-            "goal": f"Popraw swoją sferę: {category}, robiąc jeden mały krok dziennie.",
-            "steps": [
-                "Zapisz dziś jeden konkretny cel związany z tym obszarem.",
-                "Zrób 10–15 minut skoncentrowanej pracy nad tym celem.",
-                "Usuń jedną oczywistą przeszkodę lub rozpraszacz.",
-                "Podziel swój cel na 3 mniejsze podcele i wybierz jeden.",
-                "Zrób mikro-wersję działania (np. 1 mail, 1 notatka, 1 telefon).",
-                "Podsumuj na kartce, czego nauczyłeś się z dzisiejszej próby.",
-                "Zaplanuj konkretny krok na jutro (godzina + miejsce).",
-            ],
-        }
-
-    system_msg = (
-        "You are a behavior change coach. "
-        "User gives you a transcript of a short motivational / educational video. "
-        "Your job is to extract ONE clear goal and EXACTLY 7 simple daily actions "
-        "that move the user toward that goal. "
-        "Return STRICT JSON with keys: goal (string), steps (array of 7 short strings). "
-        "Do NOT add any explanation, only JSON."
-    )
-
-    user_msg = (
-        f"Category: {category}\n\n"
-        f"Transcript (may be truncated):\n"
-        f"{transcript[:4000]}"
-    )
-
-    resp = client.chat.completions.create(
-        model="gpt-4.1-mini",
-        messages=[
-            {"role": "system", "content": system_msg},
-            {"role": "user", "content": user_msg},
-        ],
-        temperature=0.2,
-    )
-
-    raw = resp.choices[0].message.content
-    raw = raw.strip()
-    start = raw.find("{")
-    end = raw.rfind("}")
-    if start == -1 or end == -1:
-        # Jeżeli model coś popierdoli z formatem
-        raise ValueError(f"Cannot parse JSON from model output: {raw}")
+# -------- FILE UTILS -----
+def _contract_path(uid:str): return os.path.join(DATA_DIR,f"{uid}.json")
 
-    json_str = raw[start:end + 1]
-    data = json.loads(json_str)
+def save(c:dict):
+    with open(_contract_path(c["uid"]),"w",encoding="utf-8") as f: json.dump(c,f,indent=2,ensure_ascii=False)
 
-    goal = data.get("goal") or f"Improve your {category}."
-    steps = data.get("steps") or []
-    steps = [s for s in steps if isinstance(s, str)]
+def load(uid:str)->dict:
+    p=_contract_path(uid)
+    if not os.path.exists(p): raise ValueError(f"Brak kontraktu: {uid}")
+    return json.load(open(p,"r",encoding="utf-8"))
 
-    # Normalizacja liczby kroków
-    if len(steps) < 7:
-        while len(steps) < 7:
-            steps.append("Powtórz mały krok, który realnie przesuwa Cię w tym obszarze.")
-    else:
-        steps = steps[:7]
-
-    return {"goal": goal, "steps": steps}
-
-
-# =====================================
-# CONTRACT LOGIC
-# =====================================
-
-def create_contract(
-    link: str,
-    category: str = "general",
-    uid: Optional[str] = None,
-    auto_transcribe: bool = True,
-) -> Dict[str, Any]:
-    """
-    Create a habit contract from a video link.
-
-    - (opcjonalnie) transkrybuje video
-    - wyciąga goal + 7 habit steps
-    - zapisuje kontrakt
-    - zwraca podsumowanie (uid, goal, pierwszy krok)
-    """
-    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:
-            # nie zabijamy procesu – lecimy z fallbackiem w extract_habits()
-            print(f"[WARN] Transcription failed for {link}: {e}")
-            transcript = ""
-
-    habits = extract_habits(transcript, category=category)
 
+# -------- BASE CONTRACT GEN --------
+def create_contract(link:str,category:str="general",uid:Optional[str]=None)->dict:
+    uid = uid or f"{category}_{uuid.uuid4().hex[:8]}"
     contract = {
-        "uid": uid,
-        "link": link,
-        "category": category,
-        "goal": habits["goal"],
-        "steps": habits["steps"],
-        "current_index": 0,
-        "history": [],
-        "created_at": datetime.datetime.utcnow().isoformat() + "Z",
-    }
-
-    save_contract(contract)
-
-    return {
-        "uid": uid,
-        "link": link,
-        "category": category,
-        "goal": contract["goal"],
-        "first_step": contract["steps"][0],
-        "total_steps": len(contract["steps"]),
+        "uid":uid,
+        "link":link,
+        "category":category,
+        "steps":[
+            "Obejrzyj materiał i wypisz 1 mikro-wniosek.",
+            "Zastosuj mikro-wniosek w praktyce przez 5 minut.",
+            "Usuń 1 przeszkadzacz który blokuje ten nawyk.",
+            "Powtórz działanie jutro w mniejszej wersji.",
+            "Napisz krótką notatkę z efektów.",
+            "Zrób wersję X1.1 (trochę trudniejszą).",
+            "Pochwal się wynikiem komuś lub zapisz publicznie."
+        ],
+        "current_index":0,
+        "history":[],
+        "created_at":datetime.datetime.utcnow().isoformat()+"Z"
     }
-
-
-def next_step(uid: str) -> Dict[str, Any]:
-    contract = load_contract(uid)
-    idx = contract.get("current_index", 0)
-    steps = contract.get("steps", [])
-
-    if idx >= len(steps):
-        return {
-            "uid": uid,
-            "done": True,
-            "message": "All steps completed.",
-            "goal": contract.get("goal", ""),
-        }
-
+    save(contract)
     return {
-        "uid": uid,
-        "done": False,
-        "goal": contract.get("goal", ""),
-        "step_index": idx,
-        "step": steps[idx],
-        "remaining_steps": len(steps) - idx,
+        "uid":uid,
+        "goal":"Tiny habit based on reel",
+        "first_step":contract["steps"][0],
+        "total_steps":7
     }
 
 
-def mark_done(uid: str) -> Dict[str, Any]:
-    contract = load_contract(uid)
-    idx = contract.get("current_index", 0)
-    steps = contract.get("steps", [])
-
-    now = datetime.datetime.utcnow().isoformat() + "Z"
+def next_step(uid:str)->dict:
+    c=load(uid)
+    i=c["current_index"]
+    if i>=len(c["steps"]): return {"uid":uid,"done":True,"message":"Wszystko wykonane."}
+    return {"uid":uid,"step":c["steps"][i],"remaining":len(c["steps"])-i}
 
-    if idx < len(steps):
-        current_step = steps[idx]
-        contract.setdefault("history", []).append(
-            {"index": idx, "step": current_step, "done_at": now}
-        )
-        contract["current_index"] = idx + 1
-        save_contract(contract)
 
+def mark_done(uid:str)->dict:
+    c=load(uid)
+    i=c["current_index"]
+    if i<len(c["steps"]):
+        c["history"].append({"step":c["steps"][i],"ts":datetime.datetime.utcnow().isoformat()+"Z"})
+        c["current_index"]=i+1
+        save(c)
     return next_step(uid)
 
 
-def report(uid: str) -> Dict[str, Any]:
-    contract = load_contract(uid)
-    steps = contract.get("steps", [])
-    idx = contract.get("current_index", 0)
-    history = contract.get("history", [])
-
-    total = len(steps)
-    done = min(idx, total)
-    remaining = max(total - done, 0)
-    progress = (done / total * 100.0) if total > 0 else 0.0
-
+def report(uid:str)->dict:
+    c=load(uid); total=len(c["steps"]); done=c["current_index"]
     return {
-        "uid": uid,
-        "goal": contract.get("goal", ""),
-        "category": contract.get("category", ""),
-        "total_steps": total,
-        "done_steps": done,
-        "remaining_steps": remaining,
-        "progress_percent": round(progress, 1),
-        "history": history,
-        "current_step": steps[idx] if idx < total else None,
+        "uid":uid,
+        "done":done,
+        "total":total,
+        "progress_pct":round(done/total*100,1)
     }
 
 
-# =====================================
-# GRADIO UI + MCP EXPOSURE
-# =====================================
-
-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 7 kroków i udostępnia jako MCP tools."
-    )
-
-    with gr.Tab("Create Contract"):
-        link_in = gr.Textbox(label="Reel / Video URL")
-        category_in = gr.Textbox(label="Category", value="career")
-        uid_in = gr.Textbox(label="Custom UID (optional)", value="")
-        output_create = gr.JSON(label="Contract summary")
-
-        btn_create = gr.Button("Create Contract")
-        btn_create.click(
-            create_contract,
-            inputs=[link_in, category_in, uid_in],
-            outputs=output_create,
-        )
-
-    with gr.Tab("Next Step"):
-        uid_next_in = gr.Textbox(label="Contract UID")
-        output_next = gr.JSON(label="Next step")
-        btn_next = gr.Button("Get Next Step")
-        btn_next.click(next_step, inputs=[uid_next_in], outputs=output_next)
-
-    with gr.Tab("Mark Done"):
-        uid_done_in = gr.Textbox(label="Contract UID")
-        output_done = gr.JSON(label="After marking done (next step)")
-        btn_done = gr.Button("Mark Current Step as Done")
-        btn_done.click(mark_done, inputs=[uid_done_in], outputs=output_done)
-
+# -------- UI + MCP --------
+with gr.Blocks() as ui:
+    gr.Markdown("# Behavior Changer – MCP")
+    with gr.Tab("Create"):
+        l=gr.Textbox(label="Reel URL")
+        c=gr.Textbox(label="Category",value="career")
+        u=gr.Textbox(label="UID optional")
+        out=gr.JSON(label="Created")
+        gr.Button("Create").click(create_contract,[l,c,u],[out])
+    with gr.Tab("Next"):
+        uid=gr.Textbox(label="UID"); out=gr.JSON(); gr.Button("Next step").click(next_step,[uid],[out])
+    with gr.Tab("Done"):
+        uid=gr.Textbox(label="UID"); out=gr.JSON(); gr.Button("Mark done").click(mark_done,[uid],[out])
     with gr.Tab("Report"):
-        uid_report_in = gr.Textbox(label="Contract UID")
-        output_report = gr.JSON(label="Progress report")
-        btn_report = gr.Button("Get Report")
-        btn_report.click(report, inputs=[uid_report_in], outputs=output_report)
-
-    with gr.Tab("Debug: Transcribe Only"):
-        link_tr_in = gr.Textbox(label="Reel / Video URL")
-        output_tr = gr.Textbox(label="Transcript (preview)")
-        btn_tr = gr.Button("Transcribe")
-        btn_tr.click(transcribe_reel, inputs=[link_tr_in], outputs=output_tr)
+        uid=gr.Textbox(label="UID"); out=gr.JSON(); gr.Button("Report").click(report,[uid],[out])
 
-    # MCP tools – exposed via /gradio_api/mcp
     gr.api(create_contract)
     gr.api(next_step)
     gr.api(mark_done)
     gr.api(report)
-    gr.api(transcribe_reel)
-    gr.api(extract_habits)
 
-demo.launch(mcp_server=True)
+ui.launch(mcp_server=True)

modules/plan_generator.py

@@ -1,29 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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

@@ -1,46 +0,0 @@
-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

@@ -1,92 +0,0 @@
-
-
-# 🔥 ł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

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

requirements.txt

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