sync: backend da GitHub 2026-05-18T11:59:53Z

.gitignore

@@ -0,0 +1,8 @@
+.venv/
+  __pycache__/
+  *.pyc
+  *.pyo
+  chroma_db/
+  *.egg-info/
+  .env
+  

Dockerfile

@@ -1,14 +1,55 @@
+# ──────────────────────────────────────────────────────────────────────────────
+# Dockerfile — Backend FastAPI per HuggingFace Spaces
+#
+# HuggingFace Spaces:  server sempre attivo, 16GB RAM, gratuito
+# Supabase:            database per memoria, file, conversazioni (esterno)
+#
+# Deploy:
+#   1. Crea uno Space su https://huggingface.co/new-space (SDK: Docker)
+#   2. Connetti il repo GitHub Baida98/AI
+#   3. Aggiungi i secrets Supabase in Settings → Repository secrets:
+#        SUPABASE_URL, SUPABASE_KEY
+#      e i secret LLM opzionali:
+#        OPENROUTER_API_KEY, GROQ_API_KEY, GEMINI_API_KEY, HF_TOKEN
+#   4. HF Spaces costruisce e avvia automaticamente questo Dockerfile
+# ──────────────────────────────────────────────────────────────────────────────
+
 FROM python:3.11-slim
 
-RUN useradd -m -u 1000 user
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
+# Variabili HuggingFace Spaces
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PORT=7860 \
+    FRONTEND_DIST=/app/backend/static
+
 WORKDIR /app
 
-COPY --chown=user requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+# Dipendenze sistema (minimali)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential curl git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Dipendenze Python
+COPY backend/requirements.txt /app/backend/requirements.txt
+RUN pip install --no-cache-dir -r /app/backend/requirements.txt
+
+# Copia il backend
+COPY backend/ /app/backend/
 
-COPY --chown=user . .
+# Copia il frontend buildato (se presente)
+# La build Vite va fatta prima del deploy e committata in backend/static/
+# oppure buildala qui se il repo contiene i sorgenti frontend
+# COPY artifacts/agente-ai/dist/ /app/backend/static/
 
+# Crea user non-root (richiesto da HF Spaces)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user PATH=/home/user/.local/bin:$PATH
+
+WORKDIR /home/user/app
+COPY --chown=user backend/ /home/user/app/backend/
+
+# HuggingFace Spaces usa la porta 7860
 EXPOSE 7860
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -1,11 +1,42 @@
----
-title: Terminal
-emoji: 🐢
-colorFrom: indigo
-colorTo: yellow
-sdk: docker
-pinned: false
-short_description: Terminal AI python
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Agente AI — Backend locale
+
+  Backend Python FastAPI con Ollama + ChromaDB + 4-layer memory.
+
+  ## Setup rapido
+
+  ```bash
+  # 1. Installa Ollama: https://ollama.com
+  ollama serve
+  ollama pull qwen2.5-coder:7b   # consigliato (~4GB)
+
+  # 2. Avvia il backend
+  cd backend && bash start.sh
+  ```
+
+  Poi apri l'app: il frontend rileva automaticamente il backend locale.
+
+  ## Architettura
+
+  Frontend React → Backend :8000 → Ollama :11434
+                            → ChromaDB (vector memory)
+
+  ## 4 Layer di memoria
+
+  | Layer     | Scopo                        | Storage   |
+  |-----------|------------------------------|-----------|
+  | Working   | Ultime 20 chat               | RAM       |
+  | Episodic  | Task completati, errori, fix | SQLite    |
+  | Semantic  | Preferenze, concetti chiave  | ChromaDB  |
+  | Reflection| Pattern errori ricorrenti    | JSON      |
+
+  ## Endpoints
+
+  - GET  /health              — stato Ollama + modelli disponibili
+  - POST /v1/chat/completions — streaming OpenAI-compatible
+  - POST /api/plan            — pianifica task complesso
+  - POST /api/critique        — valida output (critic model)
+  - POST /api/memory/search   — ricerca semantica
+  - GET  /api/memory/stats    — statistiche memoria
+  - POST /api/reflect         — reflection loop
+  - GET  /api/tools           — lista tool
+  

agents/code_agent.py

@@ -0,0 +1,51 @@
+"""code_agent.py — Coding Agent: scan→analyze→plan→edit→validate→reflect"""
+import asyncio, json, re
+from models.ollama_client import OllamaClient
+
+SYSTEM = """Sei un coding agent esperto. Analisi codice, bugfix, refactor.
+Rispondi con JSON strutturato quando richiesto."""
+
+class CodeAgent:
+  def __init__(self, ollama: OllamaClient): self.ollama = ollama
+
+  async def _llm_json(self, prompt:str, system:str=SYSTEM, max_tokens:int=1024)->dict:
+      msgs=[{"role":"system","content":system},{"role":"user","content":prompt}]
+      try:
+          raw=await self.ollama.chat(msgs,temperature=0.2,max_tokens=max_tokens)
+          m=re.search(r'\{[\s\S]+\}',raw)
+          return json.loads(m.group()) if m else {}
+      except: return {}
+
+  async def analyze_file(self, filepath:str, content:str, goal:str)->dict:
+      p=f"Analizza per: {goal}\nFile: {filepath}\nContenuto (prime 3000 char):\n{content[:3000]}\n\nRispondi JSON: {{issues:[], suggestions:[], complexity:'low|medium|high', priority:1-10, safe_to_edit:bool}}"
+      r=await self._llm_json(p)
+      return r or {"issues":[],"suggestions":[],"complexity":"unknown","priority":5,"safe_to_edit":True}
+
+  async def plan_edit(self, filepath:str, content:str, goal:str)->dict:
+      p=f"Pianifica modifiche per: {goal}\nFile: {filepath}\n{content[:2500]}\n\nJSON: {{steps:[{{description,type:'insert|replace|delete',old_code,new_code,risk:'low|medium|high'}}], requires_tests:bool, breaking_change:bool}}"
+      r=await self._llm_json(p,max_tokens=2048)
+      return r or {"steps":[],"requires_tests":False,"breaking_change":False,"_fallback":True}
+
+  async def generate_fix(self, filepath:str, content:str, issue:str)->str:
+      msgs=[{"role":"system","content":SYSTEM},
+            {"role":"user","content":f"Correggi: {issue}\nFile: {filepath}\n{content[:4000]}\n\nRestituisci SOLO il codice corretto."}]
+      return await self.ollama.chat(msgs,temperature=0.15,max_tokens=4096)
+
+  async def validate_edit(self, original:str, edited:str, goal:str)->dict:
+      p=f"Valida modifica per: {goal}\nPRIMA:{original[:1500]}\nDOPO:{edited[:1500]}\nJSON:{{valid:bool,achieves_goal:bool,regressions:[],confidence:0-1}}"
+      r=await self._llm_json(p,max_tokens=512)
+      return r or {"valid":True,"achieves_goal":True,"regressions":[],"confidence":0.7,"_fallback":True}
+
+  async def full_session(self, goal:str, files:list[dict])->dict:
+      session={"goal":goal,"analyzed":[],"edits":[]}
+      for f in files[:4]:
+          analysis=await self.analyze_file(f["path"],f["content"],goal)
+          if (analysis.get("priority") or 0)>3:
+              plan=await self.plan_edit(f["path"],f["content"],goal)
+              session["analyzed"].append({"path":f["path"],"analysis":analysis,"plan":plan})
+              if plan.get("steps"):
+                  edited=await self.generate_fix(f["path"],f["content"],goal)
+                  val=await self.validate_edit(f["content"],edited,goal)
+                  session["edits"].append({"path":f["path"],"edited":edited,"validation":val})
+      session["summary"]=f"Analizzati {len(session['analyzed'])} file, {len(session['edits'])} modifiche."
+      return session

agents/critic.py

@@ -0,0 +1,55 @@
+"""
+critic.py — Critic Model
+Secondo passaggio: verifica output, trova errori, suggerisce miglioramenti.
+"""
+import json, re
+from models.ollama_client import OllamaClient
+
+CRITIC_SYSTEM = """Sei un critico AI. Valuta l'output dato e rispondi SOLO con JSON:
+{
+  "quality": 0-10,
+  "issues": ["lista problemi trovati"],
+  "suggestions": ["lista miglioramenti"],
+  "is_complete": true/false,
+  "needs_retry": true/false,
+  "confidence": 0.0-1.0
+}"""
+
+class Critic:
+    def __init__(self, ollama: OllamaClient):
+        self.ollama = ollama
+
+    async def evaluate(self, task: str, output: str, model: str | None = None) -> dict:
+        messages = [
+            {"role": "system", "content": CRITIC_SYSTEM},
+            {"role": "user", "content": f"Task originale: {task}\n\nOutput da valutare:\n{output[:2000]}"},
+        ]
+        try:
+            raw = await self.ollama.chat(messages, model=model, temperature=0.2, max_tokens=512)
+            json_match = re.search(r'\{[\s\S]+\}', raw)
+            if json_match:
+                result = json.loads(json_match.group())
+                result["_evaluated"] = True
+                return result
+        except Exception:
+            pass
+
+        # Fallback euristico
+        quality = 5
+        issues = []
+        if len(output) < 50:
+            quality -= 3; issues.append("Output troppo breve")
+        if "errore" in output.lower() or "error" in output.lower():
+            quality -= 2; issues.append("Potenziali errori nell'output")
+        if len(output) > 100:
+            quality += 2
+
+        return {
+            "quality": max(0, min(10, quality)),
+            "issues": issues,
+            "suggestions": ["Verifica la completezza della risposta"],
+            "is_complete": len(output) > 100,
+            "needs_retry": quality < 4,
+            "confidence": 0.5,
+            "_fallback": True,
+        }

agents/executor.py

@@ -0,0 +1,47 @@
+"""
+executor.py — Tool Executor con retry e timeout.
+"""
+import asyncio
+from models.ollama_client import OllamaClient
+from memory.manager import MemoryManager
+from tools.registry import TOOL_REGISTRY
+
+class Executor:
+    def __init__(self, ollama: OllamaClient, memory: MemoryManager, max_retries: int = 2):
+        self.ollama = ollama
+        self.memory = memory
+        self.max_retries = max_retries
+
+    async def run_tool(self, tool_name: str, inputs: dict, timeout: float = 30.0) -> dict:
+        tool = TOOL_REGISTRY.get(tool_name)
+        if not tool:
+            return {"success": False, "error": f"Tool '{tool_name}' non trovato", "output": None}
+
+        # Validate required inputs
+        missing = [r for r in tool.get("required_inputs", []) if r not in inputs]
+        if missing:
+            return {"success": False, "error": f"Input mancanti: {missing}", "output": None}
+
+        for attempt in range(self.max_retries + 1):
+            try:
+                fn = tool.get("_fn")
+                if fn is None:
+                    return {"success": False, "error": "Tool non ha funzione di esecuzione", "output": None}
+                result = await asyncio.wait_for(fn(**inputs), timeout=timeout)
+                await self.memory.save_episode("tool", f"{tool_name}: {str(inputs)[:100]}", str(result)[:500], True)
+                return {"success": True, "tool": tool_name, "output": result, "attempt": attempt + 1}
+            except asyncio.TimeoutError:
+                if attempt == self.max_retries:
+                    err = f"Timeout dopo {timeout}s"
+                    await self.memory.save_episode("tool", f"{tool_name}: {str(inputs)[:100]}", err, False)
+                    await self.memory.reflect(f"{tool_name} timeout", err, False, err)
+                    return {"success": False, "error": err, "output": None}
+                await asyncio.sleep(1.0 * (attempt + 1))
+            except Exception as e:
+                if attempt == self.max_retries:
+                    err = str(e)
+                    await self.memory.save_episode("tool", f"{tool_name}", err, False)
+                    return {"success": False, "error": err, "output": None}
+                await asyncio.sleep(0.5)
+
+        return {"success": False, "error": "Max retries raggiunti", "output": None}

agents/planner.py

@@ -0,0 +1,57 @@
+"""
+planner.py — Task Planner
+Decompone obiettivi complessi in subtask con tool selection.
+"""
+import json, re
+from models.ollama_client import OllamaClient
+
+PLANNER_SYSTEM = """Sei un planner AI. Dato un obiettivo, decomponilo in subtask concreti.
+
+Rispondi SOLO con JSON valido nel formato:
+{
+  "goal": "obiettivo originale",
+  "complexity": "low|medium|high",
+  "subtasks": [
+    {
+      "id": 1,
+      "description": "cosa fare",
+      "tool": "web_search|code|read_page|memory|direct_response",
+      "requires": [],
+      "risk": "low|medium|high"
+    }
+  ],
+  "estimated_steps": 3
+}"""
+
+class Planner:
+    def __init__(self, ollama: OllamaClient):
+        self.ollama = ollama
+
+    async def create_plan(self, goal: str, context: list | None = None, model: str | None = None) -> dict:
+        messages = [
+            {"role": "system", "content": PLANNER_SYSTEM},
+            {"role": "user", "content": f"Obiettivo: {goal}"}
+        ]
+        if context:
+            ctx_str = "\n".join(m.get("content", "")[:100] for m in context[-3:])
+            messages[1]["content"] += f"\n\nContesto recente:\n{ctx_str}"
+
+        try:
+            raw = await self.ollama.chat(messages, model=model, temperature=0.3, max_tokens=1024)
+            # Extract JSON from response
+            json_match = re.search(r'\{[\s\S]+\}', raw)
+            if json_match:
+                plan = json.loads(json_match.group())
+                plan["_raw"] = raw[:200]
+                return plan
+        except Exception as e:
+            pass
+
+        # Fallback: simple plan
+        return {
+            "goal": goal,
+            "complexity": "medium",
+            "subtasks": [{"id": 1, "description": goal, "tool": "direct_response", "requires": [], "risk": "low"}],
+            "estimated_steps": 1,
+            "_fallback": True,
+        }

agents/reasoning_core.py

