@hiperplano/aluy-cli 1.0.0-rc.9 → 1.0.0-rc.91

package/README.md

@@ -41,7 +41,7 @@ opcionais. Funciona em **Linux, macOS e Windows** — o terminal recomendado é
 aluy                          # sessão interativa (TUI)
 aluy "refatore o módulo X"    # dá um objetivo direto e acompanha o agente trabalhar
 aluy -p "liste os TODOs"      # modo headless (one-shot), ideal p/ scripts/CI
-aluy --resume <id>            # retoma uma conversa anterior (o id aparece ao sair)
+aluy --resume <id|nome>       # retoma uma conversa anterior (id ao sair, ou o nome do /rename)
 aluy --continue               # retoma a sessão mais recente deste diretório
 ```
 
@@ -69,6 +69,7 @@ Dentro da sessão, **slash-commands** controlam tudo sem sair do fluxo:
   Filesystem, Memory, …).
 - **Complementos opcionais** (modo turbo) — memória persistente, modelos locais via
   Ollama e gestão de contexto, instaláveis no onboard ou depois com `aluy bootstrap`.
+  Guia completo (instalação, problemas comuns, instalação manual): [docs/turbo.md](docs/turbo.md).
 
 ## Configuração
 

package/assets/mem0/aluy-mem0-server.py

@@ -0,0 +1,483 @@
+#!/usr/bin/env python3
+"""
+aluy-mem0-server — servidor HTTP stdlib para o Mem0 OSS local.
+
+EST-1138 · ADR-0123 §8-emenda E2/E3 · C4.
+Implementa EXATAMENTE os endpoints que `mem0-memory-engine.ts` chama.
+
+Bind: 127.0.0.1 (loopback, CA-G2-6), porta via --port (default 11435).
+Uma instância de Memory() — criada UMA vez no boot.
+
+Endpoints:
+  GET  /health              → 200 {"ok":true}
+  POST /v1/memories/        → mem.add(...)          → {"id":"..."}
+  GET  /v1/memories/?...    → mem.search(...)       → {"results":[...]}
+  GET  /v1/users/           → lista scopes          → {"users":[...]}
+  DELETE /v1/memories/?...  → mem.delete_all(...)   → 204
+
+Dependências: mem0ai, chromadb (já no venv provisionado).
+Embedder: nomic-embed-text via Ollama em 127.0.0.1:11434.
+Store: chromadb em ~/.aluy/memory.
+"""
+
+import argparse
+import json
+import os
+import signal
+import sys
+import traceback
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from pathlib import Path
+from socketserver import ThreadingMixIn
+from typing import Any
+
+# ── Constantes ────────────────────────────────────────────────────────────
+DEFAULT_PORT = 11435
+DEFAULT_HOST = "127.0.0.1"
+ALUY_MEMORY_DIR = os.path.expanduser("~/.aluy/memory")
+OLLAMA_BASE_URL = "http://127.0.0.1:11434"
+# Embedder CONFIG-DRIVEN: o boot passa `ALUY_MEM0_EMBEDDER` (escolhido na instalação); default
+# bge-m3 (multilíngue, forte). Trocar o embedder muda a DIMENSÃO do vetor (bge-m3/mxbai=1024,
+# nomic=768) ⇒ o store chromadb antigo fica incompatível e o self-heal o reseta no 1º boot.
+EMBEDDER_MODEL = os.environ.get("ALUY_MEM0_EMBEDDER", "bge-m3").strip() or "bge-m3"
+# LLM local p/ extração de fatos (mem0 add infer=True). SEM isto o mem0 cai no
+# default OpenAI → 401. Local-first: tudo via Ollama loopback, zero credencial.
+LLM_MODEL = "qwen2.5:0.5b"
+USERS_FILE = os.path.join(ALUY_MEMORY_DIR, "aluy_users.json")
+
+
+# ── Mem0 config ───────────────────────────────────────────────────────────
+def _build_mem0_config() -> dict[str, Any]:
+    """Monta a config do mem0ai com paths locais absolutos."""
+    return {
+        # history em ~/.aluy/memory (não no default ~/.mem0): TODO o estado do mem0 fica num
+        # único lugar ⇒ limpar ~/.aluy/memory no self-heal recria TUDO fresco. Antes o history
+        # ia p/ ~/.mem0/history.db e, de uma versão antiga, dava `no such column: prev_value`.
+        "history_db_path": os.path.join(ALUY_MEMORY_DIR, "history.db"),
+        "vector_store": {
+            "provider": "chroma",
+            "config": {
+                "collection_name": "mem0",
+                "path": ALUY_MEMORY_DIR,
+            },
+        },
+        "embedder": {
+            "provider": "ollama",
+            "config": {
+                "model": EMBEDDER_MODEL,
+                "ollama_base_url": OLLAMA_BASE_URL,
+            },
+        },
+        "llm": {
+            "provider": "ollama",
+            "config": {
+                "model": LLM_MODEL,
+                "ollama_base_url": OLLAMA_BASE_URL,
+            },
+        },
+    }
+
+
+# ── Tracking de usuários ──────────────────────────────────────────────────
+def _load_users() -> dict[str, dict[str, Any]]:
+    """Carrega o tracking de usuários do disco (JSON simples)."""
+    try:
+        if os.path.exists(USERS_FILE):
+            with open(USERS_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+    except Exception:
+        pass
+    return {}
+
+
+def _save_users(users: dict[str, dict[str, Any]]) -> None:
+    """Persiste o tracking de usuários."""
+    os.makedirs(ALUY_MEMORY_DIR, mode=0o700, exist_ok=True)
+    tmp = USERS_FILE + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(users, f)
+    os.replace(tmp, USERS_FILE)
+    os.chmod(USERS_FILE, 0o600)
+
+
+def _track_user(users: dict[str, dict[str, Any]], user_id: str) -> None:
+    """Registra um user_id se ainda não existe no tracking."""
+    if user_id not in users:
+        users[user_id] = {"created_at": None}
+        _save_users(users)
+
+
+def _untrack_user(users: dict[str, dict[str, Any]], user_id: str) -> None:
+    """Remove um user_id do tracking."""
+    if user_id in users:
+        del users[user_id]
+        _save_users(users)
+
+
+# ── Handler HTTP ──────────────────────────────────────────────────────────
+class Mem0Handler(BaseHTTPRequestHandler):
+    """
+    Handler HTTP que traduz requests REST ↔ chamadas ao Memory() do mem0ai.
+    """
+
+    # Injectados pelo servidor (antes de start).
+    memory: Any = None
+    users: dict[str, dict[str, Any]] = {}
+
+    # ── Helpers ────────────────────────────────────────────────────────
+
+    def _send_json(self, status: int, body: Any) -> None:
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+        self.wfile.write(json.dumps(body, default=str).encode("utf-8"))
+
+    def _send_no_content(self) -> None:
+        self.send_response(204)
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.end_headers()
+
+    def _read_body(self) -> dict[str, Any]:
+        length = int(self.headers.get("Content-Length", "0"))
+        if length == 0:
+            return {}
+        raw = self.rfile.read(length)
+        return json.loads(raw)
+
+    def _parse_qs(self) -> dict[str, str]:
+        """Extrai query params da URL (simples, sem dependência)."""
+        path = self.path
+        qs: dict[str, str] = {}
+        if "?" in path:
+            query_string = path.split("?", 1)[1]
+            for pair in query_string.split("&"):
+                if "=" in pair:
+                    k, v = pair.split("=", 1)
+                    qs[k] = v
+                elif pair:
+                    qs[pair] = ""
+        return qs
+
+    # ── Routing ────────────────────────────────────────────────────────
+
+    def _route_path(self) -> str:
+        """Devolve o path sem query string."""
+        return self.path.split("?", 1)[0].rstrip("/")
+
+    def do_GET(self) -> None:
+        path = self._route_path()
+        try:
+            if path == "/health":
+                self._handle_health()
+            elif path == "/v1/memories":
+                self._handle_search()
+            elif path == "/v1/users":
+                self._handle_list_users()
+            else:
+                self._send_json(404, {"error": "not found"})
+        except Exception:
+            traceback.print_exc()
+            self._send_json(500, {"error": traceback.format_exc()})
+
+    def do_POST(self) -> None:
+        path = self._route_path()
+        try:
+            if path == "/v1/memories":
+                self._handle_add()
+            else:
+                self._send_json(404, {"error": "not found"})
+        except Exception:
+            traceback.print_exc()
+            self._send_json(500, {"error": traceback.format_exc()})
+
+    def do_DELETE(self) -> None:
+        path = self._route_path()
+        try:
+            if path == "/v1/memories":
+                self._handle_delete()
+            else:
+                self._send_json(404, {"error": "not found"})
+        except Exception:
+            traceback.print_exc()
+            self._send_json(500, {"error": traceback.format_exc()})
+
+    def do_OPTIONS(self) -> None:
+        self.send_response(200)
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.end_headers()
+
+    # ── Handlers ───────────────────────────────────────────────────────
+
+    def _handle_health(self) -> None:
+        """GET /health → 200 {"ok":true} (handshake do boot)."""
+        self._send_json(200, {"ok": True})
+
+    def _handle_add(self) -> None:
+        """POST /v1/memories/ → mem.add(...) → {"id":"..."}."""
+        body = self._read_body()
+        user_id = body.get("user_id", "default")
+        messages = body.get("messages", [])
+        metadata = body.get("metadata")
+
+        if not messages:
+            self._send_json(400, {"error": "messages é obrigatório"})
+            return
+
+        # infer=False: armazena o conteúdo DIRETO (embed+store), sem extração por LLM.
+        # Semântica da porta MemoryEngine = "guarda o que recebe"; e o judge local
+        # (qwen2.5:0.5b) é fraco demais p/ a extração de fatos do mem0 (retornaria vazio).
+        result = self.memory.add(messages, user_id=user_id, metadata=metadata, infer=False)
+
+        # mem0ai 2.0.7 retorna {"results":[{"id",...}]}; o TS espera {"id": "..."}.
+        first_id = None
+        if isinstance(result, dict):
+            res_list = result.get("results")
+            if isinstance(res_list, list) and res_list:
+                first_id = res_list[0].get("id")
+            else:
+                first_id = result.get("id")
+        elif isinstance(result, list) and result:
+            first_id = result[0].get("id")
+
+        # Track user
+        _track_user(self.users, user_id)
+
+        self._send_json(200, {"id": first_id})
+
+    def _handle_search(self) -> None:
+        """GET /v1/memories/?user_id&query&limit → mem.search(...) → {"results":[...]}."""
+        qs = self._parse_qs()
+        user_id = qs.get("user_id", "default")
+        query = qs.get("query", "")
+        limit = int(qs.get("limit", "10"))
+
+        # mem0ai 2.0.7: entity params via filters=, paginação via top_k= (não user_id/limit).
+        resp = self.memory.search(query, filters={"user_id": user_id}, top_k=limit)
+
+        # mem0ai.search retorna {"results": [...]}
+        results = resp.get("results", []) if isinstance(resp, dict) else []
+
+        self._send_json(200, {"results": results})
+
+    def _handle_list_users(self) -> None:
+        """GET /v1/users/ → lista scopes com memory_count."""
+        # Reconcilia tracking file com o estado real (get_all de cada user).
+        users_list = []
+        for user_id in list(self.users.keys()):
+            try:
+                # mem0ai 2.0.7: get_all usa filters= e retorna {"results": [...]}.
+                all_mems = self.memory.get_all(filters={"user_id": user_id})
+            except Exception:
+                # F100 — erro TRANSITÓRIO no get_all NÃO é "scope vazio". Conflar os dois
+                # (count=0 ⇒ untrack) DESTRÓI o tracking de um scope COM memórias num hiccup
+                # do backend — o scope some da lista (memórias intactas, mas invisíveis) até
+                # o próximo add. CA-MA8: degrada, não destrói estado. Preserva o tracking e
+                # OMITE só desta resposta (reaparece no próximo list bem-sucedido).
+                continue
+
+            if isinstance(all_mems, dict):
+                count = len(all_mems.get("results", []))
+            elif isinstance(all_mems, list):
+                count = len(all_mems)
+            else:
+                count = 0
+
+            created_at = self.users[user_id].get("created_at")
+            entry: dict[str, Any] = {
+                "user_id": user_id,
+                "memory_count": count,
+            }
+            if created_at:
+                entry["created_at"] = created_at
+
+            # Vazio COMPROVADO (get_all OK retornando 0) ⇒ foi deletado: untrack.
+            if count > 0:
+                users_list.append(entry)
+            else:
+                _untrack_user(self.users, user_id)
+
+        self._send_json(200, {"users": users_list})
+
+    def _handle_delete(self) -> None:
+        """DELETE /v1/memories/?user_id=X → mem.delete_all(user_id=X)."""
+        qs = self._parse_qs()
+        user_id = qs.get("user_id", "default")
+
+        self.memory.delete_all(user_id=user_id)
+        _untrack_user(self.users, user_id)
+
+        self._send_no_content()
+
+    # Suprime logs por request (stderr polui a TUI).
+    def log_message(self, format: str, *args: Any) -> None:
+        pass
+
+
+# ── ThreadingHTTPServer ───────────────────────────────────────────────────
+class ThreadingHTTPServer(ThreadingMixIn, HTTPServer):
+    """HTTPServer com thread por request (stdlib apenas)."""
+    daemon_threads = True
+
+
+# ── Main ──────────────────────────────────────────────────────────────────
+EMBEDDER_MARKER = os.path.join(ALUY_MEMORY_DIR, ".embedder")
+
+
+def _migrate_embedder_if_changed() -> None:
+    """Se o embedder mudou desde o último boot (marca em `.embedder` ≠ atual), a dimensão do
+    vetor muda e o store chromadb fica incompatível ⇒ reseta proativamente. Best-effort."""
+    try:
+        prev = None
+        if os.path.exists(EMBEDDER_MARKER):
+            with open(EMBEDDER_MARKER, encoding="utf-8") as fh:
+                prev = fh.read().strip()
+        if prev is not None and prev != EMBEDDER_MODEL:
+            sys.stderr.write(
+                f"aluy-mem0: embedder mudou ({prev} → {EMBEDDER_MODEL}); "
+                "dimensão do vetor difere — resetando store p/ recriar.\n"
+            )
+            _reset_incompatible_stores()
+            os.makedirs(ALUY_MEMORY_DIR, mode=0o700, exist_ok=True)
+    except Exception:  # noqa: BLE001 — migração best-effort, nunca derruba o boot
+        pass
+
+
+def _write_embedder_marker() -> None:
+    """Grava qual embedder gerou os vetores atuais (p/ detectar troca no próximo boot)."""
+    try:
+        os.makedirs(ALUY_MEMORY_DIR, mode=0o700, exist_ok=True)
+        with open(EMBEDDER_MARKER, "w", encoding="utf-8") as fh:
+            fh.write(EMBEDDER_MODEL)
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def _reset_incompatible_stores() -> None:
+    """Move os stores de memória p/ backup, p/ recriar frescos. Chamado quando a versão atual
+    do chromadb/mem0 não lê o store de uma versão anterior (KeyError '_type' no chromadb /
+    sqlite 'no such column' no history). Best-effort — nunca lança. Limpa OS DOIS lugares:
+    `~/.aluy/memory` (chromadb + history novo) E `~/.mem0/history.db` (history default ANTIGO,
+    de antes de consolidarmos o path — senão a 2ª tentativa ainda bate nele)."""
+    import time
+    try:
+        ts = int(time.time())
+    except Exception:  # noqa: BLE001
+        ts = 0
+    targets = [ALUY_MEMORY_DIR, os.path.expanduser("~/.mem0/history.db")]
+    for path in targets:
+        if not os.path.exists(path):
+            continue
+        try:
+            os.rename(path, f"{path}.incompat-{ts}")
+        except OSError:
+            # rename pode falhar (cross-device/permissão) ⇒ apaga o conteúdo problemático.
+            import shutil
+            try:
+                if os.path.isdir(path):
+                    shutil.rmtree(path, ignore_errors=True)
+                else:
+                    os.remove(path)
+            except Exception:  # noqa: BLE001
+                pass
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="aluy-mem0-server")
+    parser.add_argument("--port", type=int, default=DEFAULT_PORT,
+                        help=f"Porta loopback (default: {DEFAULT_PORT})")
+    parser.add_argument("--host", type=str, default=DEFAULT_HOST,
+                        help=f"Host (default: {DEFAULT_HOST})")
+    args = parser.parse_args()
+
+    # Import lazy — só depois do venv estar configurado.
+    try:
+        from mem0 import Memory  # type: ignore[import-untyped]
+    except ImportError:
+        print("ERRO: mem0ai não instalado. Rode `aluy init` primeiro.", file=sys.stderr)
+        sys.exit(1)
+
+    # Garante o dir de store com perms corretas.
+    os.makedirs(ALUY_MEMORY_DIR, mode=0o700, exist_ok=True)
+
+    # MIGRAÇÃO DE EMBEDDER (proativa): trocar o embedder muda a DIMENSÃO do vetor (bge-m3/
+    # mxbai=1024, nomic=768). O chromadb só estoura a incompatibilidade no ADD/SEARCH (runtime),
+    # NÃO no boot — então o self-heal abaixo (que envolve só o `from_config`) não pegaria. Aqui,
+    # ANTES de subir: se o embedder mudou desde o último boot, reseta o store (a marca guarda
+    # qual embedder gerou os vetores atuais). Best-effort — nunca derruba o boot.
+    _migrate_embedder_if_changed()
+
+    # Instancia Memory() UMA vez. SELF-HEAL de upgrade: um store gravado por uma versão
+    # ANTERIOR do chromadb/mem0 pode ser ilegível pela atual (ex.: chromadb `KeyError: '_type'`
+    # na config da collection; sqlite `no such column: prev_value` no history). Em vez de
+    # CRASHAR (deixando o sidecar "fora" sem causa visível), movemos os stores antigos p/
+    # backup e RECRIAMOS frescos. Perde-se memória antiga (já ilegível de qualquer forma),
+    # mas o serviço SOBE. Achado ao vivo na máquina do dono (dois stores de jun/antigo).
+    config = _build_mem0_config()
+    try:
+        memory = Memory.from_config(config)
+    except Exception as exc:  # noqa: BLE001 — qualquer erro ao ler o store antigo
+        if os.environ.get("ALUY_MEM0_RESET_DONE") == "1":
+            # JÁ resetamos uma vez e AINDA falha ⇒ não é store velho; propaga (não loopa).
+            raise
+        sys.stderr.write(
+            f"aluy-mem0: store incompatível ({type(exc).__name__}: {exc}); "
+            "movendo p/ backup e reiniciando fresco…\n"
+        )
+        _reset_incompatible_stores()
+        # RE-EXEC em vez de retry in-process: o chromadb CACHEIA o client/conexão por
+        # processo, então um 2º `from_config` no MESMO processo reusa o store velho. Reiniciar
+        # o processo garante chromadb/mem0 FRESCOS. `ALUY_MEM0_RESET_DONE` evita loop infinito.
+        # CROSS-SO: o supervisor health-checa a PORTA (não o PID), então trocar de processo é OK
+        # em Linux/macOS/Windows. `os.execv` no Windows pode falhar em casos raros (path/quoting)
+        # — então caímos p/ um respawn via subprocess + saída limpa; e, em último caso, p/ um
+        # retry in-process (melhor um chromadb possivelmente cacheado do que o sidecar morto).
+        os.environ["ALUY_MEM0_RESET_DONE"] = "1"
+        try:
+            os.execv(sys.executable, [sys.executable, *sys.argv])
+        except Exception:  # noqa: BLE001 — execv indisponível/falhou (ex.: Windows)
+            try:
+                import subprocess
+
+                subprocess.Popen([sys.executable, *sys.argv], close_fds=True)
+                os._exit(0)  # encerra ESTE processo; o novo assume a porta
+            except Exception:  # noqa: BLE001 — sem respawn possível: tenta in-process
+                os.makedirs(ALUY_MEMORY_DIR, mode=0o700, exist_ok=True)
+                memory = Memory.from_config(config)
+            else:
+                return  # inalcançável após _exit — só p/ o type-checker
+        else:
+            return  # inalcançável (execv substitui o processo) — só p/ o type-checker
+
+    # Store criado/aberto OK com o embedder atual — grava a marca p/ detectar troca futura.
+    _write_embedder_marker()
+
+    # Injeta no handler.
+    Mem0Handler.memory = memory
+    Mem0Handler.users = _load_users()
+
+    # Cria servidor com bind explícito em loopback.
+    server = ThreadingHTTPServer((args.host, args.port), Mem0Handler)
+
+    # Graceful shutdown no SIGTERM (boot-supervisor mata com SIGTERM).
+    def _shutdown(signum: int, frame: Any) -> None:
+        print(f"\naluy-mem0-server: recebido sinal {signum}, desligando...", file=sys.stderr)
+        server.shutdown()
+    signal.signal(signal.SIGTERM, _shutdown)
+    signal.signal(signal.SIGINT, _shutdown)
+
+    print(f"aluy-mem0-server: escutando em http://{args.host}:{args.port}", file=sys.stderr)
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+        print("aluy-mem0-server: parado.", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()