@@ -0,0 +1,219 @@
+"""
+reasoning_core.py — MobileMaxAgent Implementation
+Cervello di livello massimo: Project Understanding + Strategy Engine + Auto-Debug Loop.
+"""
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+import json, re
+
+
+@dataclass
+class ReasoningResult:
+    action: str          # "plan" | "fix" | "continue" | "stop" | "analyze" | "strategy"
+    steps: List[str]
+    patch: Optional[str] = None
+    reason: str = ""
+    confidence: float = 0.5
+
+
+@dataclass
+class ReasoningState:
+    goal: str
+    context: str = ""
+    last_result: str = ""
+    errors: List[str] = field(default_factory=list)
+    completed_steps: List[str] = field(default_factory=list)
+    loop_count: int = 0
+    world_model: Optional[str] = None
+    strategy: Optional[str] = None
+
+
+class ReasoningCore:
+    """
+    MobileMaxAgent — Evoluzione del ReasoningCore.
+    Gestisce l'intero ciclo di vita del progetto:
+    1. Analyze (Project Understanding)
+    2. Strategy (Global Decision Making)
+    3. Patch (Multi-file implementation)
+    4. Run & Debug (Auto-repair loop)
+    """
+    MAX_LOOPS      = 15
+    MIN_CONFIDENCE = 0.4
+
+    def __init__(self, ollama_client, planner=None, critic=None, executor=None):
+        self.llm      = ollama_client
+        self.planner  = planner
+        self.critic   = critic
+        self.executor = executor
+
+    # ── 1. Project Understanding ────────────────────────────────────────────────
+    async def analyze_project(self, repo_context: str) -> str:
+        prompt = f"""Analyze full software system.
+Return:
+- architecture map
+- dependencies
+- risk zones
+- entry points
+CONTEXT:
+{repo_context}
+"""
+        return await self.llm.chat([{"role": "user", "content": prompt}], temperature=0.2)
+
+    # ── 2. Global Strategy (Devin Core) ─────────────────────────────────────────
+    async def develop_strategy(self, state: ReasoningState) -> str:
+        prompt = f"""You are an autonomous software engineer.
+WORLD MODEL:
+{state.world_model}
+STATE:
+- goal: {state.goal}
+- errors: {state.errors}
+- completed: {state.completed_steps}
+Decide:
+- what to change
+- why
+- impact
+- risk level
+"""
+        return await self.llm.chat([{"role": "user", "content": prompt}], temperature=0.3)
+
+    # ── 3. Error Intelligence ───────────────────────────────────────────────────
+    async def analyze_error(self, error: str) -> str:
+        prompt = f"""Map error to codebase.
+ERROR:
+{error}
+Return:
+- file
+- root cause
+- fix strategy
+"""
+        return await self.llm.chat([{"role": "user", "content": prompt}], temperature=0.1)
+
+    # ── Prompt builder ──────────────────────────────────────────────────────────
+    def _build_prompt(self, state: ReasoningState) -> str:
+        errors_str = "\n".join(state.errors[-3:]) if state.errors else "nessuno"
+        steps_str  = "\n".join(f"- {s}" for s in state.completed_steps[-5:]) if state.completed_steps else "nessuno"
+        
+        return f"""Sei MobileMaxAgent, un sistema di ingegneria software autonoma.
+Analizza lo stato e decidi l'azione successiva.
+
+STATO:
+- goal: {state.goal}
+- world_model: {'Presente' if state.world_model else 'Mancante'}
+- strategy: {'Definita' if state.strategy else 'Da definire'}
+- last_result: {state.last_result[:300] if state.last_result else 'vuoto'}
+- errors: {errors_str}
+- loop_count: {state.loop_count}/{self.MAX_LOOPS}
+
+Rispondi SOLO con JSON valido:
+{{
+  "action": "analyze | strategy | plan | fix | continue | stop",
+  "steps": ["prossimo passo tecnico"],
+  "patch": "eventuale diff o codice",
+  "reason": "perché questa azione?",
+  "confidence": 0.0-1.0
+}}
+
+Regole:
+1. Se manca world_model -> "analyze"
+2. Se manca strategy -> "strategy"
+3. Se strategy c'è ma serve piano -> "plan"
+4. Se ci sono errori -> "fix"
+5. Se tutto ok -> "continue" o "stop" se finito.
+"""
+
+    def _parse(self, raw: str) -> ReasoningResult:
+        try:
+            m = re.search(r'\{[\s\S]+\}', raw)
+            data = json.loads(m.group()) if m else {}
+        except Exception:
+            return ReasoningResult(action="continue", steps=[], reason="Parsing error fallback", confidence=0.2)
+
+        return ReasoningResult(
+            action=data.get("action", "continue"),
+            steps=data.get("steps", []),
+            patch=data.get("patch"),
+            reason=data.get("reason", ""),
+            confidence=float(data.get("confidence", 0.5))
+        )
+
+    async def decide(self, state: ReasoningState) -> ReasoningResult:
+        if state.loop_count >= self.MAX_LOOPS:
+            return ReasoningResult(action="stop", steps=[], reason="Max loops reached", confidence=1.0)
+
+        prompt = self._build_prompt(state)
+        try:
+            raw = await self.llm.chat([{"role": "user", "content": prompt}], temperature=0.2)
+            return self._parse(raw)
+        except Exception as e:
+            return ReasoningResult(action="continue", steps=[], reason=f"LLM error: {e}", confidence=0.3)
+
+    async def run_loop(self, goal: str, context: str = "", on_step=None) -> Dict[str, Any]:
+        state = ReasoningState(goal=goal, context=context)
+        results = []
+
+        while state.loop_count < self.MAX_LOOPS:
+            decision = await self.decide(state)
+            
+            if on_step:
+                await on_step({
+                    "loop": state.loop_count,
+                    "action": decision.action,
+                    "reason": decision.reason,
+                    "confidence": decision.confidence
+                })
+
+            if decision.action == "stop":
+                break
+            
+            elif decision.action == "analyze":
+                state.world_model = await self.analyze_project(context or goal)
+                results.append({"action": "analyze", "output": "World model built"})
+            
+            elif decision.action == "strategy":
+                state.strategy = await self.develop_strategy(state)
+                results.append({"action": "strategy", "output": state.strategy})
+
+            elif decision.action == "plan" and self.planner:
+                plan = await self.planner.create_plan(goal, context=state.strategy)
+                state.completed_steps.append("Piano creato")
+                state.last_result = "Piano generato"
+                results.append({"action": "plan", "result": plan})
+
+            elif decision.action == "fix":
+                if decision.patch:
+                    # Se c'è una patch, l'executor la applica
+                    if self.executor:
+                        res = await self.executor.run_tool("file_editor", {"path": "patch.diff", "content": decision.patch})
+                        state.last_result = str(res.get("output", ""))
+                    state.errors = []
+                    results.append({"action": "fix", "patch": "Applicata"})
+                else:
+                    error_analysis = await self.analyze_error(str(state.errors))
+                    state.last_result = error_analysis
+                    results.append({"action": "error_analysis", "output": error_analysis})
+
+            elif decision.action == "continue":
+                if self.executor and decision.steps:
+                    res = await self.executor.run_tool("direct_response", {"input": decision.steps[0]})
+                    state.last_result = str(res.get("output", ""))
+                    state.completed_steps.append(decision.steps[0])
+                results.append({"action": "continue", "steps": decision.steps})
+
+            # Auto-debug check con Critic
+            if self.critic and state.last_result and decision.action != "analyze":
+                critique = await self.critic.evaluate(goal, state.last_result)
+                if critique.get("needs_retry"):
+                    state.errors.extend(critique.get("issues", []))
+
+            state.loop_count += 1
+
+        return {
+            "goal": goal,
+            "loops": state.loop_count,
+            "success": len(state.errors) == 0,
+            "results": results,
+            "final_state": {
+                "has_world_model": state.world_model is not None,
+                "has_strategy": state.strategy is not None
+            }
+        }

agents/unified_loop.py

@@ -0,0 +1,136 @@
+"""
+unified_loop.py — Unified Agent Loop
+
+Loop agente unico per backend cloud/HF Spaces. Usa smolagents quando installato e
+configurato; in caso contrario mantiene un fallback deterministico su Planner,
+ReasoningCore, Executor e Critic già presenti nel backend.
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable
+
+
+StepCallback = Callable[[dict[str, Any]], Awaitable[None] | None]
+
+
+@dataclass
+class UnifiedLoopState:
+    goal: str
+    context: str = ""
+    max_steps: int = 8
+    steps: list[dict[str, Any]] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+
+
+class UnifiedAgentLoop:
+    """Smolagents-first loop with safe fallback for environments without it."""
+
+    def __init__(self, llm_client: Any, planner: Any = None, executor: Any = None, critic: Any = None, memory: Any = None):
+        self.llm = llm_client
+        self.planner = planner
+        self.executor = executor
+        self.critic = critic
+        self.memory = memory
+        self._smol_agent = None
+
+    def _build_prompt(self, state: UnifiedLoopState) -> str:
+        memory_hint = ""
+        if self.memory:
+            memory_hint = "\nUsa la memoria disponibile per evitare ripetizioni e preservare preferenze utente."
+        return f"""Sei un agente operativo unificato.
+Obiettivo: {state.goal}
+Contesto: {state.context or 'nessuno'}
+{memory_hint}
+
+Produci una risposta o un piano operativo conciso. Se servono tool, indica passi verificabili.
+"""
+
+    def _load_smol_agent(self) -> Any | None:
+        if self._smol_agent is not None:
+            return self._smol_agent
+        try:
+            from smolagents import CodeAgent, LiteLLMModel  # type: ignore
+
+            model_id = os.getenv("SMOLAGENTS_MODEL") or os.getenv("LLM_MODEL") or "gpt-4o-mini"
+            api_key = os.getenv("OPENAI_API_KEY") or os.getenv("GROQ_API_KEY") or os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_API_KEY")
+            if not api_key:
+                return None
+            model = LiteLLMModel(model_id=model_id, api_key=api_key)
+            self._smol_agent = CodeAgent(tools=[], model=model, max_steps=int(os.getenv("UNIFIED_LOOP_MAX_STEPS", "8")))
+            return self._smol_agent
+        except Exception:
+            return None
+
+    async def _run_smolagents(self, state: UnifiedLoopState, on_step: StepCallback | None) -> dict[str, Any] | None:
+        agent = self._load_smol_agent()
+        if agent is None:
+            return None
+
+        prompt = self._build_prompt(state)
+        if on_step:
+            await _maybe_await(on_step({"loop": 0, "action": "smolagents", "status": "started"}))
+        try:
+            result = await asyncio.to_thread(agent.run, prompt)
+            output = str(result)
+            state.steps.append({"action": "smolagents", "output": output})
+            if self.memory:
+                await self.memory.save_episode("unified_loop", state.goal, output[:1000], True, tags=["smolagents"])
+            if on_step:
+                await _maybe_await(on_step({"loop": 1, "action": "smolagents", "status": "done"}))
+            return {"success": True, "engine": "smolagents", "goal": state.goal, "steps": state.steps, "output": output}
+        except Exception as exc:
+            state.errors.append(str(exc))
+            if on_step:
+                await _maybe_await(on_step({"loop": 1, "action": "smolagents", "status": "error", "error": str(exc)}))
+            return None
+
+    async def _run_fallback(self, state: UnifiedLoopState, on_step: StepCallback | None) -> dict[str, Any]:
+        outputs: list[str] = []
+
+        if self.memory:
+            memory_ctx = await self.memory.get_context(state.goal)
+            if memory_ctx:
+                state.context = f"{state.context}\n\nMEMORIA:\n{memory_ctx}".strip()
+
+        if self.planner:
+            if on_step:
+                await _maybe_await(on_step({"loop": 0, "action": "plan", "status": "started"}))
+            plan = await self.planner.create_plan(state.goal, context=[{"role": "system", "content": state.context}])
+            state.steps.append({"action": "plan", "result": plan})
+            outputs.append(str(plan))
+
+        prompt = self._build_prompt(state)
+        if on_step:
+            await _maybe_await(on_step({"loop": 1, "action": "llm", "status": "started"}))
+        answer = await self.llm.chat([{"role": "user", "content": prompt}], temperature=0.2, max_tokens=2048)
+        state.steps.append({"action": "llm", "output": answer})
+        outputs.append(answer)
+
+        if self.critic:
+            critique = await self.critic.evaluate(state.goal, answer)
+            state.steps.append({"action": "critic", "result": critique})
+            if critique.get("needs_retry"):
+                state.errors.extend([str(x) for x in critique.get("issues", [])])
+
+        success = len(state.errors) == 0
+        final_output = "\n\n".join(outputs).strip()
+        if self.memory:
+            await self.memory.save_episode("unified_loop", state.goal, final_output[:1000], success, tags=["fallback"])
+        if on_step:
+            await _maybe_await(on_step({"loop": 2, "action": "fallback", "status": "done", "success": success}))
+        return {"success": success, "engine": "fallback", "goal": state.goal, "steps": state.steps, "errors": state.errors, "output": final_output}
+
+    async def run(self, goal: str, context: str = "", max_steps: int = 8, on_step: StepCallback | None = None) -> dict[str, Any]:
+        state = UnifiedLoopState(goal=goal, context=context, max_steps=max_steps)
+        smol_result = await self._run_smolagents(state, on_step)
+        if smol_result:
+            return smol_result
+        return await self._run_fallback(state, on_step)
+
+
+async def _maybe_await(value: Any) -> None:
+    if hasattr(value, "__await__"):
+        await value

api/coding.py

@@ -0,0 +1,23 @@
+"""api/coding.py — Coding agent endpoints"""
+from fastapi import APIRouter
+from pydantic import BaseModel
+from typing import Optional,List
+from agents.code_agent import CodeAgent
+
+router=APIRouter(prefix="/code",tags=["coding"])
+_agent=None
+def get_agent()->CodeAgent:
+  global _agent
+  if _agent is None: from main import ollama; _agent=CodeAgent(ollama)
+  return _agent
+
+class AnalyzeReq(BaseModel): filepath:str; content:str; goal:str
+class SessionReq(BaseModel): goal:str; files:List[dict]; model:Optional[str]=None
+
+@router.post("/analyze")
+async def analyze(req:AnalyzeReq):
+  return await get_agent().analyze_file(req.filepath,req.content,req.goal)
+
+@router.post("/session")
+async def session(req:SessionReq):
+  return await get_agent().full_session(req.goal,req.files)

api/web.py

@@ -0,0 +1,31 @@
+"""api/web.py — Web search + fetch endpoints"""
+from fastapi import APIRouter
+from pydantic import BaseModel
+from typing import Optional
+from tools.web_search import web_search
+from tools.web_fetch import fetch_page
+from tools.ranking import rank_results, format_for_llm
+from tools.content_cleaner import clean_and_structure
+
+router=APIRouter(prefix="/web",tags=["web"])
+
+class SearchReq(BaseModel):
+  query:str; focus:Optional[str]="general"; max_results:Optional[int]=6; format:Optional[str]="json"
+
+class FetchReq(BaseModel):
+  url:str; query:Optional[str]=None; max_chars:Optional[int]=5000
+
+@router.post("/search")
+async def search(req:SearchReq):
+  raw=await web_search(req.query,req.focus or "general",req.max_results or 6)
+  ranked=rank_results(raw.get("results",[]),req.query,top_k=req.max_results or 6)
+  if req.format=="text": return {"text":format_for_llm(ranked,req.query),"query":req.query}
+  return {**raw,"results":ranked}
+
+@router.post("/fetch")
+async def fetch(req:FetchReq):
+  raw=await fetch_page(req.url,max_chars=req.max_chars or 5000)
+  if req.query and raw.get("content"):
+      cleaned=clean_and_structure(raw["content"],req.query)
+      raw["content"]=cleaned["content"]; raw["words"]=cleaned["words"]
+  return raw

architecture.py

@@ -0,0 +1,105 @@
+"""
+architecture.py — Free distributed no-PC architecture profile
+
+The selected zero-cost architecture is deliberately split into control,
+execution, tools and memory layers:
+
+- iPhone/mobile browser: control surface only.
+- GitHub Actions: event-triggered Agent Kernel and lightweight execution.
+- Hugging Face Spaces: backend tools/API runtime, not a heavy persistent VM.
+- LiteLLM/OpenAI-compatible provider routing: free remote model pool.
+- GitHub repository: primary memory, code, task history and run reports.
+
+This keeps the system usable without Replit, without a local PC and without
+paid infrastructure while making the real limits explicit.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, asdict
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Capability:
+    name: str
+    status: str
+    reason: str
+
+
+FREE_REMOTE_PLAN = {
+    "name": "github_actions_hf_spaces_free_agent",
+    "label": "GitHub Actions + HF Spaces Free Agent Kernel",
+    "mode": "total_free_no_local_pc",
+    "control_surface": "iPhone via GitHub Actions workflow_dispatch or web frontend",
+    "primary_runtime": "GitHub Actions for agent runs; Hugging Face Spaces for backend tools/API",
+    "tool_runtime": "Hugging Face Spaces Docker free tier",
+    "memory_primary": "GitHub repository under .agent/ plus code/history",
+    "memory_secondary": "SQLite/local backend memory when the Space is available",
+    "principle": "Distributed backend-first agent kernel with safe-by-default GitHub memory, provider fallback and mobile review.",
+    "model_priority": ["openrouter", "gemini", "groq", "huggingface", "openai_compatible"],
+    "execution": "GitHub Actions for bounded jobs; backend allowlisted tools only; browser sandbox disabled by default",
+}
+
+
+def _env_enabled(name: str, default: bool = False) -> bool:
+    raw = os.getenv(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def get_architecture_profile() -> dict[str, Any]:
+    """Return runtime capabilities for the free no-PC deployment plan."""
+    providers = {
+        "openrouter": bool(os.getenv("OPENROUTER_API_KEY")),
+        "gemini": bool(os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")),
+        "groq": bool(os.getenv("GROQ_API_KEY")),
+        "huggingface": bool(os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_API_KEY") or os.getenv("HUGGINGFACE_TOKEN")),
+        "openai_compatible": bool(os.getenv("OPENAI_API_KEY")),
+    }
+
+    github_actions_configured = bool(os.getenv("GITHUB_ACTIONS") or os.getenv("GITHUB_REPOSITORY"))
+    github_token_configured = bool(os.getenv("GITHUB_TOKEN") or os.getenv("GH_TOKEN"))
+
+    capabilities = [
+        Capability("mobile_control", "enabled", "GitHub Actions workflow_dispatch and the frontend can be used from iPhone."),
+        Capability("github_actions_agent_kernel", "enabled", "Bounded agent runs execute in GitHub Actions and persist reports under .agent/."),
+        Capability("github_memory", "enabled", "State, task history and run reports are committed to the repository for durable zero-cost memory."),
+        Capability("hf_spaces_tools", "enabled", "The FastAPI backend remains the lightweight tools/API runtime for the free Space."),
+        Capability("litellm_routing", "enabled", "OpenAI-compatible provider order supports OpenRouter, Gemini, Groq, Hugging Face and optional OpenAI-compatible endpoints."),
+        Capability("sqlite_memory", "secondary", "Backend SQLite/local memory remains useful but is not the primary no-PC source of truth."),
+        Capability("qdrant", "optional", "Use only if an external free Qdrant endpoint is configured; not required for the baseline."),
+        Capability("openhands", "external_optional", "Full OpenHands remains too heavy for the free baseline and should not run inside the free Space."),
+        Capability("docker_sandbox", "disabled_on_free_space", "Nested Docker is intentionally disabled on the free plan."),
+        Capability("browser_sandbox", "disabled_by_default", "Client-side code execution is not a real isolated workspace and is not part of the main path."),
+    ]
+
+    return {
+        "plan": FREE_REMOTE_PLAN,
+        "providers": providers,
+        "capabilities": [asdict(c) for c in capabilities],
+        "limits": {
+            "requires_local_pc": False,
+            "requires_paid_vm": False,
+            "runs_heavy_local_models": False,
+            "supports_nested_docker": False,
+            "long_running_24_7_agent": False,
+            "bounded_actions_runtime": True,
+        },
+        "github_actions": {
+            "workflow": ".github/workflows/agent-kernel.yml",
+            "workflow_template": "docs/workflows/agent-kernel.yml",
+            "activation_note": "Copy the template to .github/workflows/agent-kernel.yml with GitHub UI or a token that has workflow permission.",
+            "script": "scripts/agent_kernel.py",
+            "memory_dir": ".agent/",
+            "configured_in_current_runtime": github_actions_configured,
+            "token_available_in_current_runtime": github_token_configured,
+            "trigger_modes": ["workflow_dispatch", "issue_label_agent-run"],
+        },
+        "feature_flags": {
+            "browser_sandbox_enabled": _env_enabled("VITE_ENABLE_BROWSER_SANDBOX", False),
+            "browser_llm_enabled": _env_enabled("VITE_ENABLE_BROWSER_LLM", False),
+            "qdrant_enabled": bool(os.getenv("QDRANT_URL")),
+        },
+    }

components.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "https://ui.shadcn.com/schema.json",
+    "style": "new-york",
+    "rsc": false,
+    "tsx": true,
+    "tailwind": {
+      "config": "",
+      "css": "src/index.css",
+      "baseColor": "neutral",
+      "cssVariables": true,
+      "prefix": ""
+    },
+    "aliases": {
+      "components": "@/components",
+      "utils": "@/lib/utils",
+      "ui": "@/components/ui",
+      "lib": "@/lib",
+      "hooks": "@/hooks"
+    }
+}

index.html

@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html lang="it">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1" />
+    <title>Agente AI Pro</title>
+      <meta name="description" content="Agente AI — assistente intelligente con strumenti autonomi: ricerca web, meteo, notizie, codice, memoria e molto altro." />
+      <meta name="theme-color" content="#0f0f1a" />
+      <meta property="og:title" content="Agente AI Pro" />
+      <meta property="og:description" content="Assistente AI autonomo con 14 strumenti integrati" />
+      <meta property="og:type" content="website" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+      <meta name="description" content="Agente AI — assistente autonomo con web search, memoria, esecuzione codice e più provider AI." />
+      <meta name="theme-color" content="#0f0f1a" />
+      <meta property="og:title" content="Agente AI" />
+      <meta property="og:description" content="AI agent autonomo con web search, memoria e multi-AI Pro Mode." />
+      <meta property="og:type" content="website" />
+      <meta name="twitter:card" content="summary" />
+      <meta name="twitter:title" content="Agente AI" />
+      <meta name="apple-mobile-web-app-capable" content="yes" />
+      <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+
+    <!--
+      Register the COI Service Worker so that SharedArrayBuffer is available
+      on GitHub Pages (which doesn't allow custom COOP/COEP headers).
+      Required for WebLLM / WebGPU to work in-browser.
+    -->
+    <script>
+      if ("serviceWorker" in navigator) {
+        // Handle both root domain and subfolder (GitHub Pages)
+        const isGH = window.location.hostname.includes("github.io");
+        const pathParts = window.location.pathname.split("/").filter(Boolean);
+        const base = (isGH && pathParts.length > 0) ? "/" + pathParts[0] : "";
+        
+        
+        navigator.serviceWorker
+          .register(swPath)
+          .then(function (reg) {
+            // If the page is not yet cross-origin-isolated, reload once
+            // so the service worker can add the necessary headers.
+            if (!window.crossOriginIsolated) {
+                if (sessionStorage.getItem("__coi_reloaded__") === "1") {
+                  console.warn("[COI] Already reloaded once; giving up to avoid loop. WebLLM disabled.");
+                } else {
+                  sessionStorage.setItem("__coi_reloaded__", "1");
+                  console.log("[COI] Reloading for cross-origin isolation…");
+                  window.location.reload();
+                }
+              } else {
+                sessionStorage.removeItem("__coi_reloaded__");
+                console.log("[COI] crossOriginIsolated =", window.crossOriginIsolated);
+              }
+          })
+          .catch(function (err) {
+            console.warn("[COI] Service worker registration failed:", err);
+          });
+      }
+    </script>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

main.py

@@ -1,20 +1,490 @@
-from fastapi import FastAPI
+import os, sys, json, asyncio, subprocess, tempfile, shlex, time, uuid
+from typing import Optional, Any
+from fastapi import FastAPI, HTTPException, Body
+from fastapi.staticfiles import StaticFiles
 from fastapi.middleware.cors import CORSMiddleware
-import os
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
 
-app = FastAPI(title="Baida AI Backend", version="1.0.0")
+print('BOOT: importing FastAPI...', flush=True)
 
+app = FastAPI(title='Agente AI', version='3.1.0')
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
+    allow_origins=['*'],
+    allow_methods=['*'],
+    allow_headers=['*'],
 )
 
-@app.get("/health")
+# ── Supabase (optional) ───────────────────────────────────────────────────────
+_sb = None
+SUPABASE_URL = os.getenv('SUPABASE_URL', '')
+SUPABASE_KEY = os.getenv('SUPABASE_ANON_KEY') or os.getenv('SUPABASE_KEY', '')
+
+if SUPABASE_URL and SUPABASE_KEY:
+    try:
+        from supabase import create_client
+        _sb = create_client(SUPABASE_URL, SUPABASE_KEY)
+        print('BOOT: Supabase connected ✓', flush=True)
+    except Exception as e:
+        print(f'BOOT: Supabase init failed: {e}', flush=True)
+else:
+    print('BOOT: Supabase not configured (SUPABASE_URL / SUPABASE_KEY missing)', flush=True)
+
+def sb():
+    if not _sb:
+        raise HTTPException(503, detail={
+            'error': 'supabase_not_configured',
+            'message': 'Imposta SUPABASE_URL e SUPABASE_KEY nelle variabili Railway/HuggingFace per abilitare la persistenza.',
+        })
+    return _sb
+
+# ── Sensitive keys mask ───────────────────────────────────────────────────────
+SENSITIVE = {
+    'OPENROUTER_API_KEY','OPENAI_API_KEY','GEMINI_API_KEY','GROQ_API_KEY',
+    'HF_TOKEN','HUGGINGFACE_API_KEY','GH_TOKEN','GITHUB_TOKEN',
+    'QDRANT_API_KEY','DATABASE_URL','SESSION_SECRET','SECRET_KEY',
+    'RAILWAY_TOKEN','SUPABASE_KEY','SUPABASE_ANON_KEY',
+}
+
+# ── Pydantic models ───────────────────────────────────────────────────────────
+class ConversationIn(BaseModel):
+    id: str
+    title: str = 'Nuova conversazione'
+    created_at: int
+    updated_at: int
+
+class MessageIn(BaseModel):
+    id: str
+    conversation_id: str
+    role: str
+    content: str
+    created_at: int
+    error: Optional[bool] = False
+    steps: Optional[Any] = None
+    agent_status: Optional[str] = None
+
+class ShellCmd(BaseModel):
+    command: str
+    timeout: int = 15
+
+class PipInstall(BaseModel):
+    packages: list[str]
+
+class MemoryEntry(BaseModel):
+    key: str
+    value: str
+    category: str = 'general'
+    createdAt: int = 0
+    updatedAt: int = 0
+
+class ReasonLoopIn(BaseModel):
+    goal: str
+    context: list[dict] = []
+    max_steps: int = 8
+
+# ── In-memory fallback for agent memory (when Supabase not available) ─────────
+_mem_fallback: dict[str, dict] = {}
+
+# ─────────────────────────────────────────────────────────────────────────────
+# HEALTH / STATUS
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.get('/health')
 async def health():
     return {
-        "status": "ok",
-        "supabase": bool(os.getenv("SUPABASE_URL")),
-        "llm": bool(os.getenv("OPENROUTER_API_KEY") or os.getenv("GROQ_API_KEY")),
+        'status': 'ok',
+        'version': '3.1.0',
+        'supabase': _sb is not None,
+        'backend': 'HuggingFace Spaces / Railway',
     }
+
+@app.get('/api/status')
+async def status():
+    safe_env = {k: '***' if k in SENSITIVE else v for k, v in os.environ.items()}
+    return {'status': 'running', 'env': safe_env, 'supabase': _sb is not None}
+
+# ─────────────────────────────────────────────────────────────────────────────
+# CONVERSATIONS
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.get('/api/conversations')
+async def list_conversations():
+    data = sb().table('conversations').select('*').order('updated_at', desc=True).execute()
+    return {'conversations': data.data}
+
+@app.post('/api/conversations')
+async def upsert_conversation(conv: ConversationIn):
+    data = sb().table('conversations').upsert(conv.model_dump()).execute()
+    return {'conversation': data.data[0] if data.data else conv.model_dump()}
+
+@app.put('/api/conversations/{conv_id}')
+async def update_conversation(conv_id: str, body: dict = Body(...)):
+    body['id'] = conv_id
+    data = sb().table('conversations').upsert(body).execute()
+    return {'conversation': data.data[0] if data.data else body}
+
+@app.delete('/api/conversations/{conv_id}')
+async def delete_conversation(conv_id: str):
+    sb().table('messages').delete().eq('conversation_id', conv_id).execute()
+    sb().table('conversations').delete().eq('id', conv_id).execute()
+    return {'deleted': conv_id}
+
+# ─────────────────────────────────────────────────────────────────────────────
+# MESSAGES
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.get('/api/conversations/{conv_id}/messages')
+async def list_messages(conv_id: str):
+    data = sb().table('messages').select('*').eq('conversation_id', conv_id).order('created_at').execute()
+    return {'messages': data.data}
+
+@app.post('/api/conversations/{conv_id}/messages')
+async def upsert_messages(conv_id: str, body: dict = Body(...)):
+    msgs = body.get('messages', [])
+    if not msgs:
+        return {'upserted': 0}
+    for m in msgs:
+        m['conversation_id'] = conv_id
+        if 'steps' in m and m['steps'] is not None:
+            m['steps'] = json.dumps(m['steps']) if not isinstance(m['steps'], str) else m['steps']
+    data = sb().table('messages').upsert(msgs).execute()
+    return {'upserted': len(data.data)}
+
+@app.delete('/api/conversations/{conv_id}/messages')
+async def clear_messages(conv_id: str):
+    sb().table('messages').delete().eq('conversation_id', conv_id).execute()
+    return {'cleared': conv_id}
+
+# ─────────────────────────────────────────────────────────────────────────────
+# AGENT MEMORY — persistente su Supabase, fallback in-memory
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.get('/api/memory/agent')
+async def list_agent_memory():
+    if _sb:
+        try:
+            data = _sb.table('agent_memory').select('*').order('updated_at', desc=True).execute()
+            entries = [
+                {'key': r['key'], 'value': r['value'], 'category': r.get('category', 'general'),
+                 'createdAt': r.get('created_at', 0), 'updatedAt': r.get('updated_at', 0)}
+                for r in (data.data or [])
+            ]
+            return {'entries': entries}
+        except Exception as e:
+            print(f'[memory] Supabase list error: {e}', flush=True)
+    # Fallback in-memory
+    return {'entries': list(_mem_fallback.values())}
+
+@app.get('/api/memory/agent/{key}')
+async def get_agent_memory(key: str):
+    if _sb:
+        try:
+            data = _sb.table('agent_memory').select('*').eq('key', key).limit(1).execute()
+            if data.data:
+                return {'value': data.data[0]['value']}
+        except Exception as e:
+            print(f'[memory] Supabase get error: {e}', flush=True)
+    # Fallback in-memory
+    entry = _mem_fallback.get(key)
+    return {'value': entry['value'] if entry else None}
+
+@app.post('/api/memory/agent')
+async def set_agent_memory(entry: MemoryEntry):
+    now = int(time.time() * 1000)
+    row = {
+        'key': entry.key,
+        'value': entry.value,
+        'category': entry.category,
+        'created_at': entry.createdAt or now,
+        'updated_at': entry.updatedAt or now,
+    }
+    if _sb:
+        try:
+            _sb.table('agent_memory').upsert(row).execute()
+        except Exception as e:
+            print(f'[memory] Supabase set error: {e}', flush=True)
+    # Always update in-memory fallback
+    _mem_fallback[entry.key] = {
+        'key': entry.key, 'value': entry.value, 'category': entry.category,
+        'createdAt': row['created_at'], 'updatedAt': row['updated_at'],
+    }
+    return {'ok': True, 'key': entry.key}
+
+@app.delete('/api/memory/agent/{key}')
+async def delete_agent_memory(key: str):
+    if _sb:
+        try:
+            _sb.table('agent_memory').delete().eq('key', key).execute()
+        except Exception:
+            pass
+    _mem_fallback.pop(key, None)
+    return {'deleted': key}
+
+# ─────────────────────────────────────────────────────────────────────────────
+# VIRTUAL FILE SYSTEM
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.get('/api/files')
+async def list_files(conversation_id: Optional[str] = None):
+    q = sb().table('vfs_files').select('id, path, language, conversation_id, updated_at')
+    if conversation_id:
+        q = q.eq('conversation_id', conversation_id)
+    data = q.order('path').execute()
+    return {'files': data.data}
+
+@app.get('/api/files/{file_id}')
+async def get_file(file_id: str):
+    data = sb().table('vfs_files').select('*').eq('id', file_id).single().execute()
+    return {'file': data.data}
+
+@app.post('/api/files')
+async def save_file(body: dict = Body(...)):
+    if 'id' not in body:
+        body['id'] = str(uuid.uuid4())
+    if 'updated_at' not in body:
+        body['updated_at'] = int(time.time() * 1000)
+    if 'created_at' not in body:
+        body['created_at'] = body['updated_at']
+    data = sb().table('vfs_files').upsert(body).execute()
+    return {'file': data.data[0] if data.data else body}
+
+@app.delete('/api/files/{file_id}')
+async def delete_file(file_id: str):
+    sb().table('vfs_files').delete().eq('id', file_id).execute()
+    return {'deleted': file_id}
+
+# ─────────────────────────────────────────────────────────────────────────────
+# REASONING LOOP — delega al backend unificato per task complessi
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.post('/api/reason/loop')
+async def reason_loop(body: ReasonLoopIn):
+    """
+    Loop di ragionamento backend per task complessi.
+    Usa UnifiedAgentLoop con smolagents se disponibile, altrimenti fallback deterministico.
+    """
+    try:
+        from agents.unified_loop import UnifiedAgentLoop
+        from models.ai_client import AIClient
+        client = AIClient()
+        loop = UnifiedAgentLoop(llm_client=client)
+        result = await loop.run(goal=body.goal, context=body.context, max_steps=body.max_steps)
+        return {'ok': True, 'result': result, 'source': 'backend_loop'}
+    except Exception as e:
+        print(f'[reason/loop] Error: {e}', flush=True)
+        return {
+            'ok': False,
+            'result': f'Backend reasoning non disponibile: {e}. Il loop browser continua normalmente.',
+            'source': 'fallback',
+        }
+
+# ─────────────────────────────────────────────────────────────────────────────
+# AGENT KERNEL — dispatch GitHub Actions da iPhone
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.get('/api/agent-kernel/status')
+async def agent_kernel_status():
+    gh_token = os.getenv('GITHUB_TOKEN') or os.getenv('GH_TOKEN', '')
+    return {
+        'dispatch_available': bool(gh_token),
+        'workflow_url': 'https://github.com/Baida98/AI/actions/workflows/agent-kernel.yml',
+        'mobile_url': 'https://github.com/Baida98/AI/actions',
+        'secrets_needed': ['OPENROUTER_API_KEY', 'GROQ_API_KEY', 'GEMINI_API_KEY', 'HF_TOKEN'],
+        'usage': 'Vai su GitHub Actions → Agent Kernel — no PC → Run workflow → inserisci il goal',
+    }
+
+@app.post('/api/agent-kernel/dispatch')
+async def agent_kernel_dispatch(body: dict = Body(...)):
+    """Avvia GitHub Actions workflow dal backend (richiede GITHUB_TOKEN o GH_TOKEN nel backend)."""
+    gh_token = os.getenv('GITHUB_TOKEN') or os.getenv('GH_TOKEN', '')
+    if not gh_token:
+        raise HTTPException(503, detail={
+            'error': 'no_github_token',
+            'message': 'GITHUB_TOKEN non configurato nel backend. Usa GitHub Actions direttamente da mobile.',
+        })
+    goal = body.get('goal', '').strip()
+    mode = body.get('mode', 'plan')
+    if not goal:
+        raise HTTPException(400, detail='goal è obbligatorio')
+
+    import urllib.request, urllib.error
+    payload = json.dumps({
+        'ref': 'main',
+        'inputs': {'goal': goal, 'mode': mode, 'commit_memory': 'true'},
+    }).encode()
+    req = urllib.request.Request(
+        'https://api.github.com/repos/Baida98/AI/actions/workflows/agent-kernel.yml/dispatches',
+        data=payload,
+        headers={
+            'Authorization': f'Bearer {gh_token}',
+            'Accept': 'application/vnd.github+json',
+            'Content-Type': 'application/json',
+            'X-GitHub-Api-Version': '2022-11-28',
+        },
+        method='POST',
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return {'ok': True, 'status': resp.status, 'goal': goal, 'mode': mode}
+    except urllib.error.HTTPError as e:
+        raise HTTPException(e.code, detail=e.read().decode()[:500])
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SHELL EXECUTION (sandboxed)
+# ─────────────────────────────────────────────────────────────────────────────
+BLOCKED_CMDS = {'rm -rf /', 'mkfs', ':(){:|:&};:', 'dd if=/dev/zero'}
+
+@app.post('/api/execute-shell')
+async def execute_shell(cmd: ShellCmd):
+    raw = cmd.command.strip()
+    for bad in BLOCKED_CMDS:
+        if bad in raw:
+            raise HTTPException(400, 'Command blocked for safety')
+    timeout = min(max(cmd.timeout, 1), 60)
+    with tempfile.TemporaryDirectory() as tmpdir:
+        try:
+            proc = await asyncio.create_subprocess_shell(
+                raw,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=tmpdir,
+                env={**os.environ, 'HOME': tmpdir, 'TMPDIR': tmpdir},
+            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+            return {
+                'stdout': stdout.decode('utf-8', errors='replace')[:8000],
+                'stderr': stderr.decode('utf-8', errors='replace')[:4000],
+                'exit_code': proc.returncode,
+            }
+        except asyncio.TimeoutError:
+            proc.kill()
+            return {'stdout': '', 'stderr': f'Timeout dopo {timeout}s', 'exit_code': -1}
+        except Exception as e:
+            return {'stdout': '', 'stderr': str(e), 'exit_code': -1}
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PIP INSTALL
+# ─────────────────────────────────────────────────────────────────────────────
+
+@app.post('/api/pip-install')
+async def pip_install(body: PipInstall):
+    pkgs = [p.strip() for p in body.packages if p.strip()]
+    if not pkgs:
+        raise HTTPException(400, 'No packages specified')
+    import re
+    safe = re.compile(r'^[a-zA-Z0-9_\-\[\]>=<\.]+$')
+    for p in pkgs:
+        if not safe.match(p):
+            raise HTTPException(400, f'Invalid package name: {p}')
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            sys.executable, '-m', 'pip', 'install', '--quiet', '--user', *pkgs,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=120)
+        return {
+            'installed': pkgs,
+            'stdout': stdout.decode('utf-8', errors='replace')[:4000],
+            'stderr': stderr.decode('utf-8', errors='replace')[:2000],
+            'exit_code': proc.returncode,
+        }
+    except asyncio.TimeoutError:
+        return {'error': 'Timeout during pip install (120s)', 'exit_code': -1}
+    except Exception as e:
+        return {'error': str(e), 'exit_code': -1}
+
+# ─────────────────────────────────────────────────────────────────────────────
+# SUPABASE SCHEMA — esegui una volta nell'editor SQL di Supabase
+# ─────────────────────────────────────────────────────────────────────────────
+#
+# CREATE TABLE IF NOT EXISTS conversations (
+#   id         TEXT PRIMARY KEY,
+#   user_id    TEXT NOT NULL DEFAULT 'default',
+#   title      TEXT NOT NULL DEFAULT 'Nuova conversazione',
+#   created_at BIGINT NOT NULL,
+#   updated_at BIGINT NOT NULL
+# );
+#
+# CREATE TABLE IF NOT EXISTS messages (
+#   id              TEXT PRIMARY KEY,
+#   user_id         TEXT NOT NULL DEFAULT 'default',
+#   conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+#   role            TEXT NOT NULL CHECK (role IN ('user','assistant')),
+#   content         TEXT NOT NULL,
+#   created_at      BIGINT NOT NULL,
+#   error           BOOLEAN DEFAULT FALSE,
+#   steps           JSONB,
+#   agent_status    TEXT
+# );
+# CREATE INDEX IF NOT EXISTS idx_messages_conv ON messages(conversation_id);
+# CREATE INDEX IF NOT EXISTS idx_conv_user ON conversations(user_id);
+#
+# CREATE TABLE IF NOT EXISTS vfs_files (
+#   id              TEXT PRIMARY KEY,
+#   user_id         TEXT NOT NULL DEFAULT 'default',
+#   conversation_id TEXT,
+#   path            TEXT NOT NULL,
+#   content         TEXT NOT NULL,
+#   language        TEXT,
+#   created_at      BIGINT NOT NULL,
+#   updated_at      BIGINT NOT NULL
+# );
+# CREATE INDEX IF NOT EXISTS idx_vfs_conv ON vfs_files(conversation_id);
+# CREATE INDEX IF NOT EXISTS idx_vfs_user ON vfs_files(user_id);
+#
+# CREATE TABLE IF NOT EXISTS agent_memory (
+#   key        TEXT PRIMARY KEY,
+#   user_id    TEXT NOT NULL DEFAULT 'default',
+#   value      TEXT NOT NULL,
+#   category   TEXT DEFAULT 'general',
+#   created_at BIGINT NOT NULL DEFAULT 0,
+#   updated_at BIGINT NOT NULL DEFAULT 0
+# );
+# CREATE INDEX IF NOT EXISTS idx_memory_user ON agent_memory(user_id);
+#
+# CREATE TABLE IF NOT EXISTS episodes (
+#   id      BIGSERIAL PRIMARY KEY,
+#   user_id TEXT NOT NULL DEFAULT 'default',
+#   type    TEXT NOT NULL,
+#   task    TEXT NOT NULL,
+#   output  TEXT,
+#   success BOOLEAN DEFAULT TRUE,
+#   ts      TEXT NOT NULL,
+#   tags    JSONB DEFAULT '[]'
+# );
+# CREATE INDEX IF NOT EXISTS idx_episodes_type ON episodes(type);
+# CREATE INDEX IF NOT EXISTS idx_episodes_user ON episodes(user_id);
+#
+# CREATE TABLE IF NOT EXISTS semantic_memory (
+#   id       TEXT PRIMARY KEY,
+#   content  TEXT NOT NULL,
+#   metadata JSONB DEFAULT '{}'
+# );
+#
+# -- Row Level Security (open per ora — nessun login richiesto)
+# ALTER TABLE conversations   ENABLE ROW LEVEL SECURITY;
+# ALTER TABLE messages        ENABLE ROW LEVEL SECURITY;
+# ALTER TABLE vfs_files       ENABLE ROW LEVEL SECURITY;
+# ALTER TABLE agent_memory    ENABLE ROW LEVEL SECURITY;
+# ALTER TABLE episodes        ENABLE ROW LEVEL SECURITY;
+# ALTER TABLE semantic_memory ENABLE ROW LEVEL SECURITY;
+# CREATE POLICY "public_all" ON conversations   FOR ALL USING (true) WITH CHECK (true);
+# CREATE POLICY "public_all" ON messages        FOR ALL USING (true) WITH CHECK (true);
+# CREATE POLICY "public_all" ON vfs_files       FOR ALL USING (true) WITH CHECK (true);
+# CREATE POLICY "public_all" ON agent_memory    FOR ALL USING (true) WITH CHECK (true);
+# CREATE POLICY "public_all" ON episodes        FOR ALL USING (true) WITH CHECK (true);
+# CREATE POLICY "public_all" ON semantic_memory FOR ALL USING (true) WITH CHECK (true);
+
+# ─────────────────────────────────────────────────────────────────────────────
+# FRONTEND STATIC
+# ─────────────────────────────────────────────────────────────────────────────
+STATIC_DIR = os.getenv('FRONTEND_DIST', '/app/backend/static')
+if os.path.isdir(STATIC_DIR):
+    app.mount('/', StaticFiles(directory=STATIC_DIR, html=True), name='spa')
+    print(f'BOOT: serving frontend from {STATIC_DIR}', flush=True)
+else:
+    print(f'BOOT: no frontend at {STATIC_DIR}', flush=True)
+
+print('BOOT: main.py v3.1.0 ready ✓', flush=True)

memory/episodic.py

@@ -0,0 +1,163 @@
+"""
+episodic.py — Episodic Memory
+Task completati, errori, fix — persiste su Supabase se disponibile, altrimenti SQLite locale.
+Backend server: HuggingFace Spaces (FastAPI). Database: Supabase.
+"""
+from __future__ import annotations
+
+import json, os, sqlite3
+from datetime import datetime
+from pathlib import Path
+from dataclasses import dataclass
+
+DB_PATH = Path("episodic_memory.db")
+
+
+@dataclass
+class Episode:
+    id: int
+    type: str
+    task: str
+    output: str
+    success: bool
+    ts: str
+    tags: list[str]
+
+
+class EpisodicMemory:
+    def __init__(self):
+        self._db: sqlite3.Connection | None = None
+        self._sb = None
+
+    def _try_supabase(self):
+        url = os.getenv("SUPABASE_URL", "")
+        key = os.getenv("SUPABASE_ANON_KEY") or os.getenv("SUPABASE_KEY", "")
+        if not url or not key:
+            return None
+        try:
+            from supabase import create_client
+            return create_client(url, key)
+        except Exception as e:
+            print(f"EpisodicMemory: Supabase non disponibile: {e}", flush=True)
+            return None
+
+    def init(self):
+        self._sb = self._try_supabase()
+        if self._sb:
+            try:
+                self._sb.table("episodes").select("id").limit(1).execute()
+                print("EpisodicMemory: Supabase ✓", flush=True)
+                return
+            except Exception as e:
+                print(f"EpisodicMemory: Supabase table check fallita: {e}", flush=True)
+                self._sb = None
+
+        # Fallback SQLite locale (dev / HF Spaces senza Supabase configurato)
+        self._db = sqlite3.connect(DB_PATH, check_same_thread=False)
+        self._db.execute("""
+            CREATE TABLE IF NOT EXISTS episodes (
+                id      INTEGER PRIMARY KEY AUTOINCREMENT,
+                type    TEXT NOT NULL,
+                task    TEXT NOT NULL,
+                output  TEXT,
+                success INTEGER DEFAULT 1,
+                ts      TEXT NOT NULL,
+                tags    TEXT DEFAULT '[]'
+            )
+        """)
+        self._db.execute("CREATE INDEX IF NOT EXISTS idx_type ON episodes(type)")
+        self._db.execute("CREATE INDEX IF NOT EXISTS idx_ts   ON episodes(ts)")
+        self._db.commit()
+        print("EpisodicMemory: SQLite locale (fallback) ✓", flush=True)
+
+    # ── Write ─────────────────────────────────────────────────────────────────
+
+    def add(self, type_: str, task: str, output: str, success: bool,
+            tags: list[str] | None = None) -> int:
+        ts  = datetime.now().isoformat()
+        row = {
+            "type": type_, "task": task[:500], "output": output[:2000],
+            "success": success, "ts": ts, "tags": json.dumps(tags or []),
+        }
+        if self._sb:
+            try:
+                res = self._sb.table("episodes").insert(row).execute()
+                return res.data[0].get("id", -1) if res.data else -1
+            except Exception:
+                pass
+        if not self._db:
+            return -1
+        cur = self._db.execute(
+            "INSERT INTO episodes (type,task,output,success,ts,tags) VALUES (?,?,?,?,?,?)",
+            (type_, task[:500], output[:2000], int(success), ts, json.dumps(tags or []))
+        )
+        self._db.commit()
+        return cur.lastrowid
+
+    # ── Read ──────────────────────────────────────────────────────────────────
+
+    def get_recent(self, n: int = 20, type_: str | None = None) -> list[Episode]:
+        if self._sb:
+            try:
+                q = self._sb.table("episodes").select("*").order("id", desc=True).limit(n)
+                if type_:
+                    q = q.eq("type", type_)
+                rows = q.execute().data or []
+                return [self._from_sb(r) for r in rows]
+            except Exception:
+                pass
+        if not self._db:
+            return []
+        if type_:
+            rows = self._db.execute(
+                "SELECT * FROM episodes WHERE type=? ORDER BY id DESC LIMIT ?", (type_, n)
+            ).fetchall()
+        else:
+            rows = self._db.execute(
+                "SELECT * FROM episodes ORDER BY id DESC LIMIT ?", (n,)
+            ).fetchall()
+        return [Episode(r[0], r[1], r[2], r[3], bool(r[4]), r[5], json.loads(r[6])) for r in rows]
+
+    def search_text(self, query: str, n: int = 5) -> list[Episode]:
+        if self._sb:
+            try:
+                rows = self._sb.table("episodes").select("*").ilike("task", f"%{query}%").limit(n).execute().data or []
+                if not rows:
+                    rows = self._sb.table("episodes").select("*").ilike("output", f"%{query}%").limit(n).execute().data or []
+                return [self._from_sb(r) for r in rows]
+            except Exception:
+                pass
+        if not self._db:
+            return []
+        rows = self._db.execute(
+            "SELECT * FROM episodes WHERE task LIKE ? OR output LIKE ? ORDER BY id DESC LIMIT ?",
+            (f"%{query}%", f"%{query}%", n)
+        ).fetchall()
+        return [Episode(r[0], r[1], r[2], r[3], bool(r[4]), r[5], json.loads(r[6])) for r in rows]
+
+    def get_errors(self, n: int = 10) -> list[Episode]:
+        return self.get_recent(n, type_="error")
+
+    def stats(self) -> dict:
+        if self._sb:
+            try:
+                res = self._sb.table("episodes").select("id", count="exact").execute()
+                return {"total": res.count or 0, "backend": "supabase"}
+            except Exception:
+                pass
+        if not self._db:
+            return {"total": 0, "backend": "none"}
+        total  = self._db.execute("SELECT COUNT(*) FROM episodes").fetchone()[0]
+        by_type = dict(self._db.execute("SELECT type, COUNT(*) FROM episodes GROUP BY type").fetchall())
+        return {"total": total, "by_type": by_type, "backend": "sqlite"}
+
+    @staticmethod
+    def _from_sb(r: dict) -> Episode:
+        return Episode(
+            r["id"], r["type"], r["task"], r.get("output", ""),
+            bool(r["success"]), r["ts"], json.loads(r.get("tags", "[]"))
+        )
+
+    def close(self):
+        if self._db:
+            self._db.close()

memory/hf_store.py

@@ -0,0 +1,5 @@
+# hf_store.py — NON USATO
+# Questo file era un errore di progettazione.
+# HuggingFace Spaces = server (esegue il backend Python).
+# Supabase = database (salva dati, memoria, file).
+# Vedi episodic.py e semantic.py per la corretta implementazione Supabase-first.

memory/manager.py

@@ -0,0 +1,115 @@
+"""
+manager.py — Unified Memory Manager
+Coordina i 4 layer: Working, Episodic, Semantic, Reflection.
+"""
+from .working import WorkingMemory
+from .episodic import EpisodicMemory
+from .semantic import SemanticMemory
+from .reflection import ReflectionMemory
+
+class MemoryManager:
+    def __init__(self):
+        self.working   = WorkingMemory(max_entries=40)
+        self.episodic  = EpisodicMemory()
+        self.semantic  = SemanticMemory()
+        self.reflection = ReflectionMemory()
+
+    async def init(self):
+        self.episodic.init()
+        self.semantic.init()
+
+    async def close(self):
+        self.episodic.close()
+
+    async def get_context(self, query: str) -> str:
+        """Assembla il contesto dai 4 layer per arricchire il prompt."""
+        parts = []
+
+        # 1. Working memory — conversazione recente
+        working_ctx = self.working.get_context_string(n=6)
+        if working_ctx:
+            parts.append(working_ctx)
+
+        # 2. Semantic memory — conoscenza rilevante
+        if self.semantic.available:
+            semantic_hits = self.semantic.search(query, n_results=4)
+            if semantic_hits:
+                lines = [f"- {h['content'][:200]}" for h in semantic_hits if h["similarity"] > 0.3]
+                if lines:
+                    parts.append("Conoscenza rilevante:\n" + "\n".join(lines))
+
+        # 3. Reflection lessons — errori da evitare
+        lessons = self.reflection.get_relevant_lessons(query, n=2)
+        if lessons:
+            lesson_lines = []
+            for l in lessons:
+                if l["type"] == "failure":
+                    lesson_lines.append(f"- EVITA: {l['avoid'][:100]}")
+                else:
+                    lesson_lines.append(f"- STRATEGIA: {l['strategy'][:100]}")
+            if lesson_lines:
+                parts.append("Lezioni passate:\n" + "\n".join(lesson_lines))
+
+        return "\n\n".join(parts) if parts else ""
+
+    async def save_exchange(self, messages: list, response: str):
+        """Salva uno scambio chat nella memoria."""
+        user_msg = next((m["content"] for m in reversed(messages) if m["role"] == "user"), "")
+        # Working: aggiungi utente + risposta
+        if user_msg:
+            self.working.add("user", user_msg)
+        self.working.add("assistant", response)
+        # Episodic: salva la coppia
+        self.episodic.add("chat", user_msg[:300], response[:500], True)
+        # Semantic: indicizza per similarity search futura
+        if self.semantic.available and user_msg and len(response) > 50:
+            combined = f"Q: {user_msg[:200]} A: {response[:400]}"
+            self.semantic.add(combined, {"type": "chat", "query": user_msg[:100]})
+
+    async def save_episode(self, type_: str, task: str, output: str, success: bool, tags: list | None = None):
+        self.episodic.add(type_, task, output, success, tags)
+        if self.semantic.available and task:
+            self.semantic.add(task, {"type": type_, "success": success})
+
+    async def search(self, query: str, n: int = 5, layer: str | None = None) -> list[dict]:
+        results = []
+        if layer in (None, "semantic") and self.semantic.available:
+            for h in self.semantic.search(query, n_results=n):
+                results.append({**h, "layer": "semantic"})
+        if layer in (None, "episodic"):
+            for ep in self.episodic.search_text(query, n=n):
+                results.append({"content": f"{ep.task} → {ep.output[:200]}", "layer": "episodic", "type": ep.type, "success": ep.success})
+        if layer == "reflection":
+            lessons = self.reflection.get_relevant_lessons(query, n=n)
+            results.extend([{**l, "layer": "reflection"} for l in lessons])
+        return results[:n]
+
+    async def reflect(self, task: str, output: str, success: bool, error: str | None = None) -> dict:
+        if success:
+            self.reflection.record_success(task, output[:300])
+            await self.save_episode("fix", task, output, True)
+        else:
+            self.reflection.record_failure(task, error or output[:300])
+            await self.save_episode("error", task, error or output[:300], False)
+        return {
+            "recorded": True,
+            "top_patterns": self.reflection.get_top_patterns(3),
+            "lessons": self.reflection.get_relevant_lessons(task, 2),
+        }
+
+    def stats(self) -> dict:
+        return {
+            "working":    self.working.stats(),
+            "episodic":   self.episodic.stats(),
+            "semantic":   self.semantic.stats(),
+            "reflection": self.reflection.stats(),
+        }
+
+    async def clear(self, layer: str | None = None):
+        if layer in (None, "working"):
+            self.working.clear()
+        if layer in (None, "episodic"):
+            import sqlite3
+            if self.episodic._db:
+                self.episodic._db.execute("DELETE FROM episodes")
+                self.episodic._db.commit()

memory/reflection.py

@@ -0,0 +1,81 @@
+"""
+reflection.py — Reflection Memory
+Impara dagli errori, pattern di fallimento, strategie vincenti.
+"""
+import json
+from pathlib import Path
+from datetime import datetime
+
+REFLECTION_PATH = Path("reflection_memory.json")
+
+class ReflectionMemory:
+    def __init__(self):
+        self._data: dict = {"failures": [], "successes": [], "patterns": {}}
+        self._load()
+
+    def _load(self):
+        if REFLECTION_PATH.exists():
+            try:
+                self._data = json.loads(REFLECTION_PATH.read_text())
+            except Exception:
+                pass
+
+    def _save(self):
+        REFLECTION_PATH.write_text(json.dumps(self._data, indent=2, ensure_ascii=False))
+
+    def record_failure(self, task: str, error: str, attempted_strategy: str = ""):
+        entry = {
+            "ts": datetime.now().isoformat(),
+            "task": task[:300],
+            "error": error[:500],
+            "strategy": attempted_strategy,
+        }
+        self._data["failures"].append(entry)
+        # Track pattern frequency
+        key = error[:80].lower()
+        self._data["patterns"][key] = self._data["patterns"].get(key, 0) + 1
+        # Cap at 200 entries
+        self._data["failures"] = self._data["failures"][-200:]
+        self._save()
+
+    def record_success(self, task: str, strategy: str):
+        entry = {
+            "ts": datetime.now().isoformat(),
+            "task": task[:300],
+            "strategy": strategy[:300],
+        }
+        self._data["successes"].append(entry)
+        self._data["successes"] = self._data["successes"][-100:]
+        self._save()
+
+    def get_relevant_lessons(self, task: str, n: int = 3) -> list[dict]:
+        """Find past failures/successes relevant to current task."""
+        task_lower = task.lower()
+        words = set(task_lower.split())
+        def score(entry):
+            text = (entry.get("task", "") + " " + entry.get("strategy", "") + entry.get("error", "")).lower()
+            return sum(1 for w in words if w in text and len(w) > 3)
+
+        failures = sorted(self._data["failures"], key=score, reverse=True)[:n]
+        successes = sorted(self._data["successes"], key=score, reverse=True)[:n]
+        lessons = []
+        for f in failures[:2]:
+            if score(f) > 0:
+                lessons.append({"type": "failure", "task": f["task"], "avoid": f["error"]})
+        for s in successes[:1]:
+            if score(s) > 0:
+                lessons.append({"type": "success", "task": s["task"], "strategy": s["strategy"]})
+        return lessons
+
+    def get_top_patterns(self, n: int = 5) -> list[dict]:
+        return sorted(
+            [{"pattern": k, "count": v} for k, v in self._data["patterns"].items()],
+            key=lambda x: x["count"], reverse=True
+        )[:n]
+
+    def stats(self) -> dict:
+        return {
+            "failures": len(self._data["failures"]),
+            "successes": len(self._data["successes"]),
+            "patterns": len(self._data["patterns"]),
+        }

memory/semantic.py

@@ -0,0 +1,138 @@
+"""
+semantic.py — Semantic Memory
+Preferenze, concetti, conoscenza persistente.
+Database: Supabase (text search). Fallback: ChromaDB locale.
+Backend server: HuggingFace Spaces (FastAPI).
+"""
+from __future__ import annotations
+
+import os, uuid
+from pathlib import Path
+from typing import Any
+
+CHROMA_PATH     = Path("chroma_db")
+COLLECTION_NAME = "agente_semantic"
+EMBED_MODEL     = "BAAI/bge-small-en-v1.5"
+
+try:
+    import chromadb
+    from chromadb.utils import embedding_functions
+    CHROMA_AVAILABLE = True
+except ImportError:
+    CHROMA_AVAILABLE = False
+
+
+class SemanticMemory:
+    def __init__(self):
+        self._client     = None
+        self._collection = None
+        self._embed_fn   = None
+        self._sb         = None
+        self.available   = False
+
+    def _try_supabase(self):
+        url = os.getenv("SUPABASE_URL", "")
+        key = os.getenv("SUPABASE_ANON_KEY") or os.getenv("SUPABASE_KEY", "")
+        if not url or not key:
+            return None
+        try:
+            from supabase import create_client
+            return create_client(url, key)
+        except Exception:
+            return None
+
+    def init(self):
+        self._sb = self._try_supabase()
+        if self._sb:
+            try:
+                self._sb.table("semantic_memory").select("id").limit(1).execute()
+                self.available = True
+                print("SemanticMemory: Supabase ✓", flush=True)
+                return
+            except Exception as e:
+                print(f"SemanticMemory: Supabase table mancante: {e}", flush=True)
+                self._sb = None
+
+        # Fallback ChromaDB locale (HF Spaces senza Supabase)
+        if not CHROMA_AVAILABLE:
+            print("WARN: chromadb non installato — SemanticMemory disabilitata", flush=True)
+            return
+        try:
+            self._embed_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
+                model_name=EMBED_MODEL
+            )
+            self._client    = chromadb.PersistentClient(path=str(CHROMA_PATH))
+            self._collection = self._client.get_or_create_collection(
+                name=COLLECTION_NAME,
+                embedding_function=self._embed_fn,
+                metadata={"hnsw:space": "cosine"},
+            )
+            self.available = True
+            print("SemanticMemory: ChromaDB locale (fallback) ✓", flush=True)
+        except Exception as e:
+            print(f"WARN: SemanticMemory non disponibile: {e}", flush=True)
+
+    # ── Write ─────────────────────────────────────────────────────────────────
+
+    def add(self, text: str, metadata: dict | None = None, doc_id: str | None = None):
+        _id = doc_id or str(uuid.uuid4())
+        if self._sb:
+            try:
+                self._sb.table("semantic_memory").upsert({
+                    "id": _id, "content": text[:2000], "metadata": metadata or {},
+                }).execute()
+                return
+            except Exception:
+                pass
+        if self._collection:
+            self._collection.upsert(
+                documents=[text],
+                metadatas=[metadata or {}],
+                ids=[_id],
+            )
+
+    # ── Read ──────────────────────────────────────────────────────────────────
+
+    def search(self, query: str, n_results: int = 5) -> list[dict]:
+        if self._sb:
+            try:
+                rows = (
+                    self._sb.table("semantic_memory")
+                    .select("*")
+                    .ilike("content", f"%{query}%")
+                    .limit(n_results)
+                    .execute().data or []
+                )
+                return [{"content": r["content"], "metadata": r.get("metadata", {}),
+                         "similarity": 0.8} for r in rows]
+            except Exception:
+                pass
+        if not self._collection:
+            return []
+        try:
+            results = self._collection.query(
+                query_texts=[query],
+                n_results=min(n_results, self._collection.count() or 1),
+            )
+            docs   = results.get("documents", [[]])[0]
+            metas  = results.get("metadatas",  [[]])[0]
+            dists  = results.get("distances",  [[]])[0]
+            return [
+                {"content": doc, "metadata": meta, "similarity": round(1 - dist, 4)}
+                for doc, meta, dist in zip(docs, metas, dists)
+            ]
+        except Exception:
+            return []
+
+    def count(self) -> int:
+        if self._sb:
+            try:
+                return self._sb.table("semantic_memory").select("id", count="exact").execute().count or 0
+            except Exception:
+                pass
+        return self._collection.count() if self._collection else 0
+
+    def stats(self) -> dict:
+        backend = "supabase" if self._sb else ("chroma" if self._collection else "none")
+        return {"available": self.available, "documents": self.count(),
+                "model": EMBED_MODEL, "backend": backend}

memory/sync.py

@@ -0,0 +1,169 @@
+"""
+sync.py — Memory Sync Protocol
+
+Sincronizza in modo idempotente la memoria locale del browser con il backend.
+Il protocollo accetta batch di elementi firmati da source/id/versione e salva
+il contenuto nei layer episodic/semantic senza richiedere dipendenze aggiuntive.
+"""
+from __future__ import annotations
+
+import hashlib
+import time
+from typing import Any, Iterable, Literal
+
+from fastapi import APIRouter
+from pydantic import BaseModel, Field
+
+
+MemoryLayer = Literal["working", "episodic", "semantic", "reflection"]
+MemoryType = Literal["fact", "preference", "summary", "skill", "episode", "reflection"]
+
+
+class SyncMemoryItem(BaseModel):
+    id: str = Field(..., min_length=1)
+    content: str = Field(..., min_length=1)
+    type: MemoryType = "fact"
+    layer: MemoryLayer = "semantic"
+    topic: str | None = None
+    weight: float = 1.0
+    created_at: int | None = None
+    updated_at: int | None = None
+    source: str = "browser"
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
+class MemorySyncPushRequest(BaseModel):
+    device_id: str = "browser"
+    since: int | None = None
+    items: list[SyncMemoryItem] = Field(default_factory=list)
+
+
+class MemorySyncPullRequest(BaseModel):
+    device_id: str = "browser"
+    query: str | None = None
+    since: int | None = None
+    limit: int = Field(default=50, ge=1, le=200)
+    layer: MemoryLayer | None = None
+
+
+class MemorySyncStatus(BaseModel):
+    ok: bool
+    protocol: str = "memory-sync-v1"
+    server_time: int
+    stats: dict[str, Any]
+
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+def _fingerprint(item: SyncMemoryItem) -> str:
+    raw = f"{item.source}:{item.id}:{item.updated_at or item.created_at or 0}:{item.content}".encode("utf-8")
+    return hashlib.sha256(raw).hexdigest()[:16]
+
+
+def _iter_local_items(memory: Any, layer: MemoryLayer | None, limit: int) -> Iterable[dict[str, Any]]:
+    """Best-effort export from available memory layers."""
+    if layer in (None, "working") and hasattr(memory, "working"):
+        entries = getattr(memory.working, "entries", []) or []
+        for idx, entry in enumerate(entries[-limit:]):
+            if isinstance(entry, dict):
+                content = entry.get("content") or entry.get("text") or str(entry)
+                role = entry.get("role", "unknown")
+            else:
+                content = getattr(entry, "content", str(entry))
+                role = getattr(entry, "role", "unknown")
+            yield {
+                "id": f"working-{idx}",
+                "content": content,
+                "type": "episode",
+                "layer": "working",
+                "topic": role,
+                "weight": 1,
+                "updated_at": _now_ms(),
+                "source": "backend",
+                "metadata": {"role": role},
+            }
+
+
+def create_memory_sync_router(memory: Any) -> APIRouter:
+    router = APIRouter(prefix="/api/memory/sync", tags=["memory-sync"])
+
+    @router.get("/status", response_model=MemorySyncStatus)
+    async def sync_status() -> MemorySyncStatus:
+        return MemorySyncStatus(ok=True, server_time=_now_ms(), stats=memory.stats())
+
+    @router.post("/push")
+    async def sync_push(req: MemorySyncPushRequest) -> dict[str, Any]:
+        accepted: list[str] = []
+        skipped: list[dict[str, str]] = []
+        now = _now_ms()
+
+        for item in req.items:
+            if not item.content.strip():
+                skipped.append({"id": item.id, "reason": "empty-content"})
+                continue
+
+            item.metadata.setdefault("sync_id", item.id)
+            item.metadata.setdefault("device_id", req.device_id)
+            item.metadata.setdefault("fingerprint", _fingerprint(item))
+            item.metadata.setdefault("synced_at", now)
+            item.metadata.setdefault("source", item.source)
+            item.metadata.setdefault("topic", item.topic or "generale")
+
+            try:
+                if item.layer == "working" and hasattr(memory, "working"):
+                    role = str(item.metadata.get("role") or item.type)
+                    memory.working.add(role, item.content)
+                elif item.layer == "episodic":
+                    await memory.save_episode(item.type, item.topic or item.id, item.content, True, tags=["sync", req.device_id])
+                else:
+                    if getattr(memory.semantic, "available", False):
+                        memory.semantic.add(item.content, {"type": item.type, **item.metadata})
+                    else:
+                        await memory.save_episode(item.type, item.topic or item.id, item.content, True, tags=["sync", req.device_id])
+                accepted.append(item.id)
+            except Exception as exc:  # pragma: no cover - defensive endpoint boundary
+                skipped.append({"id": item.id, "reason": str(exc)[:180]})
+
+        return {
+            "ok": True,
+            "protocol": "memory-sync-v1",
+            "accepted": accepted,
+            "skipped": skipped,
+            "server_time": now,
+            "stats": memory.stats(),
+        }
+
+    @router.post("/pull")
+    async def sync_pull(req: MemorySyncPullRequest) -> dict[str, Any]:
+        query = (req.query or "").strip()
+        items: list[dict[str, Any]] = []
+
+        if query:
+            results = await memory.search(query, req.limit, layer=req.layer)
+            for idx, hit in enumerate(results):
+                content = str(hit.get("content", ""))
+                items.append({
+                    "id": str(hit.get("id") or f"backend-search-{idx}"),
+                    "content": content,
+                    "type": str(hit.get("type") or "fact"),
+                    "layer": str(hit.get("layer") or req.layer or "semantic"),
+                    "topic": str(hit.get("topic") or "generale"),
+                    "weight": float(hit.get("similarity") or 1),
+                    "updated_at": _now_ms(),
+                    "source": "backend",
+                    "metadata": {k: v for k, v in hit.items() if k not in {"content"}},
+                })
+        else:
+            items.extend(list(_iter_local_items(memory, req.layer, req.limit)))
+
+        return {
+            "ok": True,
+            "protocol": "memory-sync-v1",
+            "items": items[: req.limit],
+            "server_time": _now_ms(),
+            "stats": memory.stats(),
+        }
+
+    return router

memory/working.py

@@ -0,0 +1,40 @@
+"""
+working.py — Working Memory (short-term, in-RAM)
+Ultime N conversazioni per contesto immediato.
+"""
+from collections import deque
+from dataclasses import dataclass, field
+from datetime import datetime
+
+@dataclass
+class WorkingEntry:
+    role: str
+    content: str
+    ts: float = field(default_factory=lambda: datetime.now().timestamp())
+
+class WorkingMemory:
+    def __init__(self, max_entries: int = 40):
+        self._buf: deque[WorkingEntry] = deque(maxlen=max_entries)
+
+    def add(self, role: str, content: str):
+        self._buf.append(WorkingEntry(role=role, content=content))
+
+    def get_recent(self, n: int = 10) -> list[dict]:
+        entries = list(self._buf)[-n:]
+        return [{"role": e.role, "content": e.content} for e in entries]
+
+    def get_context_string(self, n: int = 6) -> str:
+        recent = self.get_recent(n)
+        if not recent:
+            return ""
+        lines = []
+        for m in recent:
+            prefix = "Utente" if m["role"] == "user" else "AI"
+            lines.append(f"{prefix}: {m['content'][:200]}")
+        return "Conversazione recente:\n" + "\n".join(lines)
+
+    def clear(self):
+        self._buf.clear()
+
+    def stats(self) -> dict:
+        return {"entries": len(self._buf), "max": self._buf.maxlen}

models/ai_client.py

@@ -0,0 +1,187 @@
+"""
+ai_client.py — Cloud AI Client for free remote deployments
+
+Backend-first model router for mobile/no-PC usage. It prefers free or low-cost
+OpenAI-compatible providers when configured and falls back across providers before
+returning an error. The iPhone remains only a control surface; all model calls run
+from the deployed backend/HF Space.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import AsyncIterator, Optional
+
+from openai import OpenAI
+
+
+@dataclass(frozen=True)
+class ProviderConfig:
+    name: str
+    api_key: str
+    base_url: str
+    default_model: str
+    embedding_model: Optional[str] = None
+
+
+class AIClient:
+    def __init__(self):
+        self.providers = self._discover_providers()
+        self.default_model = self.providers[0].default_model if self.providers else os.getenv("LLM_MODEL", "openrouter/auto")
+        self.provider_name = self.providers[0].name if self.providers else "unconfigured"
+        self.client = self._client_for(self.providers[0]) if self.providers else None
+
+    def _discover_providers(self) -> list[ProviderConfig]:
+        providers: list[ProviderConfig] = []
+
+        openrouter_key = os.getenv("OPENROUTER_API_KEY")
+        if openrouter_key:
+            providers.append(ProviderConfig(
+                name="openrouter",
+                api_key=openrouter_key,
+                base_url="https://openrouter.ai/api/v1",
+                default_model=os.getenv("OPENROUTER_MODEL", os.getenv("LLM_MODEL", "deepseek/deepseek-r1:free")),
+            ))
+
+        gemini_key = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+        if gemini_key:
+            providers.append(ProviderConfig(
+                name="gemini",
+                api_key=gemini_key,
+                base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+                default_model=os.getenv("GEMINI_MODEL", os.getenv("LLM_MODEL_GEMINI", "gemini-2.0-flash")),
+            ))
+
+        groq_key = os.getenv("GROQ_API_KEY")
+        if groq_key:
+            providers.append(ProviderConfig(
+                name="groq",
+                api_key=groq_key,
+                base_url="https://api.groq.com/openai/v1",
+                default_model=os.getenv("GROQ_MODEL", os.getenv("LLM_MODEL_GROQ", "llama-3.1-8b-instant")),
+            ))
+
+        hf_key = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_API_KEY") or os.getenv("HUGGINGFACE_TOKEN")
+        if hf_key:
+            providers.append(ProviderConfig(
+                name="huggingface",
+                api_key=hf_key,
+                base_url=os.getenv("HF_OPENAI_BASE_URL", "https://router.huggingface.co/v1"),
+                default_model=os.getenv("HF_MODEL", os.getenv("LLM_MODEL_HF", "Qwen/Qwen2.5-Coder-32B-Instruct")),
+            ))
+
+        openai_key = os.getenv("OPENAI_API_KEY")
+        if openai_key:
+            providers.append(ProviderConfig(
+                name="openai_compatible",
+                api_key=openai_key,
+                base_url=os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
+                default_model=os.getenv("OPENAI_MODEL", os.getenv("LLM_MODEL", "gpt-4o-mini")),
+                embedding_model=os.getenv("EMBEDDING_MODEL", "text-embedding-3-small"),
+            ))
+
+        return providers
+
+    def _client_for(self, provider: ProviderConfig) -> OpenAI:
+        return OpenAI(api_key=provider.api_key, base_url=provider.base_url)
+
+    def _model_for(self, provider: ProviderConfig, requested: Optional[str]) -> str:
+        return requested or provider.default_model
+
+    async def health(self) -> dict:
+        if not self.providers:
+            return {
+                "available": False,
+                "provider": "none",
+                "error": "No remote provider key configured. Set OPENROUTER_API_KEY, GEMINI_API_KEY, GROQ_API_KEY, HF_TOKEN or OPENAI_API_KEY.",
+                "models": [],
+            }
+
+        checks = []
+        for provider in self.providers:
+            try:
+                client = self._client_for(provider)
+                response = client.chat.completions.create(
+                    model=provider.default_model,
+                    messages=[{"role": "user", "content": "ping"}],
+                    max_tokens=1,
+                    temperature=0,
+                )
+                checks.append({"provider": provider.name, "available": True, "model": provider.default_model})
+                self.provider_name = provider.name
+                self.default_model = provider.default_model
+                self.client = client
+                return {
+                    "available": True,
+                    "provider": provider.name,
+                    "models": [p.default_model for p in self.providers],
+                    "default": provider.default_model,
+                    "checks": checks,
+                }
+            except Exception as exc:
+                checks.append({"provider": provider.name, "available": False, "model": provider.default_model, "error": str(exc)})
+
+        return {
+            "available": False,
+            "provider": "configured_but_unavailable",
+            "models": [p.default_model for p in self.providers],
+            "checks": checks,
+        }
+
+    async def chat(self, messages: list, *, model=None, temperature=0.7, max_tokens=4096) -> str:
+        last_error: Exception | None = None
+        for provider in self.providers:
+            try:
+                client = self._client_for(provider)
+                response = client.chat.completions.create(
+                    model=self._model_for(provider, model),
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    stream=False,
+                )
+                self.provider_name = provider.name
+                self.default_model = self._model_for(provider, model)
+                self.client = client
+                return response.choices[0].message.content or ""
+            except Exception as exc:
+                last_error = exc
+                continue
+        raise RuntimeError(f"No configured model provider succeeded: {last_error}")
+
+    async def stream_chat(self, messages: list, *, model=None, temperature=0.7, max_tokens=4096) -> AsyncIterator[str]:
+        last_error: Exception | None = None
+        for provider in self.providers:
+            try:
+                client = self._client_for(provider)
+                response = client.chat.completions.create(
+                    model=self._model_for(provider, model),
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    stream=True,
+                )
+                self.provider_name = provider.name
+                self.default_model = self._model_for(provider, model)
+                self.client = client
+                for chunk in response:
+                    if chunk.choices and chunk.choices[0].delta.content:
+                        yield chunk.choices[0].delta.content
+                return
+            except Exception as exc:
+                last_error = exc
+                continue
+        raise RuntimeError(f"No configured streaming model provider succeeded: {last_error}")
+
+    async def embed(self, text: str, model: str = "text-embedding-3-small") -> list[float]:
+        for provider in self.providers:
+            embedding_model = provider.embedding_model or os.getenv("EMBEDDING_MODEL")
+            if not embedding_model:
+                continue
+            try:
+                client = self._client_for(provider)
+                response = client.embeddings.create(input=[text], model=embedding_model or model)
+                return response.data[0].embedding
+            except Exception:
+                continue
+        return []

models/ollama_client.py

@@ -0,0 +1,79 @@
+"""
+ollama_client.py — Client Ollama con auto-discovery modelli
+"""
+import httpx
+from typing import Optional, AsyncIterator
+
+OLLAMA_BASE = "http://localhost:11434"
+DEFAULT_MODEL = "qwen2.5-coder:7b"
+FALLBACK_MODELS = ["gemma3:4b", "phi4-mini", "llama3.2:3b", "mistral:7b", "llama3:8b"]
+
+class OllamaClient:
+    def __init__(self, base_url: str = OLLAMA_BASE):
+        self.base = base_url.rstrip("/")
+        self.default_model = DEFAULT_MODEL
+        self._available_models: list[str] = []
+
+    async def health(self) -> dict:
+        try:
+            async with httpx.AsyncClient(timeout=3) as c:
+                r = await c.get(f"{self.base}/api/tags")
+                models = [m["name"] for m in r.json().get("models", [])]
+                self._available_models = models
+                # Pick best default from what's installed
+                for m in [DEFAULT_MODEL] + FALLBACK_MODELS:
+                    if any(m in installed for installed in models):
+                        self.default_model = m
+                        break
+                return {"available": True, "models": models, "default": self.default_model}
+        except Exception as e:
+            return {"available": False, "models": [], "error": str(e)}
+
+    def _resolve_model(self, model: Optional[str]) -> str:
+        if model and model in self._available_models:
+            return model
+        return self.default_model
+
+    async def chat(self, messages: list, *, model=None, temperature=0.7, max_tokens=4096) -> str:
+        payload = {
+            "model": self._resolve_model(model),
+            "messages": messages,
+            "stream": False,
+            "options": {"temperature": temperature, "num_predict": max_tokens},
+        }
+        async with httpx.AsyncClient(timeout=120) as c:
+            r = await c.post(f"{self.base}/api/chat", json=payload)
+            r.raise_for_status()
+            return r.json().get("message", {}).get("content", "")
+
+    async def stream_chat(self, messages: list, *, model=None, temperature=0.7, max_tokens=4096) -> AsyncIterator[str]:
+        import json as _json
+        payload = {
+            "model": self._resolve_model(model),
+            "messages": messages,
+            "stream": True,
+            "options": {"temperature": temperature, "num_predict": max_tokens},
+        }
+        async with httpx.AsyncClient(timeout=180) as c:
+            async with c.stream("POST", f"{self.base}/api/chat", json=payload) as resp:
+                async for line in resp.aiter_lines():
+                    if not line:
+                        continue
+                    try:
+                        data = _json.loads(line)
+                        chunk = data.get("message", {}).get("content", "")
+                        if chunk:
+                            yield chunk
+                        if data.get("done"):
+                            break
+                    except Exception:
+                        continue
+
+    async def embed(self, text: str, model: str = "mxbai-embed-large") -> list[float]:
+        try:
+            async with httpx.AsyncClient(timeout=30) as c:
+                r = await c.post(f"{self.base}/api/embed", json={"model": model, "input": text})
+                r.raise_for_status()
+                return r.json().get("embeddings", [[]])[0]
+        except Exception:
+            return []

package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@workspace/agente-ai",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite --config vite.config.ts --host 0.0.0.0",
+    "build": "vite build --config vite.config.ts",
+    "serve": "vite preview --config vite.config.ts --host 0.0.0.0",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "build:pages": "vite build --config vite.gh-pages.config.ts"
+  },
+  "devDependencies": {
+    "@replit/vite-plugin-cartographer": "catalog:",
+    "@replit/vite-plugin-dev-banner": "catalog:",
+    "@replit/vite-plugin-runtime-error-modal": "catalog:",
+
+    "@tailwindcss/vite": "catalog:",
+    "@types/node": "catalog:",
+    "@types/react": "catalog:",
+    "@types/react-dom": "catalog:",
+    "@vitejs/plugin-react": "catalog:",
+
+    "react": "catalog:",
+    "react-dom": "catalog:",
+    "tailwindcss": "catalog:",
+    "vite": "catalog:",
+
+    "@types/qrcode": "^1.5.5",
+    "highlight.js": "^11.11.1",
+    "jszip": "^3.10.1",
+    "katex": "^0.16.21",
+    "mammoth": "^1.9.0",
+    "mermaid": "^11.4.1",
+    "pdfjs-dist": "^4.10.38",
+    "qrcode": "^1.5.4",
+    "react-markdown": "^10.1.0",
+    "rehype-highlight": "^7.0.2",
+    "remark-gfm": "^4.0.1",
+    "tw-animate-css": "^1.4.0",
+    "xlsx": "^0.18.5"
+  }
+}

requirements.txt

@@ -5,4 +5,7 @@ pydantic>=2.0.0
 python-multipart>=0.0.9
 aiofiles>=23.0.0
 openai>=1.0.0
-supabase>=2.0.0
+supabase>=2.5.0,<3.0.0
+smolagents[litellm]>=1.14.0
+litellm>=1.40.0
+huggingface_hub>=0.24.0

start.py

@@ -0,0 +1,6 @@
+import os, sys
+port = int(os.environ.get('PORT', '7860'))
+print(f'START: PORT={port}', flush=True)
+
+import uvicorn
+uvicorn.run('main:app', host='0.0.0.0', port=port, log_level='info', access_log=True)

tools/content_cleaner.py

@@ -0,0 +1,27 @@
+"""content_cleaner.py — Pulisce e struttura il testo per il modello."""
+import re
+from typing import Optional
+NOISE_PATTERNS=["cookie","accept all cookies","privacy policy","terms of service","all rights reserved","subscribe","follow us on","share this article"]
+
+def remove_noise(text:str)->str:
+  lines=text.split("\n"); cleaned=[]
+  for line in lines:
+      ll=line.lower().strip()
+      if len(ll)<4: continue
+      if any(p in ll for p in NOISE_PATTERNS): continue
+      if line.count("|")>5: continue
+      cleaned.append(line)
+  return "\n".join(cleaned)
+
+def extract_key_paragraphs(text:str,query:str,max_paragraphs:int=6)->list[str]:
+  q_words=set(w.lower() for w in re.split(r"\W+",query) if len(w)>3)
+  pars=[p.strip() for p in re.split(r"\n{2,}",text) if len(p.strip())>60]
+  def rel(p): pl=p.lower(); return sum(1 for w in q_words if w in pl)/max(1,len(q_words))
+  return sorted(pars,key=rel,reverse=True)[:max_paragraphs]
+
+def clean_and_structure(text:str,query:Optional[str]=None,max_chars:int=4000)->dict:
+  text=remove_noise(text)
+  pars=extract_key_paragraphs(text,query) if query else [text]
+  structured="\n\n".join(pars)
+  if len(structured)>max_chars: structured=structured[:max_chars]+"\n[troncato]"
+  return {"content":structured,"chars":len(structured),"words":len(structured.split()),"query_used":query}

tools/diff_checker.py

@@ -0,0 +1,20 @@
+"""diff_checker.py — Genera e valida diff tra versioni di file."""
+import difflib, re
+from pathlib import Path
+
+def generate_diff(original:str,modified:str,filename:str="file")->dict:
+  a=original.splitlines(keepends=True); b=modified.splitlines(keepends=True)
+  lines=list(difflib.unified_diff(a,b,fromfile=f"a/{filename}",tofile=f"b/{filename}",lineterm=""))
+  diff="\n".join(lines)
+  added=sum(1 for l in lines if l.startswith("+") and not l.startswith("+++"))
+  removed=sum(1 for l in lines if l.startswith("-") and not l.startswith("---"))
+  return {"diff":diff,"added":added,"removed":removed,"has_changes":len(lines)>0}
+
+def validate_python(code:str)->dict:
+  import ast
+  try: ast.parse(code); return {"valid":True,"errors":[]}
+  except SyntaxError as e: return {"valid":False,"errors":[f"L{e.lineno}: {e.msg}"]}
+
+def file_diff(path_a:str,path_b:str)->dict:
+  try: return generate_diff(Path(path_a).read_text(encoding="utf-8"),Path(path_b).read_text(encoding="utf-8"),Path(path_a).name)
+  except Exception as e: return {"error":str(e),"diff":""}

tools/file_editor.py

@@ -0,0 +1,33 @@
+"""file_editor.py — Applica modifiche a file con backup automatico."""
+import shutil
+from pathlib import Path
+from datetime import datetime
+BACKUP_DIR=Path(".agent_backups")
+
+def _backup(filepath:str)->str:
+  BACKUP_DIR.mkdir(exist_ok=True); src=Path(filepath)
+  if not src.exists(): return ""
+  ts=datetime.now().strftime("%Y%m%d_%H%M%S"); bk=BACKUP_DIR/f"{src.stem}_{ts}{src.suffix}"
+  shutil.copy2(src,bk); return str(bk)
+
+def apply_replace(filepath:str,old_code:str,new_code:str,backup:bool=True)->dict:
+  try:
+      p=Path(filepath)
+      if not p.exists(): return {"success":False,"error":"File non trovato"}
+      c=p.read_text(encoding="utf-8")
+      if old_code not in c: return {"success":False,"error":"Blocco non trovato"}
+      bk=_backup(filepath) if backup else ""
+      p.write_text(c.replace(old_code,new_code,1),encoding="utf-8")
+      return {"success":True,"backup":bk}
+  except Exception as e: return {"success":False,"error":str(e)}
+
+def write_file(filepath:str,content:str,backup:bool=True)->dict:
+  try:
+      p=Path(filepath); bk=_backup(filepath) if backup and p.exists() else ""
+      p.parent.mkdir(parents=True,exist_ok=True); p.write_text(content,encoding="utf-8")
+      return {"success":True,"backup":bk,"path":filepath}
+  except Exception as e: return {"success":False,"error":str(e)}
+
+def list_backups()->list[dict]:
+  if not BACKUP_DIR.exists(): return []
+  return [{"path":str(b),"name":b.name,"size":b.stat().st_size} for b in sorted(BACKUP_DIR.iterdir(),reverse=True)[:20]]

tools/ranking.py

@@ -0,0 +1,32 @@
+"""ranking.py — Ordina risultati web per rilevanza + qualità."""
+import re
+from typing import Optional
+
+def tfidf_score(query:str,document:str)->float:
+  terms=[w.lower() for w in re.split(r"\W+",query) if len(w)>2]
+  words=re.split(r"\W+",document.lower()); n=max(1,len(words)); score=0.0
+  for t in terms: score+=words.count(t)/n
+  return score
+
+def quality_score(result:dict)->float:
+  w={"StackOverflow":0.95,"HackerNews":0.80,"DDG":0.70}
+  base=w.get(result.get("source",""),0.60)
+  bonus=min(0.2,len(result.get("snippet",""))/1000)+(0.1 if result.get("answered") else 0)
+  return min(1.0,base+bonus)
+
+def rank_results(results:list[dict],query:str,top_k:int=6)->list[dict]:
+  for r in results:
+      r["_r"]=tfidf_score(query,f"{r.get('title','')} {r.get('snippet','')}")
+      r["_q"]=quality_score(r); r["_s"]=0.6*r["_r"]+0.4*r["_q"]
+  ranked=sorted(results,key=lambda x:x["_s"],reverse=True)[:top_k]
+  for r in ranked: [r.pop(k,None) for k in ["_r","_q","_s"]]
+  return ranked
+
+def format_for_llm(results:list[dict],query:str)->str:
+  if not results: return f"Nessun risultato per: {query}"
+  lines=[f"Risultati: **{query}**\n"]
+  for i,r in enumerate(results,1):
+      lines.append(f"{i}. **{r.get('title','')[:80]}** [{r.get('source','Web')}]")
+      if r.get("snippet"): lines.append(f"   {r['snippet'][:200]}")
+      if r.get("url"): lines.append(f"   {r['url']}"); lines.append("")
+  return "\n".join(lines)

tools/registry.py

@@ -0,0 +1,193 @@
+"""
+registry.py — Tool Registry
+Ogni tool ha: goal, required_inputs, risk_level, fallbacks, _fn.
+"""
+import httpx
+import asyncio
+import subprocess
+import tempfile
+import os
+import sys
+
+# ─── Tool functions ────────────────────────────────────────
+
+async def _web_search(query: str, max_results: int = 5) -> dict:
+    headers = {"User-Agent": "Mozilla/5.0 (compatible; AgentBot/1.0)"}
+    results = []
+    # 1. DuckDuckGo Instant Answers
+    try:
+        async with httpx.AsyncClient(timeout=10, follow_redirects=True) as c:
+            r = await c.get(
+                f"https://api.duckduckgo.com/?q={httpx.QueryParams({'q': query}).get('q')}&format=json&no_html=1&skip_disambig=1",
+                headers=headers
+            )
+            data = r.json()
+            if data.get("AbstractText"):
+                results.append({
+                    "title": data.get("Heading", query),
+                    "snippet": data["AbstractText"][:400],
+                    "url": data.get("AbstractURL", "")
+                })
+            for t in data.get("RelatedTopics", [])[:max_results]:
+                if isinstance(t, dict) and t.get("Text"):
+                    results.append({
+                        "title": t.get("Text", "")[:80],
+                        "snippet": t.get("Text", "")[:300],
+                        "url": t.get("FirstURL", "")
+                    })
+    except Exception:
+        pass
+
+    # 2. Se non abbastanza risultati, prova SearXNG pubblico
+    if len(results) < 2:
+        try:
+            async with httpx.AsyncClient(timeout=10) as c:
+                r = await c.get(
+                    f"https://searx.be/search?q={query}&format=json&categories=general",
+                    headers=headers
+                )
+                data = r.json()
+                for item in data.get("results", [])[:max_results]:
+                    results.append({
+                        "title": item.get("title", ""),
+                        "snippet": item.get("content", "")[:300],
+                        "url": item.get("url", "")
+                    })
+        except Exception:
+            pass
+
+    return {"query": query, "results": results[:max_results]}
+
+async def _read_page(url: str) -> dict:
+    try:
+        async with httpx.AsyncClient(timeout=15, follow_redirects=True) as c:
+            r = await c.get(url, headers={"User-Agent": "Mozilla/5.0"})
+            text = r.text
+            # Strip HTML tags
+            import re
+            clean = re.sub(r'<[^>]+>', ' ', text)
+            clean = re.sub(r'\s+', ' ', clean).strip()
+            return {"url": url, "content": clean[:5000], "status": r.status_code}
+    except Exception as e:
+        return {"url": url, "content": "", "error": str(e)}
+
+async def _get_weather(city: str) -> dict:
+    try:
+        async with httpx.AsyncClient(timeout=8) as c:
+            geo = await c.get(f"https://geocoding-api.open-meteo.com/v1/search?name={city}&count=1&language=it&format=json")
+            results = geo.json().get("results", [])
+            if not results:
+                return {"error": f"Città '{city}' non trovata"}
+            loc = results[0]
+            weather = await c.get(
+                f"https://api.open-meteo.com/v1/forecast?latitude={loc['latitude']}&longitude={loc['longitude']}"
+                f"&current=temperature_2m,weather_code,wind_speed_10m&timezone=auto"
+            )
+            w = weather.json().get("current", {})
+            return {"city": loc["name"], "country": loc.get("country", ""), "temp_c": w.get("temperature_2m"), "wind_kmh": w.get("wind_speed_10m"), "code": w.get("weather_code")}
+    except Exception as e:
+        return {"error": str(e)}
+
+async def _calculate(expression: str) -> dict:
+    try:
+        import ast, operator
+        allowed = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv, ast.Pow: operator.pow, ast.USub: operator.neg}
+        def eval_node(node):
+            if isinstance(node, ast.Constant): return node.value
+            if isinstance(node, ast.BinOp): return allowed[type(node.op)](eval_node(node.left), eval_node(node.right))
+            if isinstance(node, ast.UnaryOp): return allowed[type(node.op)](eval_node(node.operand))
+            raise ValueError("Operazione non supportata")
+        tree = ast.parse(expression, mode='eval')
+        result = eval_node(tree.body)
+        return {"expression": expression, "result": result}
+    except Exception as e:
+        return {"expression": expression, "error": str(e)}
+
+async def _run_python(code: str) -> dict:
+    """Esegue codice Python reale sul server in sandbox con timeout."""
+    # Sandbox: blocca import pericolosi
+    forbidden = ["os.system", "subprocess", "shutil.rmtree", "__import__('os')", "open('/etc"]
+    for f in forbidden:
+        if f in code:
+            return {"error": f"Operazione non permessa: {f}", "stdout": "", "returncode": -1}
+
+    with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode="w", encoding="utf-8") as fp:
+        fp.write(code)
+        path = fp.name
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            sys.executable, path,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        try:
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=15.0)
+        except asyncio.TimeoutError:
+            proc.kill()
+            return {"error": "Timeout 15s superato", "stdout": "", "returncode": -1}
+        return {
+            "stdout": stdout.decode("utf-8", errors="replace")[:3000],
+            "stderr": stderr.decode("utf-8", errors="replace")[:500],
+            "returncode": proc.returncode,
+        }
+    finally:
+        try:
+            os.unlink(path)
+        except Exception:
+            pass
+
+
+# ─── Registry ─────────────────────────────────────────────
+
+TOOL_REGISTRY: dict[str, dict] = {
+    "web_search": {
+        "name": "web_search",
+        "goal": "Cerca informazioni aggiornate sul web",
+        "description": "Esegue ricerca DuckDuckGo e restituisce risultati rilevanti",
+        "required_inputs": ["query"],
+        "optional_inputs": {"max_results": 5},
+        "risk_level": "low",
+        "fallbacks": ["direct_response"],
+        "_fn": _web_search,
+    },
+    "read_page": {
+        "name": "read_page",
+        "goal": "Legge il contenuto di una pagina web",
+        "description": "Scarica e pulisce il testo di una URL",
+        "required_inputs": ["url"],
+        "optional_inputs": {},
+        "risk_level": "low",
+        "fallbacks": ["web_search"],
+        "_fn": _read_page,
+    },
+    "get_weather": {
+        "name": "get_weather",
+        "goal": "Ottieni meteo attuale per una città",
+        "description": "Usa Open-Meteo (gratuito, no API key) per meteo in tempo reale",
+        "required_inputs": ["city"],
+        "optional_inputs": {},
+        "risk_level": "low",
+        "fallbacks": [],
+        "_fn": _get_weather,
+    },
+    "calculate": {
+        "name": "calculate",
+        "goal": "Calcola espressioni matematiche in modo sicuro",
+        "description": "Valuta espressioni matematiche senza exec() — solo operatori sicuri",
+        "required_inputs": ["expression"],
+        "optional_inputs": {},
+        "risk_level": "low",
+        "fallbacks": [],
+        "_fn": _calculate,
+    },
+    "run_python": {
+        "name": "run_python",
+        "goal": "Esegui codice Python reale sul server",
+        "description": "Esegue Python vero: calcoli, data processing, file I/O, librerie stdlib. Timeout 15s.",
+        "required_inputs": ["code"],
+        "optional_inputs": {},
+        "risk_level": "medium",
+        "fallbacks": [],
+        "_fn": _run_python,
+    },
+}

tools/repo_reader.py

@@ -0,0 +1,29 @@
+"""repo_reader.py — Legge struttura e file di un repository locale."""
+from pathlib import Path
+SKIP={'.git','node_modules','__pycache__','.venv','dist','build'}
+TEXT={'.py','.ts','.tsx','.js','.jsx','.html','.css','.md','.json','.yaml','.yml','.toml','.txt','.sh'}
+
+def read_tree(root:str,max_files:int=80)->dict:
+  rp=Path(root)
+  if not rp.exists(): return {"error":f"Path non trovato: {root}","files":[]}
+  files=[]
+  for p in sorted(rp.rglob("*")):
+      if len(files)>=max_files: break
+      if any(s in p.parts for s in SKIP): continue
+      if p.is_file():
+          rel=str(p.relative_to(rp)); sz=p.stat().st_size
+          files.append({"path":rel,"size":sz,"type":"text" if p.suffix.lower() in TEXT else "binary","ext":p.suffix})
+  return {"root":root,"total_files":len(files),"files":files}
+
+def read_file(root:str,filepath:str)->dict:
+  full=Path(root)/filepath
+  if not full.exists(): return {"error":f"Non trovato: {filepath}","content":""}
+  if full.stat().st_size>50000: return {"error":"File troppo grande","content":""}
+  if full.suffix.lower() not in TEXT and full.suffix!="": return {"error":"File binario","content":""}
+  try:
+      c=full.read_text(encoding="utf-8",errors="replace")
+      return {"path":filepath,"content":c,"lines":c.count("\n")+1,"size":len(c)}
+  except Exception as e: return {"error":str(e),"content":""}
+
+def read_files_batch(root:str,paths:list[str])->list[dict]:
+  return [read_file(root,p) for p in paths[:10]]

tools/web_fetch.py

@@ -0,0 +1,29 @@
+"""web_fetch.py — Scarica + pulisce una pagina web. NON restituisce HTML grezzo."""
+import httpx, re
+from urllib.parse import urlparse
+USER_AGENT="Mozilla/5.0 (compatible; AgenteAI/2.0)"
+MAX_CONTENT=6000
+
+def _clean_html(html:str)->str:
+  html=re.sub(r"<(script|style|nav|footer|header|noscript|aside)[^>]*>.*?</\1>"," ",html,flags=re.S|re.I)
+  text=re.sub(r"<[^>]+>"," ",html)
+  text=re.sub(r"[ \t]+"," ",text)
+  text=re.sub(r"\n{3,}","\n\n",text)
+  return text.strip()
+
+def _extract_meta(html:str)->dict:
+  t=re.search(r"<title[^>]*>([^<]+)</title>",html,re.I)
+  d=re.search(r'<meta[^>]+name=["\'\']description["\'\'][^>]+content=["\'\']([^"\'\']+ )["\'\']',html,re.I)
+  return {"title":t.group(1).strip() if t else "","description":d.group(1).strip() if d else ""}
+
+async def fetch_page(url:str, max_chars:int=MAX_CONTENT)->dict:
+  try:
+      parsed=urlparse(url)
+      if parsed.scheme not in ("http","https"): return {"url":url,"error":"Schema non supportato","content":""}
+      async with httpx.AsyncClient(timeout=15,follow_redirects=True,headers={"User-Agent":USER_AGENT}) as c:
+          r=await c.get(url)
+          html=r.text; meta=_extract_meta(html); text=_clean_html(html)
+          if len(text)>max_chars: text=text[:max_chars]+"\n[...troncato...]"
+          return {"url":url,"title":meta["title"],"description":meta["description"],"content":text,"status":r.status_code,"chars":len(text)}
+  except httpx.TimeoutException: return {"url":url,"error":"Timeout","content":""}
+  except Exception as e: return {"url":url,"error":str(e),"content":""}

tools/web_search.py

@@ -0,0 +1,58 @@
+"""web_search.py — Pipeline: search → rank → cite"""
+import httpx, re, asyncio
+from urllib.parse import quote_plus
+
+MAX_RESULTS = 8
+
+async def search_ddg(query: str, max_results: int = MAX_RESULTS) -> list[dict]:
+  try:
+      async with httpx.AsyncClient(timeout=8, follow_redirects=True) as c:
+          r = await c.get("https://api.duckduckgo.com/",
+              params={"q": query, "format": "json", "no_html": "1", "skip_disambig": "1"})
+          d = r.json(); results = []
+          if d.get("AbstractText"):
+              results.append({"source":"DDG","title":d.get("Heading",query),"snippet":d["AbstractText"][:400],"url":d.get("AbstractURL",""),"score":1.0})
+          for t in d.get("RelatedTopics",[])[:max_results]:
+              if isinstance(t,dict) and t.get("Text") and t.get("FirstURL"):
+                  results.append({"source":"DDG","title":t["Text"][:80],"snippet":t["Text"][:250],"url":t["FirstURL"],"score":0.7})
+          return results[:max_results]
+  except Exception as e:
+      return [{"source":"DDG","error":str(e),"title":"","snippet":"","url":"","score":0}]
+
+async def search_hackernews(query: str, max_results: int = 5) -> list[dict]:
+  try:
+      async with httpx.AsyncClient(timeout=8) as c:
+          r = await c.get("https://hn.algolia.com/api/v1/search",
+              params={"query":query,"hitsPerPage":max_results,"tags":"story"})
+          return [{"source":"HackerNews","title":h.get("title","")[:100],
+                   "snippet":(h.get("story_text") or "")[:300],
+                   "url":h.get("url") or f"https://news.ycombinator.com/item?id={h.get('objectID','')}",
+                   "score":min(1.0,(h.get("points",0) or 0)/500)} for h in r.json().get("hits",[]) if h.get("title")]
+  except: return []
+
+async def search_stackoverflow(query: str, max_results: int = 4) -> list[dict]:
+  import re as _re
+  try:
+      async with httpx.AsyncClient(timeout=8) as c:
+          r = await c.get("https://api.stackexchange.com/2.3/search/advanced",
+              params={"q":query,"site":"stackoverflow","pagesize":max_results,"order":"desc","sort":"relevance","filter":"withbody"})
+          return [{"source":"StackOverflow","title":it.get("title","")[:100],
+                   "snippet":_re.sub(r"<[^>]+>"," ",it.get("body",""))[:250],
+                   "url":it.get("link",""),"score":min(1.0,(it.get("score",0) or 0)/100),
+                   "answered":it.get("is_answered",False)} for it in r.json().get("items",[])]
+  except: return []
+
+async def web_search(query:str, focus:str="general", max_results:int=6) -> dict:
+  tasks = [search_ddg(query, max_results)]
+  if focus in ("technical","code"): tasks.append(search_stackoverflow(query,4))
+  if focus in ("news","general","technical"): tasks.append(search_hackernews(query,4))
+  all_results=[]
+  for batch in await asyncio.gather(*tasks, return_exceptions=True):
+      if isinstance(batch,list): all_results.extend(batch)
+  seen,ranked=set(),[]
+  for r in sorted(all_results,key=lambda x:x.get("score",0),reverse=True):
+      url=r.get("url","")
+      if url and url not in seen: seen.add(url); ranked.append(r)
+      elif not url: ranked.append(r)
+  ranked=ranked[:max_results]
+  return {"query":query,"focus":focus,"total":len(ranked),"results":ranked,"sources":list({r["source"] for r in ranked})}

tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["src/**/*"],
+  "exclude": [
+    "node_modules", "build", "dist", "**/*.test.ts",
+    "src/components/ui",
+    "src/hooks/use-toast.ts",
+    "src/pages/not-found.tsx",
+    "src/lib/utils.ts"
+  ],
+  "compilerOptions": {
+    "noEmit": true,
+    "jsx": "preserve",
+    "lib": ["esnext", "dom", "dom.iterable"],
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "moduleResolution": "bundler",
+    "types": ["node", "vite/client"],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

vite.config.ts

@@ -0,0 +1,83 @@
+import { defineConfig } from "vite";
+import path from "node:path";
+
+export default defineConfig({
+  root: ".",
+
+  server: {
+    host: "0.0.0.0",
+    port: 5174,
+    strictPort: false,
+    open: false,
+    cors: true,
+
+    fs: {
+      strict: false,
+      allow: [
+        path.resolve(__dirname),
+      ],
+    },
+
+    proxy: {
+      "/api": {
+        target: "http://localhost:8000",
+        changeOrigin: true,
+        secure: false,
+      },
+
+      "/ws": {
+        target: "ws://localhost:8000",
+        ws: true,
+        changeOrigin: true,
+      },
+    },
+  },
+
+  preview: {
+    host: "0.0.0.0",
+    port: 4174,
+  },
+
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+      "@backend": path.resolve(__dirname, "./"),
+    },
+  },
+
+  build: {
+    target: "es2022",
+
+    outDir: "dist",
+
+    emptyOutDir: true,
+
+    sourcemap: false,
+
+    minify: "esbuild",
+
+    chunkSizeWarningLimit: 1200,
+
+    rollupOptions: {
+      output: {
+        manualChunks: {
+          vendor: [
+            "react",
+            "react-dom",
+          ],
+        },
+      },
+    },
+  },
+
+  optimizeDeps: {
+    exclude: [
+      "@xenova/transformers",
+      "@mlc-ai/web-llm",
+    ],
+  },
+
+  define: {
+    __DEV__: JSON.stringify(process.env.NODE_ENV !== "production"),
+  },
+});